add support for the AVR32 platform, namely the ATNGW100 board - joint work with wigyori
authorImre Kaloz <kaloz@openwrt.org>
Fri, 8 Jun 2007 10:44:01 +0000 (10:44 +0000)
committerImre Kaloz <kaloz@openwrt.org>
Fri, 8 Jun 2007 10:44:01 +0000 (10:44 +0000)
SVN-Revision: 7533

38 files changed:
include/kernel-defaults.mk
include/site/avr32-linux-uclibc [new file with mode: 0644]
package/base-files/Makefile
target/Config.in
target/linux/avr32-2.6/Makefile [new file with mode: 0644]
target/linux/avr32-2.6/config/default [new file with mode: 0644]
target/linux/avr32-2.6/image/Makefile [new file with mode: 0644]
target/linux/avr32-2.6/patches/100-git_sync.patch [new file with mode: 0644]
target/linux/avr32-2.6/patches/110-openwrt_flashmap.patch [new file with mode: 0644]
target/linux/generic-2.6/patches/209-mini_fo.patch
toolchain/binutils/patches/2.17/500-avr32.patch [new file with mode: 0644]
toolchain/binutils/patches/2.17/501-avr32-sreldyn-fix.patch [new file with mode: 0644]
toolchain/binutils/patches/2.17/502-avr32-bfd-dont-allow-direct-refs-to-bss.patch [new file with mode: 0644]
toolchain/binutils/patches/2.17/503-avr32-fix-got-offset-init.patch [new file with mode: 0644]
toolchain/gcc/patches/4.1.2/500-avr32.patch [new file with mode: 0644]
toolchain/uClibc/Makefile
toolchain/uClibc/config/arm
toolchain/uClibc/config/armeb
toolchain/uClibc/config/avr32 [new file with mode: 0644]
toolchain/uClibc/config/cris
toolchain/uClibc/config/i386
toolchain/uClibc/config/mips
toolchain/uClibc/config/mipsel
toolchain/uClibc/config/powerpc
toolchain/uClibc/config/x86_64
toolchain/uClibc/patches/300-let-optimized-stringops-override-default-ones.patch [new file with mode: 0644]
toolchain/uClibc/patches/301-fix-getrusage-argument-type.patch [new file with mode: 0644]
toolchain/uClibc/patches/302-fix-__libc_fcntl64-varargs-prototype.patch [new file with mode: 0644]
toolchain/uClibc/patches/303-fix-broken-__libc_open-declaration.patch [new file with mode: 0644]
toolchain/uClibc/patches/400-avr32-arch-2.patch [new file with mode: 0644]
toolchain/uClibc/patches/401-avr32-linkrelax-option.patch [new file with mode: 0644]
toolchain/uClibc/patches/402-avr32-string-ops.patch [new file with mode: 0644]
toolchain/uClibc/patches/403-no-create_module-on-avr32.patch [new file with mode: 0644]
toolchain/uClibc/patches/407-ldso-avr32-2.patch [new file with mode: 0644]
toolchain/uClibc/patches/409-ldso-avr32-startup-hack.patch [new file with mode: 0644]
toolchain/uClibc/patches/410-ldd-avr32-support.patch [new file with mode: 0644]
toolchain/uClibc/patches/411-libpthread-avr32.patch [new file with mode: 0644]
toolchain/uClibc/patches/412-sync-fcntl-h-with-linux-kernel.patch [new file with mode: 0644]

index 529b330851142f4cd258864d3a0062902354a20e..84030a6d2dc0677ba2a56b7c80c0acc943fa948a 100644 (file)
@@ -21,6 +21,9 @@ endif
 ifneq (,$(findstring ppc,$(BOARD)))
   KERNELNAME="uImage"
 endif
+ifneq (,$(findstring avr32,$(BOARD)))
+  KERNELNAME="uImage"
+endif
 
 KERNEL_MAKEOPTS := -C $(LINUX_DIR) \
        CROSS_COMPILE="$(KERNEL_CROSS)" \
diff --git a/include/site/avr32-linux-uclibc b/include/site/avr32-linux-uclibc
new file mode 100644 (file)
index 0000000..5ea2515
--- /dev/null
@@ -0,0 +1,31 @@
+#!/bin/sh
+
+ac_cv_c_littleendian=${ac_cv_c_littleendian=no}
+ac_cv_c_bigendian=${ac_cv_c_bigendian=yes}
+
+ac_cv_sizeof___int64=0
+ac_cv_sizeof_char=1
+ac_cv_sizeof_int=4
+ac_cv_sizeof_int16_t=2
+ac_cv_sizeof_int32_t=4
+ac_cv_sizeof_int64_t=8
+ac_cv_sizeof_long_int=4
+ac_cv_sizeof_long_long=8
+ac_cv_sizeof_long=4
+ac_cv_sizeof_off_t=8
+ac_cv_sizeof_short_int=2
+ac_cv_sizeof_short=2
+ac_cv_sizeof_size_t=4
+ac_cv_sizeof_u_int16_t=2
+ac_cv_sizeof_u_int32_t=4
+ac_cv_sizeof_u_int64_t=8
+ac_cv_sizeof_uint16_t=2
+ac_cv_sizeof_uint32_t=4
+ac_cv_sizeof_uint64_t=8
+ac_cv_sizeof_unsigned_int=4
+ac_cv_sizeof_unsigned_long=4
+ac_cv_sizeof_unsigned_short=2
+ac_cv_sizeof_void_p=4
+
+. $TOPDIR/include/site/linux-uclibc
+
index 8d265f07eeeb2b9d93a1c758c4f2c61b01c35cdb..cc6ce5d2a15648d85cf7a60148736ab302e85f5a 100644 (file)
@@ -72,6 +72,7 @@ endef
 define Package/libgcc
   $(call Package/gcc/Default)
   TITLE:=GCC support library
+  DEPENDS:=@!LINUX_2_6_AVR32
 endef
 
 define Package/libssp
index 780ee421fce4081ab11edfbff26a2dd9d8cbc40c..31a4e590e1a339d562e2855b11779bbd246c8b27 100644 (file)
@@ -57,6 +57,10 @@ config armeb
        select BIG_ENDIAN
        bool
 
+config avr32
+       select BIG_ENDIAN
+       bool
+
 config cris
        bool
 
@@ -92,6 +96,7 @@ config ARCH
        string
        default "arm"     if arm
        default "armeb"   if armeb
+       default "avr32"   if avr32
        default "cris"    if cris
        default "i386"    if i386
        default "m68k"    if m68k
diff --git a/target/linux/avr32-2.6/Makefile b/target/linux/avr32-2.6/Makefile
new file mode 100644 (file)
index 0000000..2dcd76a
--- /dev/null
@@ -0,0 +1,25 @@
+# 
+# Copyright (C) 2007 OpenWrt.org
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+include $(TOPDIR)/rules.mk
+
+ARCH:=avr32
+BOARD:=avr32
+BOARDNAME:=Atmel AVR32
+FEATURES:=squashfs
+
+define Target/Description
+  Build firmware images for ATNGW100 board
+endef
+
+KERNEL:=2.6
+
+include $(INCLUDE_DIR)/kernel-build.mk
+
+#include the profiles
+-include profiles/*.mk
+
+$(eval $(call BuildKernel))
diff --git a/target/linux/avr32-2.6/config/default b/target/linux/avr32-2.6/config/default
new file mode 100644 (file)
index 0000000..88c5bac
--- /dev/null
@@ -0,0 +1,85 @@
+CONFIG_AP7000_16_BIT_SMC=y
+# CONFIG_AP7000_32_BIT_SMC is not set
+# CONFIG_AP7000_8_BIT_SMC is not set
+# CONFIG_ARCH_DISCONTIGMEM_ENABLE is not set
+CONFIG_AVR32=y
+CONFIG_BOARD_ATNGW100=y
+# CONFIG_BOARD_ATSTK1000 is not set
+CONFIG_CPU_AT32AP7000=y
+CONFIG_DW_DMAC=y
+CONFIG_ENTRY_ADDRESS=0x90000000
+# CONFIG_GEN_RTC is not set
+# CONFIG_HZ_100 is not set
+CONFIG_HZ=250
+CONFIG_HZ_250=y
+# CONFIG_HW_RANDOM is not set
+# CONFIG_I2C is not set
+# CONFIG_IDE is not set
+CONFIG_INITRAMFS_SOURCE=""
+CONFIG_MACB=y
+# CONFIG_MTD_ABSENT is not set
+CONFIG_MTD_BLKDEVS=y
+# CONFIG_MTD_BLOCK2MTD is not set
+CONFIG_MTD_BLOCK=y
+# CONFIG_MTD_CFI_ADV_OPTIONS is not set
+CONFIG_MTD_CFI_AMDSTD=y
+CONFIG_MTD_CFI_I1=y
+CONFIG_MTD_CFI_I2=y
+# CONFIG_MTD_CFI_I4 is not set
+# CONFIG_MTD_CFI_I8 is not set
+# CONFIG_MTD_CFI_INTELEXT is not set
+# CONFIG_MTD_CFI_STAA is not set
+CONFIG_MTD_CFI_UTIL=y
+CONFIG_MTD_CFI=y
+CONFIG_MTD_CHAR=y
+CONFIG_MTD_CMDLINE_PARTS=y
+# CONFIG_MTD_COMPLEX_MAPPINGS is not set
+# CONFIG_MTD_CONCAT is not set
+CONFIG_MTD_DATAFLASH=y
+# CONFIG_MTD_DEBUG is not set
+# CONFIG_MTD_DOC2000 is not set
+# CONFIG_MTD_DOC2001 is not set
+# CONFIG_MTD_DOC2001PLUS is not set
+CONFIG_MTD_GEN_PROBE=y
+# CONFIG_MTD_JEDECPROBE is not set
+# CONFIG_MTD_M25P80 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
+CONFIG_MTD_MAP_BANK_WIDTH_1=y
+CONFIG_MTD_MAP_BANK_WIDTH_2=y
+# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
+CONFIG_MTD_MAP_BANK_WIDTH_4=y
+# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
+# CONFIG_MTD_MTDRAM is not set
+# CONFIG_MTD_NAND is not set
+# CONFIG_MTD_OBSOLETE_CHIPS is not set
+# CONFIG_MTD_ONENAND is not set
+CONFIG_MTD_PARTITIONS=y
+# CONFIG_MTD_PHRAM is not set
+CONFIG_MTD_PHYSMAP_BANKWIDTH=2
+CONFIG_MTD_PHYSMAP_LEN=0x0
+CONFIG_MTD_PHYSMAP_START=0x80000000
+CONFIG_MTD_PHYSMAP=y
+# CONFIG_MTD_PLATRAM is not set
+# CONFIG_MTD_RAM is not set
+# CONFIG_MTD_REDBOOT_PARTS is not set
+# CONFIG_MTD_ROM is not set
+# CONFIG_MTD_SLRAM is not set
+CONFIG_MTD_SPLIT_ROOTFS=y
+CONFIG_MTD=y
+# CONFIG_OWNERSHIP_TRACE is not set
+CONFIG_PHYS_OFFSET=0x10000000
+CONFIG_PLATFORM_AT32AP=y
+# CONFIG_RTC is not set
+# CONFIG_SERIAL_8250 is not set
+CONFIG_SERIAL_ATMEL_CONSOLE=y
+# CONFIG_SERIAL_ATMEL_TTYAT is not set
+CONFIG_SERIAL_ATMEL=y
+# CONFIG_SPI_AT25 is not set
+CONFIG_SPI_ATMEL=y
+# CONFIG_SPI_BITBANG is not set
+# CONFIG_SPI_DEBUG is not set
+CONFIG_SPI_MASTER=y
+CONFIG_SPI=y
+CONFIG_SUBARCH_AVR32B=y
+# CONFIG_UNUSED_SYMBOLS is not set
+# CONFIG_WATCHDOG is not set
diff --git a/target/linux/avr32-2.6/image/Makefile b/target/linux/avr32-2.6/image/Makefile
new file mode 100644 (file)
index 0000000..a001097
--- /dev/null
@@ -0,0 +1,37 @@
+# 
+# Copyright (C) 2007 OpenWrt.org
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+include $(TOPDIR)/rules.mk
+include $(INCLUDE_DIR)/image.mk
+
+define Image/Prepare
+       cp $(LINUX_DIR)/arch/avr32/boot/images/uImage $(KDIR)/uImage
+endef
+
+define Image/BuildKernel
+       cp $(KDIR)/uImage $(BIN_DIR)/openwrt-$(BOARD)-$(KERNEL)-uImage
+endef
+
+define Image/Build
+       $(call Image/Build/$(1),$(1))
+endef
+
+define Image/Build/squashfs
+       $(call prepare_generic_squashfs,$(KDIR)/root.squashfs)
+       ( \
+               dd if=$(KDIR)/uImage bs=1024k conv=sync; \
+               dd if=$(KDIR)/root.$(1) bs=64k conv=sync; \
+       ) > $(BIN_DIR)/openwrt-$(BOARD)-$(KERNEL)-$(1).img
+endef
+
+define Image/Build/jffs2-64k
+       ( \
+               dd if=$(KDIR)/uImage bs=1024k conv=sync; \
+               dd if=$(KDIR)/root.$(1) bs=64k conv=sync; \
+       ) > $(BIN_DIR)/openwrt-$(BOARD)-$(KERNEL)-$(1).img
+endef
+
+$(eval $(call BuildImage))
diff --git a/target/linux/avr32-2.6/patches/100-git_sync.patch b/target/linux/avr32-2.6/patches/100-git_sync.patch
new file mode 100644 (file)
index 0000000..5c5cc8e
--- /dev/null
@@ -0,0 +1,11252 @@
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atngw100/flash.c avr32-git/arch/avr32/boards/atngw100/flash.c
+--- linux-2.6.21.3/arch/avr32/boards/atngw100/flash.c  1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/boards/atngw100/flash.c       2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,95 @@
++/*
++ * ATNGW100 board-specific flash initialization
++ *
++ * Copyright (C) 2005-2006 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#include <linux/init.h>
++#include <linux/platform_device.h>
++#include <linux/mtd/mtd.h>
++#include <linux/mtd/partitions.h>
++#include <linux/mtd/physmap.h>
++
++#include <asm/arch/smc.h>
++
++static struct smc_config flash_config __initdata = {
++      .ncs_read_setup         = 0,
++      .nrd_setup              = 40,
++      .ncs_write_setup        = 0,
++      .nwe_setup              = 10,
++
++      .ncs_read_pulse         = 80,
++      .nrd_pulse              = 40,
++      .ncs_write_pulse        = 65,
++      .nwe_pulse              = 55,
++
++      .read_cycle             = 120,
++      .write_cycle            = 120,
++
++      .bus_width              = 2,
++      .nrd_controlled         = 1,
++      .nwe_controlled         = 1,
++      .byte_write             = 1,
++};
++
++static struct mtd_partition flash_parts[] = {
++      {
++              .name           = "u-boot",
++              .offset         = 0x00000000,
++              .size           = 0x00020000,           /* 128 KiB */
++              .mask_flags     = MTD_WRITEABLE,
++      },
++      {
++              .name           = "root",
++              .offset         = 0x00020000,
++              .size           = 0x007d0000,
++      },
++      {
++              .name           = "env",
++              .offset         = 0x007f0000,
++              .size           = 0x00010000,
++              .mask_flags     = MTD_WRITEABLE,
++      },
++};
++
++static struct physmap_flash_data flash_data = {
++      .width          = 2,
++      .nr_parts       = ARRAY_SIZE(flash_parts),
++      .parts          = flash_parts,
++};
++
++static struct resource flash_resource = {
++      .start          = 0x00000000,
++      .end            = 0x007fffff,
++      .flags          = IORESOURCE_MEM,
++};
++
++static struct platform_device flash_device = {
++      .name           = "physmap-flash",
++      .id             = 0,
++      .resource       = &flash_resource,
++      .num_resources  = 1,
++      .dev            = {
++              .platform_data = &flash_data,
++      },
++};
++
++/* This needs to be called after the SMC has been initialized */
++static int __init atngw100_flash_init(void)
++{
++      int ret;
++
++      ret = smc_set_configuration(0, &flash_config);
++      if (ret < 0) {
++              printk(KERN_ERR "atngw100: failed to set NOR flash timing\n");
++              return ret;
++      }
++
++      platform_device_register(&flash_device);
++
++      return 0;
++}
++device_initcall(atngw100_flash_init);
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atngw100/Makefile avr32-git/arch/avr32/boards/atngw100/Makefile
+--- linux-2.6.21.3/arch/avr32/boards/atngw100/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/boards/atngw100/Makefile      2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1 @@
++obj-y                         += setup.o flash.o
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atngw100/setup.c avr32-git/arch/avr32/boards/atngw100/setup.c
+--- linux-2.6.21.3/arch/avr32/boards/atngw100/setup.c  1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/boards/atngw100/setup.c       2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,131 @@
++/*
++ * Board-specific setup code for the ATNGW100 Network Gateway
++ *
++ * Copyright (C) 2005-2006 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#include <linux/clk.h>
++#include <linux/etherdevice.h>
++#include <linux/init.h>
++#include <linux/linkage.h>
++#include <linux/platform_device.h>
++#include <linux/types.h>
++#include <linux/spi/spi.h>
++
++#include <asm/io.h>
++#include <asm/setup.h>
++
++#include <asm/arch/at32ap7000.h>
++#include <asm/arch/board.h>
++#include <asm/arch/init.h>
++
++/* Initialized by bootloader-specific startup code. */
++struct tag *bootloader_tags __initdata;
++
++struct eth_addr {
++      u8 addr[6];
++};
++static struct eth_addr __initdata hw_addr[2];
++static struct eth_platform_data __initdata eth_data[2];
++
++static struct spi_board_info spi0_board_info[] __initdata = {
++      {
++              .modalias       = "mtd_dataflash",
++              .max_speed_hz   = 10000000,
++              .chip_select    = 0,
++      },
++};
++
++static struct mci_platform_data __initdata mci0_data = {
++      .detect_pin     = GPIO_PIN_PC(25),
++      .wp_pin         = GPIO_PIN_PE(0),
++};
++
++/*
++ * The next two functions should go away as the boot loader is
++ * supposed to initialize the macb address registers with a valid
++ * ethernet address. But we need to keep it around for a while until
++ * we can be reasonably sure the boot loader does this.
++ *
++ * The phy_id is ignored as the driver will probe for it.
++ */
++static int __init parse_tag_ethernet(struct tag *tag)
++{
++      int i;
++
++      i = tag->u.ethernet.mac_index;
++      if (i < ARRAY_SIZE(hw_addr))
++              memcpy(hw_addr[i].addr, tag->u.ethernet.hw_address,
++                     sizeof(hw_addr[i].addr));
++
++      return 0;
++}
++__tagtable(ATAG_ETHERNET, parse_tag_ethernet);
++
++static void __init set_hw_addr(struct platform_device *pdev)
++{
++      struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++      const u8 *addr;
++      void __iomem *regs;
++      struct clk *pclk;
++
++      if (!res)
++              return;
++      if (pdev->id >= ARRAY_SIZE(hw_addr))
++              return;
++
++      addr = hw_addr[pdev->id].addr;
++      if (!is_valid_ether_addr(addr))
++              return;
++
++      /*
++       * Since this is board-specific code, we'll cheat and use the
++       * physical address directly as we happen to know that it's
++       * the same as the virtual address.
++       */
++      regs = (void __iomem __force *)res->start;
++      pclk = clk_get(&pdev->dev, "pclk");
++      if (!pclk)
++              return;
++
++      clk_enable(pclk);
++      __raw_writel((addr[3] << 24) | (addr[2] << 16)
++                   | (addr[1] << 8) | addr[0], regs + 0x98);
++      __raw_writel((addr[5] << 8) | addr[4], regs + 0x9c);
++      clk_disable(pclk);
++      clk_put(pclk);
++}
++
++struct platform_device *at32_usart_map[1];
++unsigned int at32_nr_usarts = 1;
++
++void __init setup_board(void)
++{
++      at32_map_usart(1, 0);   /* USART 1: /dev/ttyS0, DB9 */
++      at32_setup_serial_console(0);
++}
++
++static int __init atngw100_init(void)
++{
++      /*
++       * ATNGW100 uses 16-bit SDRAM interface, so we don't need to
++       * reserve any pins for it.
++       */
++
++      at32_add_system_devices();
++
++      at32_add_device_usart(0);
++
++      set_hw_addr(at32_add_device_eth(0, &eth_data[0]));
++      set_hw_addr(at32_add_device_eth(1, &eth_data[1]));
++
++      at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info));
++      at32_add_device_mci(0, &mci0_data);
++      at32_add_device_usba(0);
++
++      return 0;
++}
++postcore_initcall(atngw100_init);
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1000.h avr32-git/arch/avr32/boards/atstk1000/atstk1000.h
+--- linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1000.h     1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/boards/atstk1000/atstk1000.h  2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,15 @@
++/*
++ * ATSTK1000 setup code: Daughterboard interface
++ *
++ * Copyright (C) 2007 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#ifndef __ARCH_AVR32_BOARDS_ATSTK1000_ATSTK1000_H
++#define __ARCH_AVR32_BOARDS_ATSTK1000_ATSTK1000_H
++
++extern struct atmel_lcdfb_info atstk1000_lcdc_data;
++
++#endif /* __ARCH_AVR32_BOARDS_ATSTK1000_ATSTK1000_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1002.c avr32-git/arch/avr32/boards/atstk1000/atstk1002.c
+--- linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1002.c     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/boards/atstk1000/atstk1002.c  2007-06-06 11:33:46.000000000 +0200
+@@ -16,6 +16,8 @@
+ #include <linux/types.h>
+ #include <linux/spi/spi.h>
++#include <video/atmel_lcdc.h>
++
+ #include <asm/io.h>
+ #include <asm/setup.h>
+ #include <asm/arch/at32ap7000.h>
+@@ -23,6 +25,7 @@
+ #include <asm/arch/init.h>
+ #include <asm/arch/portmux.h>
++#include "atstk1000.h"
+ #define       SW2_DEFAULT             /* MMCI and UART_A available */
+@@ -31,9 +34,7 @@
+ };
+ static struct eth_addr __initdata hw_addr[2];
+-
+ static struct eth_platform_data __initdata eth_data[2];
+-extern struct lcdc_platform_data atstk1000_fb0_data;
+ static struct spi_board_info spi0_board_info[] __initdata = {
+       {
+@@ -41,9 +42,15 @@
+               .modalias       = "ltv350qv",
+               .max_speed_hz   = 16000000,
+               .chip_select    = 1,
++              .mode           = SPI_MODE_3,
+       },
+ };
++static struct mci_platform_data __initdata mci0_data = {
++      .detect_pin     = GPIO_PIN_NONE,
++      .wp_pin         = GPIO_PIN_NONE,
++};
++
+ /*
+  * The next two functions should go away as the boot loader is
+  * supposed to initialize the macb address registers with a valid
+@@ -148,7 +155,12 @@
+       set_hw_addr(at32_add_device_eth(0, &eth_data[0]));
+       at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info));
+-      at32_add_device_lcdc(0, &atstk1000_fb0_data);
++      at32_add_device_twi(0);
++      at32_add_device_mci(0, &mci0_data);
++      at32_add_device_lcdc(0, &atstk1000_lcdc_data,
++                           fbmem_start, fbmem_size);
++      at32_add_device_usba(0);
++      at32_add_device_abdac(0);
+       return 0;
+ }
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atstk1000/setup.c avr32-git/arch/avr32/boards/atstk1000/setup.c
+--- linux-2.6.21.3/arch/avr32/boards/atstk1000/setup.c 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/boards/atstk1000/setup.c      2007-06-06 11:33:46.000000000 +0200
+@@ -8,43 +8,56 @@
+  * published by the Free Software Foundation.
+  */
+ #include <linux/bootmem.h>
++#include <linux/fb.h>
+ #include <linux/init.h>
+ #include <linux/types.h>
+ #include <linux/linkage.h>
+-#include <asm/setup.h>
++#include <video/atmel_lcdc.h>
++#include <asm/setup.h>
+ #include <asm/arch/board.h>
++#include "atstk1000.h"
++
+ /* Initialized by bootloader-specific startup code. */
+ struct tag *bootloader_tags __initdata;
+-struct lcdc_platform_data __initdata atstk1000_fb0_data;
+-
+-void __init board_setup_fbmem(unsigned long fbmem_start,
+-                            unsigned long fbmem_size)
+-{
+-      if (!fbmem_size)
+-              return;
+-
+-      if (!fbmem_start) {
+-              void *fbmem;
+-
+-              fbmem = alloc_bootmem_low_pages(fbmem_size);
+-              fbmem_start = __pa(fbmem);
+-      } else {
+-              pg_data_t *pgdat;
+-
+-              for_each_online_pgdat(pgdat) {
+-                      if (fbmem_start >= pgdat->bdata->node_boot_start
+-                          && fbmem_start <= pgdat->bdata->node_low_pfn)
+-                              reserve_bootmem_node(pgdat, fbmem_start,
+-                                                   fbmem_size);
+-              }
+-      }
+-
+-      printk("%luKiB framebuffer memory at address 0x%08lx\n",
+-             fbmem_size >> 10, fbmem_start);
+-      atstk1000_fb0_data.fbmem_start = fbmem_start;
+-      atstk1000_fb0_data.fbmem_size = fbmem_size;
+-}
++static struct fb_videomode __initdata ltv350qv_modes[] = {
++      {
++              .name           = "320x240 @ 75",
++              .refresh        = 75,
++              .xres           = 320,          .yres           = 240,
++              .pixclock       = KHZ2PICOS(6891),
++
++              .left_margin    = 17,           .right_margin   = 33,
++              .upper_margin   = 10,           .lower_margin   = 10,
++              .hsync_len      = 16,           .vsync_len      = 1,
++
++              .sync           = 0,
++              .vmode          = FB_VMODE_NONINTERLACED,
++      },
++};
++
++static struct fb_monspecs __initdata atstk1000_default_monspecs = {
++      .manufacturer           = "SNG",
++      .monitor                = "LTV350QV",
++      .modedb                 = ltv350qv_modes,
++      .modedb_len             = ARRAY_SIZE(ltv350qv_modes),
++      .hfmin                  = 14820,
++      .hfmax                  = 22230,
++      .vfmin                  = 60,
++      .vfmax                  = 90,
++      .dclkmax                = 30000000,
++};
++
++struct atmel_lcdfb_info __initdata atstk1000_lcdc_data = {
++      .default_bpp            = 24,
++      .default_dmacon         = ATMEL_LCDC_DMAEN | ATMEL_LCDC_DMA2DEN,
++      .default_lcdcon2        = (ATMEL_LCDC_DISTYPE_TFT
++                                 | ATMEL_LCDC_INVCLK
++                                 | ATMEL_LCDC_CLKMOD_ALWAYSACTIVE
++                                 | ATMEL_LCDC_MEMOR_BIG),
++      .default_monspecs       = &atstk1000_default_monspecs,
++      .guard_time             = 2,
++};
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/dw-dmac.c avr32-git/arch/avr32/drivers/dw-dmac.c
+--- linux-2.6.21.3/arch/avr32/drivers/dw-dmac.c        1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/drivers/dw-dmac.c     2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,761 @@
++/*
++ * Driver for the Synopsys DesignWare DMA Controller
++ *
++ * Copyright (C) 2005-2006 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#include <linux/clk.h>
++#include <linux/device.h>
++#include <linux/dma-mapping.h>
++#include <linux/dmapool.h>
++#include <linux/init.h>
++#include <linux/interrupt.h>
++#include <linux/module.h>
++#include <linux/platform_device.h>
++
++#include <asm/dma-controller.h>
++#include <asm/io.h>
++
++#include "dw-dmac.h"
++
++#define DMAC_NR_CHANNELS 3
++#define DMAC_MAX_BLOCKSIZE 4095
++
++enum {
++      CH_STATE_FREE = 0,
++      CH_STATE_ALLOCATED,
++      CH_STATE_BUSY,
++};
++
++struct dw_dma_lli {
++      dma_addr_t      sar;
++      dma_addr_t      dar;
++      dma_addr_t      llp;
++      u32             ctllo;
++      u32             ctlhi;
++      u32             sstat;
++      u32             dstat;
++};
++
++struct dw_dma_block {
++      struct dw_dma_lli *lli_vaddr;
++      dma_addr_t lli_dma_addr;
++};
++
++struct dw_dma_channel {
++      unsigned int state;
++        int is_cyclic;
++      struct dma_request_sg *req_sg;
++      struct dma_request_cyclic *req_cyclic;
++      unsigned int nr_blocks;
++      int direction;
++      struct dw_dma_block *block;
++};
++
++struct dw_dma_controller {
++      spinlock_t lock;
++      void * __iomem  regs;
++      struct dma_pool *lli_pool;
++      struct clk *hclk;
++      struct dma_controller dma;
++      struct dw_dma_channel channel[DMAC_NR_CHANNELS];
++};
++#define to_dw_dmac(dmac) container_of(dmac, struct dw_dma_controller, dma)
++
++#define dmac_writel_hi(dmac, reg, value) \
++      __raw_writel((value), (dmac)->regs + DW_DMAC_##reg + 4)
++#define dmac_readl_hi(dmac, reg) \
++      __raw_readl((dmac)->regs + DW_DMAC_##reg + 4)
++#define dmac_writel_lo(dmac, reg, value) \
++      __raw_writel((value), (dmac)->regs + DW_DMAC_##reg)
++#define dmac_readl_lo(dmac, reg) \
++      __raw_readl((dmac)->regs + DW_DMAC_##reg)
++#define dmac_chan_writel_hi(dmac, chan, reg, value) \
++      __raw_writel((value), ((dmac)->regs + 0x58 * (chan) \
++                             + DW_DMAC_CHAN_##reg + 4))
++#define dmac_chan_readl_hi(dmac, chan, reg) \
++      __raw_readl((dmac)->regs + 0x58 * (chan) + DW_DMAC_CHAN_##reg + 4)
++#define dmac_chan_writel_lo(dmac, chan, reg, value) \
++      __raw_writel((value), (dmac)->regs + 0x58 * (chan) + DW_DMAC_CHAN_##reg)
++#define dmac_chan_readl_lo(dmac, chan, reg) \
++      __raw_readl((dmac)->regs + 0x58 * (chan) + DW_DMAC_CHAN_##reg)
++#define set_channel_bit(dmac, reg, chan) \
++      dmac_writel_lo(dmac, reg, (1 << (chan)) | (1 << ((chan) + 8)))
++#define clear_channel_bit(dmac, reg, chan) \
++      dmac_writel_lo(dmac, reg, (0 << (chan)) | (1 << ((chan) + 8)))
++
++static int dmac_alloc_channel(struct dma_controller *_dmac)
++{
++      struct dw_dma_controller *dmac = to_dw_dmac(_dmac);
++      struct dw_dma_channel *chan;
++      unsigned long flags;
++      int i;
++
++      spin_lock_irqsave(&dmac->lock, flags);
++      for (i = 0; i < DMAC_NR_CHANNELS; i++)
++              if (dmac->channel[i].state == CH_STATE_FREE)
++                      break;
++
++      if (i < DMAC_NR_CHANNELS) {
++              chan = &dmac->channel[i];
++              chan->state = CH_STATE_ALLOCATED;
++      } else {
++              i = -EBUSY;
++      }
++
++      spin_unlock_irqrestore(&dmac->lock, flags);
++
++      return i;
++}
++
++static void dmac_release_channel(struct dma_controller *_dmac, int channel)
++{
++      struct dw_dma_controller *dmac = to_dw_dmac(_dmac);
++
++      BUG_ON(channel >= DMAC_NR_CHANNELS
++             || dmac->channel[channel].state != CH_STATE_ALLOCATED);
++
++      dmac->channel[channel].state = CH_STATE_FREE;
++}
++
++static struct dw_dma_block *allocate_blocks(struct dw_dma_controller *dmac,
++                                          unsigned int nr_blocks)
++{
++      struct dw_dma_block *block;
++      void *p;
++      unsigned int i;
++
++      block = kmalloc(nr_blocks * sizeof(*block),
++                      GFP_KERNEL);
++      if (unlikely(!block))
++              return NULL;
++
++      for (i = 0; i < nr_blocks; i++) {
++              p = dma_pool_alloc(dmac->lli_pool, GFP_KERNEL,
++                                 &block[i].lli_dma_addr);
++              block[i].lli_vaddr = p;
++              if (unlikely(!p))
++                      goto fail;
++      }
++
++      return block;
++
++fail:
++      for (i = 0; i < nr_blocks; i++) {
++              if (!block[i].lli_vaddr)
++                      break;
++              dma_pool_free(dmac->lli_pool, block[i].lli_vaddr,
++                            block[i].lli_dma_addr);
++      }
++      kfree(block);
++      return NULL;
++}
++
++static void cleanup_channel(struct dw_dma_controller *dmac,
++                          struct dw_dma_channel *chan)
++{
++      unsigned int i;
++
++      if (chan->nr_blocks > 1) {
++              for (i = 0; i < chan->nr_blocks; i++)
++                      dma_pool_free(dmac->lli_pool, chan->block[i].lli_vaddr,
++                                    chan->block[i].lli_dma_addr);
++              kfree(chan->block);
++      }
++
++      chan->state = CH_STATE_ALLOCATED;
++}
++
++static int dmac_prepare_request_sg(struct dma_controller *_dmac,
++                                 struct dma_request_sg *req)
++{
++      struct dw_dma_controller *dmac = to_dw_dmac(_dmac);
++      struct dw_dma_channel *chan;
++      unsigned long ctlhi, ctllo, cfghi, cfglo;
++      unsigned long block_size;
++      unsigned int nr_blocks;
++      int ret, i, direction;
++      unsigned long flags;
++
++      spin_lock_irqsave(&dmac->lock, flags);
++
++      ret = -EINVAL;
++      if (req->req.channel >= DMAC_NR_CHANNELS
++          || dmac->channel[req->req.channel].state != CH_STATE_ALLOCATED
++          || req->block_size > DMAC_MAX_BLOCKSIZE) {
++              spin_unlock_irqrestore(&dmac->lock, flags);
++              return -EINVAL;
++      }
++
++      chan = &dmac->channel[req->req.channel];
++      chan->state = CH_STATE_BUSY;
++      chan->req_sg = req;
++      chan->is_cyclic = 0;
++
++      /*
++       * We have marked the channel as busy, so no need to keep the
++       * lock as long as we only touch the channel-specific
++       * registers
++       */
++      spin_unlock_irqrestore(&dmac->lock, flags);
++
++      /*
++       * There may be limitations in the driver and/or the DMA
++       * controller that prevents us from sending a whole
++       * scatterlist item in one go.  Taking this into account,
++       * calculate the number of block transfers we need to set up.
++       *
++       * FIXME: Let the peripheral driver know about the maximum
++       * block size we support. We really don't want to use a
++       * different block size than what was suggested by the
++       * peripheral.
++       *
++       * Each block will get its own Linked List Item (LLI) below.
++       */
++      block_size = req->block_size;
++      nr_blocks = req->nr_blocks;
++      pr_debug("block_size %lu, nr_blocks %u nr_sg = %u\n",
++               block_size, nr_blocks, req->nr_sg);
++
++      BUG_ON(nr_blocks == 0);
++      chan->nr_blocks = nr_blocks;
++
++      ret = -EINVAL;
++      cfglo = cfghi = 0;
++      switch (req->direction) {
++      case DMA_DIR_MEM_TO_PERIPH:
++              direction = DMA_TO_DEVICE;
++              cfghi = req->periph_id << (43 - 32);
++              break;
++
++      case DMA_DIR_PERIPH_TO_MEM:
++              direction = DMA_FROM_DEVICE;
++              cfghi = req->periph_id << (39 - 32);
++              break;
++      default:
++              goto out_unclaim_channel;
++      }
++
++        chan->direction = direction;
++
++      dmac_chan_writel_hi(dmac, req->req.channel, CFG, cfghi);
++      dmac_chan_writel_lo(dmac, req->req.channel, CFG, cfglo);
++
++      ctlhi = block_size >> req->width;
++      ctllo = ((req->direction << 20)
++               // | (1 << 14) | (1 << 11) // source/dest burst trans len
++               | (req->width << 4) | (req->width << 1)
++               | (1 << 0));            // interrupt enable
++
++      if (nr_blocks == 1) {
++              /* Only one block: No need to use block chaining */
++              if (direction == DMA_TO_DEVICE) {
++                      dmac_chan_writel_lo(dmac, req->req.channel, SAR,
++                                          req->sg->dma_address);
++                      dmac_chan_writel_lo(dmac, req->req.channel, DAR,
++                                          req->data_reg);
++                      ctllo |= 2 << 7; // no dst increment
++              } else {
++                      dmac_chan_writel_lo(dmac, req->req.channel, SAR,
++                                          req->data_reg);
++                      dmac_chan_writel_lo(dmac, req->req.channel, DAR,
++                                          req->sg->dma_address);
++                      ctllo |= 2 << 9; // no src increment
++              }
++              dmac_chan_writel_lo(dmac, req->req.channel, CTL, ctllo);
++              dmac_chan_writel_hi(dmac, req->req.channel, CTL, ctlhi);
++              pr_debug("ctl hi:lo 0x%lx:%lx\n", ctlhi, ctllo);
++      } else {
++              struct dw_dma_lli *lli, *lli_prev = NULL;
++              int j = 0, offset = 0;
++
++              ret = -ENOMEM;
++              chan->block = allocate_blocks(dmac, nr_blocks);
++              if (!chan->block)
++                      goto out_unclaim_channel;
++
++              if (direction == DMA_TO_DEVICE)
++                      ctllo |= 1 << 28 | 1 << 27 | 2 << 7;
++              else
++                      ctllo |= 1 << 28 | 1 << 27 | 2 << 9;
++
++              /*
++               * Map scatterlist items to blocks. One scatterlist
++               * item may need more than one block for the reasons
++               * mentioned above.
++               */
++              for (i = 0; i < nr_blocks; i++) {
++                      lli = chan->block[i].lli_vaddr;
++                      if (lli_prev) {
++                              lli_prev->llp = chan->block[i].lli_dma_addr;
++                              pr_debug("lli[%d] (0x%p/0x%x): 0x%x 0x%x 0x%x 0x%x 0x%x\n",
++                                       i - 1, chan->block[i - 1].lli_vaddr,
++                                       chan->block[i - 1].lli_dma_addr,
++                                       lli_prev->sar, lli_prev->dar, lli_prev->llp,
++                                       lli_prev->ctllo, lli_prev->ctlhi);
++                      }
++                      lli->llp = 0;
++                      lli->ctllo = ctllo;
++                      lli->ctlhi = ctlhi;
++                      if (direction == DMA_TO_DEVICE) {
++                              lli->sar = req->sg[j].dma_address + offset;
++                              lli->dar = req->data_reg;
++                      } else {
++                              lli->sar = req->data_reg;
++                              lli->dar = req->sg[j].dma_address + offset;
++                      }
++                      lli_prev = lli;
++
++                      offset += block_size;
++                      if (offset > req->sg[j].length) {
++                              j++;
++                              offset = 0;
++                      }
++              }
++
++              pr_debug("lli[%d] (0x%p/0x%x): 0x%x 0x%x 0x%x 0x%x 0x%x\n",
++                       i - 1, chan->block[i - 1].lli_vaddr,
++                       chan->block[i - 1].lli_dma_addr, lli_prev->sar,
++                       lli_prev->dar, lli_prev->llp,
++                       lli_prev->ctllo, lli_prev->ctlhi);
++
++              /*
++               * SAR, DAR and CTL are initialized from the LLI. We
++               * only have to enable the LLI bits in CTL.
++               */
++              dmac_chan_writel_hi(dmac, req->req.channel, CTL, 0);
++              dmac_chan_writel_lo(dmac, req->req.channel, LLP,
++                                  chan->block[0].lli_dma_addr);
++              dmac_chan_writel_lo(dmac, req->req.channel, CTL, 1 << 28 | 1 << 27);
++      }
++
++      set_channel_bit(dmac, MASK_XFER, req->req.channel);
++      set_channel_bit(dmac, MASK_ERROR, req->req.channel);
++      if (req->req.block_complete)
++              set_channel_bit(dmac, MASK_BLOCK, req->req.channel);
++      else
++              clear_channel_bit(dmac, MASK_BLOCK, req->req.channel);
++
++      return 0;
++
++out_unclaim_channel:
++      chan->state = CH_STATE_ALLOCATED;
++      return ret;
++}
++
++static int dmac_prepare_request_cyclic(struct dma_controller *_dmac,
++                                       struct dma_request_cyclic *req)
++{
++      struct dw_dma_controller *dmac = to_dw_dmac(_dmac);
++      struct dw_dma_channel *chan;
++      unsigned long ctlhi, ctllo, cfghi, cfglo;
++      unsigned long block_size;
++      int ret, i, direction;
++      unsigned long flags;
++
++      spin_lock_irqsave(&dmac->lock, flags);
++
++        block_size = (req->buffer_size/req->periods) >> req->width;
++
++      ret = -EINVAL;
++      if (req->req.channel >= DMAC_NR_CHANNELS
++          || dmac->channel[req->req.channel].state != CH_STATE_ALLOCATED
++            || (req->periods == 0)
++          || block_size > DMAC_MAX_BLOCKSIZE) {
++              spin_unlock_irqrestore(&dmac->lock, flags);
++              return -EINVAL;
++      }
++
++      chan = &dmac->channel[req->req.channel];
++      chan->state = CH_STATE_BUSY;
++      chan->is_cyclic = 1;
++        chan->req_cyclic = req;
++
++      /*
++       * We have marked the channel as busy, so no need to keep the
++       * lock as long as we only touch the channel-specific
++       * registers
++       */
++      spin_unlock_irqrestore(&dmac->lock, flags);
++
++      /*
++          Setup
++       */
++      BUG_ON(req->buffer_size % req->periods);
++      /* printk(KERN_INFO "block_size = %lu, periods = %u\n", block_size, req->periods); */
++
++      chan->nr_blocks = req->periods;
++
++      ret = -EINVAL;
++      cfglo = cfghi = 0;
++      switch (req->direction) {
++      case DMA_DIR_MEM_TO_PERIPH:
++              direction = DMA_TO_DEVICE;
++              cfghi = req->periph_id << (43 - 32);
++              break;
++
++      case DMA_DIR_PERIPH_TO_MEM:
++              direction = DMA_FROM_DEVICE;
++              cfghi = req->periph_id << (39 - 32);
++              break;
++      default:
++              goto out_unclaim_channel;
++      }
++
++        chan->direction = direction;
++
++      dmac_chan_writel_hi(dmac, req->req.channel, CFG, cfghi);
++      dmac_chan_writel_lo(dmac, req->req.channel, CFG, cfglo);
++
++      ctlhi = block_size;
++      ctllo = ((req->direction << 20)
++               | (req->width << 4) | (req->width << 1)
++               | (1 << 0));            // interrupt enable
++
++        {
++              struct dw_dma_lli *lli = NULL, *lli_prev = NULL;
++
++              ret = -ENOMEM;
++              chan->block = allocate_blocks(dmac, req->periods);
++              if (!chan->block)
++                      goto out_unclaim_channel;
++
++              if (direction == DMA_TO_DEVICE)
++                      ctllo |= 1 << 28 | 1 << 27 | 2 << 7;
++              else
++                      ctllo |= 1 << 28 | 1 << 27 | 2 << 9;
++
++              /*
++               * Set up a linked list items where each period gets
++               * an item. The linked list item for the last period
++               * points back to the star of the buffer making a
++               * cyclic buffer.
++               */
++              for (i = 0; i < req->periods; i++) {
++                      lli = chan->block[i].lli_vaddr;
++                      if (lli_prev) {
++                              lli_prev->llp = chan->block[i].lli_dma_addr;
++                              /* printk(KERN_INFO "lli[%d] (0x%p/0x%x): 0x%x 0x%x 0x%x 0x%x 0x%x\n",
++                                 i - 1, chan->block[i - 1].lli_vaddr,
++                                 chan->block[i - 1].lli_dma_addr,
++                                 lli_prev->sar, lli_prev->dar, lli_prev->llp,
++                                 lli_prev->ctllo, lli_prev->ctlhi);*/
++                      }
++                      lli->llp = 0;
++                      lli->ctllo = ctllo;
++                      lli->ctlhi = ctlhi;
++                      if (direction == DMA_TO_DEVICE) {
++                              lli->sar = req->buffer_start + i*(block_size << req->width);
++                              lli->dar = req->data_reg;
++                      } else {
++                              lli->sar = req->data_reg;
++                              lli->dar = req->buffer_start + i*(block_size << req->width);
++                      }
++                      lli_prev = lli;
++              }
++              lli->llp = chan->block[0].lli_dma_addr;
++
++              /*printk(KERN_INFO "lli[%d] (0x%p/0x%x): 0x%x 0x%x 0x%x 0x%x 0x%x\n",
++                i - 1, chan->block[i - 1].lli_vaddr,
++                chan->block[i - 1].lli_dma_addr, lli_prev->sar,
++                lli_prev->dar, lli_prev->llp,
++                lli_prev->ctllo, lli_prev->ctlhi); */
++
++              /*
++               * SAR, DAR and CTL are initialized from the LLI. We
++               * only have to enable the LLI bits in CTL.
++               */
++              dmac_chan_writel_lo(dmac, req->req.channel, LLP,
++                                  chan->block[0].lli_dma_addr);
++              dmac_chan_writel_lo(dmac, req->req.channel, CTL, 1 << 28 | 1 << 27);
++      }
++
++      clear_channel_bit(dmac, MASK_XFER, req->req.channel);
++      set_channel_bit(dmac, MASK_ERROR, req->req.channel);
++      if (req->req.block_complete)
++              set_channel_bit(dmac, MASK_BLOCK, req->req.channel);
++      else
++              clear_channel_bit(dmac, MASK_BLOCK, req->req.channel);
++
++      return 0;
++
++out_unclaim_channel:
++      chan->state = CH_STATE_ALLOCATED;
++      return ret;
++}
++
++static int dmac_start_request(struct dma_controller *_dmac,
++                            unsigned int channel)
++{
++      struct dw_dma_controller *dmac = to_dw_dmac(_dmac);
++
++      BUG_ON(channel >= DMAC_NR_CHANNELS);
++
++      set_channel_bit(dmac, CH_EN, channel);
++
++      return 0;
++}
++
++static dma_addr_t dmac_get_current_pos(struct dma_controller *_dmac,
++                                       unsigned int channel)
++{
++      struct dw_dma_controller *dmac = to_dw_dmac(_dmac);
++      struct dw_dma_channel *chan;
++        dma_addr_t current_pos;
++
++      BUG_ON(channel >= DMAC_NR_CHANNELS);
++
++        chan = &dmac->channel[channel];
++
++      switch (chan->direction) {
++      case DMA_TO_DEVICE:
++              current_pos = dmac_chan_readl_lo(dmac, channel, SAR);
++              break;
++      case DMA_FROM_DEVICE:
++              current_pos = dmac_chan_readl_lo(dmac, channel, DAR);
++              break;
++      default:
++              return 0;
++      }
++
++
++        if (!current_pos) {
++              if (chan->is_cyclic) {
++                      current_pos = chan->req_cyclic->buffer_start;
++              } else {
++                      current_pos = chan->req_sg->sg->dma_address;
++              }
++      }
++
++      return current_pos;
++}
++
++
++static int dmac_stop_request(struct dma_controller *_dmac,
++                             unsigned int channel)
++{
++      struct dw_dma_controller *dmac = to_dw_dmac(_dmac);
++      struct dw_dma_channel *chan;
++
++      BUG_ON(channel >= DMAC_NR_CHANNELS);
++
++      chan = &dmac->channel[channel];
++      pr_debug("stop: st%u s%08x d%08x l%08x ctl0x%08x:0x%08x\n",
++               chan->state, dmac_chan_readl_lo(dmac, channel, SAR),
++               dmac_chan_readl_lo(dmac, channel, DAR),
++               dmac_chan_readl_lo(dmac, channel, LLP),
++               dmac_chan_readl_hi(dmac, channel, CTL),
++               dmac_chan_readl_lo(dmac, channel, CTL));
++
++      if (chan->state == CH_STATE_BUSY) {
++              clear_channel_bit(dmac, CH_EN, channel);
++              cleanup_channel(dmac, &dmac->channel[channel]);
++      }
++
++      return 0;
++}
++
++
++static void dmac_block_complete(struct dw_dma_controller *dmac)
++{
++      struct dw_dma_channel *chan;
++      unsigned long status, chanid;
++
++      status = dmac_readl_lo(dmac, STATUS_BLOCK);
++
++      while (status) {
++              struct dma_request *req;
++              chanid = __ffs(status);
++              chan = &dmac->channel[chanid];
++
++                if (chan->is_cyclic) {
++                      BUG_ON(!chan->req_cyclic
++                             || !chan->req_cyclic->req.block_complete);
++                      req = &chan->req_cyclic->req;
++                } else {
++                      BUG_ON(!chan->req_sg || !chan->req_sg->req.block_complete);
++                      req = &chan->req_sg->req;
++                }
++              dmac_writel_lo(dmac, CLEAR_BLOCK, 1 << chanid);
++              req->block_complete(req);
++              status = dmac_readl_lo(dmac, STATUS_BLOCK);
++      }
++}
++
++static void dmac_xfer_complete(struct dw_dma_controller *dmac)
++{
++      struct dw_dma_channel *chan;
++      struct dma_request *req;
++      unsigned long status, chanid;
++
++      status = dmac_readl_lo(dmac, STATUS_XFER);
++
++      while (status) {
++              chanid = __ffs(status);
++              chan = &dmac->channel[chanid];
++
++              dmac_writel_lo(dmac, CLEAR_XFER, 1 << chanid);
++
++                req = &chan->req_sg->req;
++                BUG_ON(!req);
++                cleanup_channel(dmac, chan);
++                if (req->xfer_complete)
++                      req->xfer_complete(req);
++
++              status = dmac_readl_lo(dmac, STATUS_XFER);
++      }
++}
++
++static void dmac_error(struct dw_dma_controller *dmac)
++{
++      struct dw_dma_channel *chan;
++      unsigned long status, chanid;
++
++      status = dmac_readl_lo(dmac, STATUS_ERROR);
++
++      while (status) {
++              struct dma_request *req;
++
++              chanid = __ffs(status);
++              chan = &dmac->channel[chanid];
++
++              dmac_writel_lo(dmac, CLEAR_ERROR, 1 << chanid);
++              clear_channel_bit(dmac, CH_EN, chanid);
++
++                if (chan->is_cyclic) {
++                      BUG_ON(!chan->req_cyclic);
++                      req = &chan->req_cyclic->req;
++                } else {
++                      BUG_ON(!chan->req_sg);
++                      req = &chan->req_sg->req;
++                }
++
++              cleanup_channel(dmac, chan);
++              if (req->error)
++                      req->error(req);
++
++              status = dmac_readl_lo(dmac, STATUS_XFER);
++      }
++}
++
++static irqreturn_t dmac_interrupt(int irq, void *dev_id)
++{
++      struct dw_dma_controller *dmac = dev_id;
++      unsigned long status;
++      int ret = IRQ_NONE;
++
++      spin_lock(&dmac->lock);
++
++      status = dmac_readl_lo(dmac, STATUS_INT);
++
++      while (status) {
++              ret = IRQ_HANDLED;
++              if (status & 0x10)
++                      dmac_error(dmac);
++              if (status & 0x02)
++                      dmac_block_complete(dmac);
++              if (status & 0x01)
++                      dmac_xfer_complete(dmac);
++
++              status = dmac_readl_lo(dmac, STATUS_INT);
++      }
++
++      spin_unlock(&dmac->lock);
++      return ret;
++}
++
++static int __devinit dmac_probe(struct platform_device *pdev)
++{
++      struct dw_dma_controller *dmac;
++      struct resource *regs;
++      int ret;
++
++      regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++      if (!regs)
++              return -ENXIO;
++
++      dmac = kmalloc(sizeof(*dmac), GFP_KERNEL);
++      if (!dmac)
++              return -ENOMEM;
++      memset(dmac, 0, sizeof(*dmac));
++
++      dmac->hclk = clk_get(&pdev->dev, "hclk");
++      if (IS_ERR(dmac->hclk)) {
++              ret = PTR_ERR(dmac->hclk);
++              goto out_free_dmac;
++      }
++      clk_enable(dmac->hclk);
++
++      ret = -ENOMEM;
++      dmac->lli_pool = dma_pool_create("dmac", &pdev->dev,
++                                       sizeof(struct dw_dma_lli), 4, 0);
++      if (!dmac->lli_pool)
++              goto out_disable_clk;
++
++      spin_lock_init(&dmac->lock);
++      dmac->dma.dev = &pdev->dev;
++      dmac->dma.alloc_channel = dmac_alloc_channel;
++      dmac->dma.release_channel = dmac_release_channel;
++      dmac->dma.prepare_request_sg = dmac_prepare_request_sg;
++      dmac->dma.prepare_request_cyclic = dmac_prepare_request_cyclic;
++      dmac->dma.start_request = dmac_start_request;
++      dmac->dma.stop_request = dmac_stop_request;
++      dmac->dma.get_current_pos = dmac_get_current_pos;
++
++      dmac->regs = ioremap(regs->start, regs->end - regs->start + 1);
++      if (!dmac->regs)
++              goto out_free_pool;
++
++      ret = request_irq(platform_get_irq(pdev, 0), dmac_interrupt,
++                        SA_SAMPLE_RANDOM, pdev->name, dmac);
++      if (ret)
++              goto out_unmap_regs;
++
++      /* Enable the DMA controller */
++      dmac_writel_lo(dmac, CFG, 1);
++
++      register_dma_controller(&dmac->dma);
++
++      printk(KERN_INFO
++             "dmac%d: DesignWare DMA controller at 0x%p irq %d\n",
++             dmac->dma.id, dmac->regs, platform_get_irq(pdev, 0));
++
++      return 0;
++
++out_unmap_regs:
++      iounmap(dmac->regs);
++out_free_pool:
++      dma_pool_destroy(dmac->lli_pool);
++out_disable_clk:
++      clk_disable(dmac->hclk);
++      clk_put(dmac->hclk);
++out_free_dmac:
++      kfree(dmac);
++      return ret;
++}
++
++static struct platform_driver dmac_driver = {
++      .probe          = dmac_probe,
++      .driver         = {
++              .name           = "dmaca",
++      },
++};
++
++static int __init dmac_init(void)
++{
++      return platform_driver_register(&dmac_driver);
++}
++subsys_initcall(dmac_init);
++
++static void __exit dmac_exit(void)
++{
++      platform_driver_unregister(&dmac_driver);
++}
++module_exit(dmac_exit);
++
++MODULE_DESCRIPTION("Synopsys DesignWare DMA Controller driver");
++MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>");
++MODULE_LICENSE("GPL");
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/dw-dmac.h avr32-git/arch/avr32/drivers/dw-dmac.h
+--- linux-2.6.21.3/arch/avr32/drivers/dw-dmac.h        1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/drivers/dw-dmac.h     2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,42 @@
++/*
++ * Driver for the Synopsys DesignWare DMA Controller
++ *
++ * Copyright (C) 2005-2006 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#ifndef __AVR32_DW_DMAC_H__
++#define __AVR32_DW_DMAC_H__
++
++#define DW_DMAC_CFG           0x398
++#define DW_DMAC_CH_EN         0x3a0
++
++#define DW_DMAC_STATUS_XFER   0x2e8
++#define DW_DMAC_STATUS_BLOCK  0x2f0
++#define DW_DMAC_STATUS_ERROR  0x308
++
++#define DW_DMAC_MASK_XFER     0x310
++#define DW_DMAC_MASK_BLOCK    0x318
++#define DW_DMAC_MASK_ERROR    0x330
++
++#define DW_DMAC_CLEAR_XFER    0x338
++#define DW_DMAC_CLEAR_BLOCK   0x340
++#define DW_DMAC_CLEAR_ERROR   0x358
++
++#define DW_DMAC_STATUS_INT    0x360
++
++#define DW_DMAC_CHAN_SAR      0x000
++#define DW_DMAC_CHAN_DAR      0x008
++#define DW_DMAC_CHAN_LLP      0x010
++#define DW_DMAC_CHAN_CTL      0x018
++#define DW_DMAC_CHAN_SSTAT    0x020
++#define DW_DMAC_CHAN_DSTAT    0x028
++#define DW_DMAC_CHAN_SSTATAR  0x030
++#define DW_DMAC_CHAN_DSTATAR  0x038
++#define DW_DMAC_CHAN_CFG      0x040
++#define DW_DMAC_CHAN_SGR      0x048
++#define DW_DMAC_CHAN_DSR      0x050
++
++#endif /* __AVR32_DW_DMAC_H__ */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/Makefile avr32-git/arch/avr32/drivers/Makefile
+--- linux-2.6.21.3/arch/avr32/drivers/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/drivers/Makefile      2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1 @@
++obj-$(CONFIG_DW_DMAC)                 += dw-dmac.o
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/Kconfig avr32-git/arch/avr32/Kconfig
+--- linux-2.6.21.3/arch/avr32/Kconfig  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/Kconfig       2007-06-06 11:33:46.000000000 +0200
+@@ -57,9 +57,6 @@
+       bool
+       default n
+-config GENERIC_BUST_SPINLOCK
+-      bool
+-
+ config GENERIC_HWEIGHT
+       bool
+       default y
+@@ -68,6 +65,11 @@
+       bool
+       default y
++config GENERIC_BUG
++      bool
++      default y
++      depends on BUG
++
+ source "init/Kconfig"
+ menu "System Type and features"
+@@ -106,6 +108,9 @@
+ config BOARD_ATSTK1000
+       bool "ATSTK1000 evaluation board"
+       select BOARD_ATSTK1002 if CPU_AT32AP7000
++
++config BOARD_ATNGW100
++      bool "ATNGW100 Network Gateway"
+ endchoice
+ choice
+@@ -116,6 +121,8 @@
+       bool "U-Boot (or similar) bootloader"
+ endchoice
++source "arch/avr32/mach-at32ap/Kconfig"
++
+ config LOAD_ADDRESS
+       hex
+       default 0x10000000 if LOADER_U_BOOT=y && CPU_AT32AP7000=y
+@@ -164,6 +171,10 @@
+         enabling Nexus-compliant debuggers to keep track of the PID of the
+         currently executing task.
++config DW_DMAC
++      tristate "Synopsys DesignWare DMA Controller support"
++      default y if CPU_AT32AP7000
++
+ # FPU emulation goes here
+ source "kernel/Kconfig.hz"
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/cpu.c avr32-git/arch/avr32/kernel/cpu.c
+--- linux-2.6.21.3/arch/avr32/kernel/cpu.c     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/cpu.c  2007-06-06 11:33:46.000000000 +0200
+@@ -209,16 +209,17 @@
+ void __init setup_processor(void)
+ {
+       unsigned long config0, config1;
++      unsigned long features;
+       unsigned cpu_id, cpu_rev, arch_id, arch_rev, mmu_type;
+       unsigned tmp;
+-      config0 = sysreg_read(CONFIG0); /* 0x0000013e; */
+-      config1 = sysreg_read(CONFIG1); /* 0x01f689a2; */
+-      cpu_id = config0 >> 24;
+-      cpu_rev = (config0 >> 16) & 0xff;
+-      arch_id = (config0 >> 13) & 0x07;
+-      arch_rev = (config0 >> 10) & 0x07;
+-      mmu_type = (config0 >> 7) & 0x03;
++      config0 = sysreg_read(CONFIG0);
++      config1 = sysreg_read(CONFIG1);
++      cpu_id = SYSREG_BFEXT(PROCESSORID, config0);
++      cpu_rev = SYSREG_BFEXT(PROCESSORREVISION, config0);
++      arch_id = SYSREG_BFEXT(AT, config0);
++      arch_rev = SYSREG_BFEXT(AR, config0);
++      mmu_type = SYSREG_BFEXT(MMUT, config0);
+       boot_cpu_data.arch_type = arch_id;
+       boot_cpu_data.cpu_type = cpu_id;
+@@ -226,16 +227,16 @@
+       boot_cpu_data.cpu_revision = cpu_rev;
+       boot_cpu_data.tlb_config = mmu_type;
+-      tmp = (config1 >> 13) & 0x07;
++      tmp = SYSREG_BFEXT(ILSZ, config1);
+       if (tmp) {
+-              boot_cpu_data.icache.ways = 1 << ((config1 >> 10) & 0x07);
+-              boot_cpu_data.icache.sets = 1 << ((config1 >> 16) & 0x0f);
++              boot_cpu_data.icache.ways = 1 << SYSREG_BFEXT(IASS, config1);
++              boot_cpu_data.icache.sets = 1 << SYSREG_BFEXT(ISET, config1);
+               boot_cpu_data.icache.linesz = 1 << (tmp + 1);
+       }
+-      tmp = (config1 >> 3) & 0x07;
++      tmp = SYSREG_BFEXT(DLSZ, config1);
+       if (tmp) {
+-              boot_cpu_data.dcache.ways = 1 << (config1 & 0x07);
+-              boot_cpu_data.dcache.sets = 1 << ((config1 >> 6) & 0x0f);
++              boot_cpu_data.dcache.ways = 1 << SYSREG_BFEXT(DASS, config1);
++              boot_cpu_data.dcache.sets = 1 << SYSREG_BFEXT(DSET, config1);
+               boot_cpu_data.dcache.linesz = 1 << (tmp + 1);
+       }
+@@ -250,16 +251,39 @@
+               cpu_names[cpu_id], cpu_id, cpu_rev,
+               arch_names[arch_id], arch_rev);
+       printk ("CPU: MMU configuration: %s\n", mmu_types[mmu_type]);
++
+       printk ("CPU: features:");
+-      if (config0 & (1 << 6))
+-              printk(" fpu");
+-      if (config0 & (1 << 5))
+-              printk(" java");
+-      if (config0 & (1 << 4))
+-              printk(" perfctr");
+-      if (config0 & (1 << 3))
++      features = 0;
++      if (config0 & SYSREG_BIT(CONFIG0_R)) {
++              features |= AVR32_FEATURE_RMW;
++              printk(" rmw");
++      }
++      if (config0 & SYSREG_BIT(CONFIG0_D)) {
++              features |= AVR32_FEATURE_DSP;
++              printk(" dsp");
++      }
++      if (config0 & SYSREG_BIT(CONFIG0_S)) {
++              features |= AVR32_FEATURE_SIMD;
++              printk(" simd");
++      }
++      if (config0 & SYSREG_BIT(CONFIG0_O)) {
++              features |= AVR32_FEATURE_OCD;
+               printk(" ocd");
++      }
++      if (config0 & SYSREG_BIT(CONFIG0_P)) {
++              features |= AVR32_FEATURE_PCTR;
++              printk(" perfctr");
++      }
++      if (config0 & SYSREG_BIT(CONFIG0_J)) {
++              features |= AVR32_FEATURE_JAVA;
++              printk(" java");
++      }
++      if (config0 & SYSREG_BIT(CONFIG0_F)) {
++              features |= AVR32_FEATURE_FPU;
++              printk(" fpu");
++      }
+       printk("\n");
++      boot_cpu_data.features = features;
+ }
+ #ifdef CONFIG_PROC_FS
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/dma-controller.c avr32-git/arch/avr32/kernel/dma-controller.c
+--- linux-2.6.21.3/arch/avr32/kernel/dma-controller.c  1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/kernel/dma-controller.c       2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,34 @@
++/*
++ * Preliminary DMA controller framework for AVR32
++ *
++ * Copyright (C) 2005-2006 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#include <asm/dma-controller.h>
++
++static LIST_HEAD(controllers);
++
++int register_dma_controller(struct dma_controller *dmac)
++{
++      static int next_id;
++
++      dmac->id = next_id++;
++      list_add_tail(&dmac->list, &controllers);
++
++      return 0;
++}
++EXPORT_SYMBOL(register_dma_controller);
++
++struct dma_controller *find_dma_controller(int id)
++{
++      struct dma_controller *dmac;
++
++      list_for_each_entry(dmac, &controllers, list)
++              if (dmac->id == id)
++                      return dmac;
++      return NULL;
++}
++EXPORT_SYMBOL(find_dma_controller);
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/entry-avr32b.S avr32-git/arch/avr32/kernel/entry-avr32b.S
+--- linux-2.6.21.3/arch/avr32/kernel/entry-avr32b.S    2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/entry-avr32b.S 2007-06-06 11:33:46.000000000 +0200
+@@ -100,55 +100,49 @@
+       .global tlb_miss_common
+ tlb_miss_common:
+-      mfsr    r0, SYSREG_PTBR
+-      mfsr    r1, SYSREG_TLBEAR
++      mfsr    r0, SYSREG_TLBEAR
++      mfsr    r1, SYSREG_PTBR
+       /* Is it the vmalloc space? */
+-      bld     r1, 31
++      bld     r0, 31
+       brcs    handle_vmalloc_miss
+       /* First level lookup */
+ pgtbl_lookup:
+-      lsr     r2, r1, PGDIR_SHIFT
+-      ld.w    r0, r0[r2 << 2]
+-      bld     r0, _PAGE_BIT_PRESENT
++      lsr     r2, r0, PGDIR_SHIFT
++      ld.w    r3, r1[r2 << 2]
++      bfextu  r1, r0, PAGE_SHIFT, PGDIR_SHIFT - PAGE_SHIFT
++      bld     r3, _PAGE_BIT_PRESENT
+       brcc    page_table_not_present
+-      /* TODO: Check access rights on page table if necessary */
+-
+       /* Translate to virtual address in P1. */
+-      andl    r0, 0xf000
+-      sbr     r0, 31
++      andl    r3, 0xf000
++      sbr     r3, 31
+       /* Second level lookup */
+-      lsl     r1, (32 - PGDIR_SHIFT)
+-      lsr     r1, (32 - PGDIR_SHIFT) + PAGE_SHIFT
+-      add     r2, r0, r1 << 2
+-      ld.w    r1, r2[0]
+-      bld     r1, _PAGE_BIT_PRESENT
++      ld.w    r2, r3[r1 << 2]
++      mfsr    r0, SYSREG_TLBARLO
++      bld     r2, _PAGE_BIT_PRESENT
+       brcc    page_not_present
+       /* Mark the page as accessed */
+-      sbr     r1, _PAGE_BIT_ACCESSED
+-      st.w    r2[0], r1
++      sbr     r2, _PAGE_BIT_ACCESSED
++      st.w    r3[r1 << 2], r2
+       /* Drop software flags */
+-      andl    r1, _PAGE_FLAGS_HARDWARE_MASK & 0xffff
+-      mtsr    SYSREG_TLBELO, r1
++      andl    r2, _PAGE_FLAGS_HARDWARE_MASK & 0xffff
++      mtsr    SYSREG_TLBELO, r2
+       /* Figure out which entry we want to replace */
+-      mfsr    r0, SYSREG_TLBARLO
++      mfsr    r1, SYSREG_MMUCR
+       clz     r2, r0
+       brcc    1f
+-      mov     r1, -1                  /* All entries have been accessed, */
+-      mtsr    SYSREG_TLBARLO, r1      /* so reset TLBAR */
+-      mov     r2, 0                   /* and start at 0 */
+-1:    mfsr    r1, SYSREG_MMUCR
+-      lsl     r2, 14
+-      andl    r1, 0x3fff, COH
+-      or      r1, r2
+-      mtsr    SYSREG_MMUCR, r1
++      mov     r3, -1                  /* All entries have been accessed, */
++      mov     r2, 0                   /* so start at 0 */
++      mtsr    SYSREG_TLBARLO, r3      /* and reset TLBAR */
++1:    bfins   r1, r2, SYSREG_DRP_OFFSET, SYSREG_DRP_SIZE
++      mtsr    SYSREG_MMUCR, r1
+       tlbw
+       tlbmiss_restore
+@@ -156,8 +150,8 @@
+ handle_vmalloc_miss:
+       /* Simply do the lookup in init's page table */
+-      mov     r0, lo(swapper_pg_dir)
+-      orh     r0, hi(swapper_pg_dir)
++      mov     r1, lo(swapper_pg_dir)
++      orh     r1, hi(swapper_pg_dir)
+       rjmp    pgtbl_lookup
+@@ -340,12 +334,34 @@
+ do_nmi_ll:
+       sub     sp, 4
+       stmts   --sp, r0-lr
+-      /* FIXME: Make sure RAR_NMI and RSR_NMI are pushed instead of *_EX */
+-      rcall   save_full_context_ex
++      mfsr    r9, SYSREG_RSR_NMI
++      mfsr    r8, SYSREG_RAR_NMI
++      bfextu  r0, r9, MODE_SHIFT, 3
++      brne    2f
++
++1:    pushm   r8, r9  /* PC and SR */
+       mfsr    r12, SYSREG_ECR
+       mov     r11, sp
+       rcall   do_nmi
+-      rjmp    bad_return
++      popm    r8-r9
++      mtsr    SYSREG_RAR_NMI, r8
++      tst     r0, r0
++      mtsr    SYSREG_RSR_NMI, r9
++      brne    3f
++
++      ldmts   sp++, r0-lr
++      sub     sp, -4          /* skip r12_orig */
++      rete
++
++2:    sub     r10, sp, -(FRAME_SIZE_FULL - REG_LR)
++      stdsp   sp[4], r10      /* replace saved SP */
++      rjmp    1b
++
++3:    popm    lr
++      sub     sp, -4          /* skip sp */
++      popm    r0-r12
++      sub     sp, -4          /* skip r12_orig */
++      rete
+ handle_address_fault:
+       sub     sp, 4
+@@ -630,9 +646,12 @@
+       rcall   do_IRQ
+       lddsp   r4, sp[REG_SR]
+-      andh    r4, (MODE_MASK >> 16), COH
++      bfextu  r4, r4, SYSREG_M0_OFFSET, 3
++      cp.w    r4, MODE_SUPERVISOR >> SYSREG_M0_OFFSET
++      breq    2f
++      cp.w    r4, MODE_USER >> SYSREG_M0_OFFSET
+ #ifdef CONFIG_PREEMPT
+-      brne    2f
++      brne    3f
+ #else
+       brne    1f
+ #endif
+@@ -649,9 +668,18 @@
+       sub     sp, -4          /* ignore r12_orig */
+       rete
++2:    get_thread_info r0
++      ld.w    r1, r0[TI_flags]
++      bld     r1, TIF_CPU_GOING_TO_SLEEP
+ #ifdef CONFIG_PREEMPT
+-2:
+-      get_thread_info r0
++      brcc    3f
++#else
++      brcc    1b
++#endif
++      sub     r1, pc, . - cpu_idle_skip_sleep
++      stdsp   sp[REG_PC], r1
++#ifdef CONFIG_PREEMPT
++3:    get_thread_info r0
+       ld.w    r2, r0[TI_preempt_count]
+       cp.w    r2, 0
+       brne    1b
+@@ -662,12 +690,32 @@
+       bld     r4, SYSREG_GM_OFFSET
+       brcs    1b
+       rcall   preempt_schedule_irq
+-      rjmp    1b
+ #endif
++      rjmp    1b
+       .endm
+       .section .irq.text,"ax",@progbits
++.global cpu_idle_sleep
++cpu_idle_sleep:
++      mask_interrupts
++      get_thread_info r8
++      ld.w    r9, r8[TI_flags]
++      bld     r9, TIF_NEED_RESCHED
++      brcs    cpu_idle_enable_int_and_exit
++      sbr     r9, TIF_CPU_GOING_TO_SLEEP
++      st.w    r8[TI_flags], r9
++      unmask_interrupts
++      sleep 0
++cpu_idle_skip_sleep:
++      mask_interrupts
++      ld.w    r9, r8[TI_flags]
++      cbr     r9, TIF_CPU_GOING_TO_SLEEP
++      st.w    r8[TI_flags], r9
++cpu_idle_enable_int_and_exit:
++      unmask_interrupts
++      retal   r12
++
+       .global irq_level0
+       .global irq_level1
+       .global irq_level2
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/irq.c avr32-git/arch/avr32/kernel/irq.c
+--- linux-2.6.21.3/arch/avr32/kernel/irq.c     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/irq.c  2007-06-06 11:33:46.000000000 +0200
+@@ -7,15 +7,6 @@
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License version 2 as
+  * published by the Free Software Foundation.
+- *
+- * This file contains the code used by various IRQ handling routines:
+- * asking for different IRQ's should be done through these routines
+- * instead of just grabbing them. Thus setups with different IRQ numbers
+- * shouldn't result in any weird surprises, and installing new handlers
+- * should be easier.
+- *
+- * IRQ's are in fact implemented a bit like signal handlers for the kernel.
+- * Naturally it's not a 1:1 relation, but there are similarities.
+  */
+ #include <linux/interrupt.h>
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/kprobes.c avr32-git/arch/avr32/kernel/kprobes.c
+--- linux-2.6.21.3/arch/avr32/kernel/kprobes.c 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/kprobes.c      2007-06-06 11:33:46.000000000 +0200
+@@ -179,7 +179,7 @@
+       return 1;
+ }
+-static int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr)
++int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr)
+ {
+       struct kprobe *cur = kprobe_running();
+@@ -216,11 +216,6 @@
+               if (post_kprobe_handler(args->regs))
+                       ret = NOTIFY_STOP;
+               break;
+-      case DIE_FAULT:
+-              if (kprobe_running()
+-                  && kprobe_fault_handler(args->regs, args->trapnr))
+-                      ret = NOTIFY_STOP;
+-              break;
+       default:
+               break;
+       }
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/Makefile avr32-git/arch/avr32/kernel/Makefile
+--- linux-2.6.21.3/arch/avr32/kernel/Makefile  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/Makefile       2007-06-06 11:33:46.000000000 +0200
+@@ -9,6 +9,7 @@
+ obj-y                         += setup.o traps.o semaphore.o ptrace.o
+ obj-y                         += signal.o sys_avr32.o process.o time.o
+ obj-y                         += init_task.o switch_to.o cpu.o
++obj-y                         += dma-controller.o
+ obj-$(CONFIG_MODULES)         += module.o avr32_ksyms.o
+ obj-$(CONFIG_KPROBES)         += kprobes.o
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/module.c avr32-git/arch/avr32/kernel/module.c
+--- linux-2.6.21.3/arch/avr32/kernel/module.c  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/module.c       2007-06-06 11:33:46.000000000 +0200
+@@ -12,10 +12,11 @@
+  * published by the Free Software Foundation.
+  */
+-#include <linux/moduleloader.h>
+-#include <linux/module.h>
+-#include <linux/kernel.h>
++#include <linux/bug.h>
+ #include <linux/elf.h>
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/moduleloader.h>
+ #include <linux/vmalloc.h>
+ void *module_alloc(unsigned long size)
+@@ -315,10 +316,10 @@
+       vfree(module->arch.syminfo);
+       module->arch.syminfo = NULL;
+-      return 0;
++      return module_bug_finalize(hdr, sechdrs, module);
+ }
+ void module_arch_cleanup(struct module *module)
+ {
+-
++      module_bug_cleanup(module);
+ }
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/process.c avr32-git/arch/avr32/kernel/process.c
+--- linux-2.6.21.3/arch/avr32/kernel/process.c 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/process.c      2007-06-06 11:33:46.000000000 +0200
+@@ -11,6 +11,7 @@
+ #include <linux/fs.h>
+ #include <linux/ptrace.h>
+ #include <linux/reboot.h>
++#include <linux/uaccess.h>
+ #include <linux/unistd.h>
+ #include <asm/sysreg.h>
+@@ -19,6 +20,8 @@
+ void (*pm_power_off)(void) = NULL;
+ EXPORT_SYMBOL(pm_power_off);
++extern void cpu_idle_sleep(void);
++
+ /*
+  * This file handles the architecture-dependent parts of process handling..
+  */
+@@ -27,9 +30,8 @@
+ {
+       /* endless idle loop with no priority at all */
+       while (1) {
+-              /* TODO: Enter sleep mode */
+               while (!need_resched())
+-                      cpu_relax();
++                      cpu_idle_sleep();
+               preempt_enable_no_resched();
+               schedule();
+               preempt_disable();
+@@ -114,39 +116,178 @@
+       /* do nothing */
+ }
++static void dump_mem(const char *str, const char *log_lvl,
++                   unsigned long bottom, unsigned long top)
++{
++      unsigned long p;
++      int i;
++
++      printk("%s%s(0x%08lx to 0x%08lx)\n", log_lvl, str, bottom, top);
++
++      for (p = bottom & ~31; p < top; ) {
++              printk("%s%04lx: ", log_lvl, p & 0xffff);
++
++              for (i = 0; i < 8; i++, p += 4) {
++                      unsigned int val;
++
++                      if (p < bottom || p >= top)
++                              printk("         ");
++                      else {
++                              if (__get_user(val, (unsigned int __user *)p)) {
++                                      printk("\n");
++                                      goto out;
++                              }
++                              printk("%08x ", val);
++                      }
++              }
++              printk("\n");
++      }
++
++out:
++      return;
++}
++
++static inline int valid_stack_ptr(struct thread_info *tinfo, unsigned long p)
++{
++      return (p > (unsigned long)tinfo)
++              && (p < (unsigned long)tinfo + THREAD_SIZE - 3);
++}
++
++#ifdef CONFIG_FRAME_POINTER
++static void show_trace_log_lvl(struct task_struct *tsk, unsigned long *sp,
++                             struct pt_regs *regs, const char *log_lvl)
++{
++      unsigned long lr, fp;
++      struct thread_info *tinfo;
++
++      if (regs)
++              fp = regs->r7;
++      else if (tsk == current)
++              asm("mov %0, r7" : "=r"(fp));
++      else
++              fp = tsk->thread.cpu_context.r7;
++
++      /*
++       * Walk the stack as long as the frame pointer (a) is within
++       * the kernel stack of the task, and (b) it doesn't move
++       * downwards.
++       */
++      tinfo = task_thread_info(tsk);
++      printk("%sCall trace:\n", log_lvl);
++      while (valid_stack_ptr(tinfo, fp)) {
++              unsigned long new_fp;
++
++              lr = *(unsigned long *)fp;
++#ifdef CONFIG_KALLSYMS
++              printk("%s [<%08lx>] ", log_lvl, lr);
++#else
++              printk(" [<%08lx>] ", lr);
++#endif
++              print_symbol("%s\n", lr);
++
++              new_fp = *(unsigned long *)(fp + 4);
++              if (new_fp <= fp)
++                      break;
++              fp = new_fp;
++      }
++      printk("\n");
++}
++#else
++static void show_trace_log_lvl(struct task_struct *tsk, unsigned long *sp,
++                             struct pt_regs *regs, const char *log_lvl)
++{
++      unsigned long addr;
++
++      printk("%sCall trace:\n", log_lvl);
++
++      while (!kstack_end(sp)) {
++              addr = *sp++;
++              if (kernel_text_address(addr)) {
++#ifdef CONFIG_KALLSYMS
++                      printk("%s [<%08lx>] ", log_lvl, addr);
++#else
++                      printk(" [<%08lx>] ", addr);
++#endif
++                      print_symbol("%s\n", addr);
++              }
++      }
++      printk("\n");
++}
++#endif
++
++void show_stack_log_lvl(struct task_struct *tsk, unsigned long sp,
++                      struct pt_regs *regs, const char *log_lvl)
++{
++      struct thread_info *tinfo;
++
++      if (sp == 0) {
++              if (tsk)
++                      sp = tsk->thread.cpu_context.ksp;
++              else
++                      sp = (unsigned long)&tinfo;
++      }
++      if (!tsk)
++              tsk = current;
++
++      tinfo = task_thread_info(tsk);
++
++      if (valid_stack_ptr(tinfo, sp)) {
++              dump_mem("Stack: ", log_lvl, sp,
++                       THREAD_SIZE + (unsigned long)tinfo);
++              show_trace_log_lvl(tsk, (unsigned long *)sp, regs, log_lvl);
++      }
++}
++
++void show_stack(struct task_struct *tsk, unsigned long *stack)
++{
++      show_stack_log_lvl(tsk, (unsigned long)stack, NULL, "");
++}
++
++void dump_stack(void)
++{
++      unsigned long stack;
++
++      show_trace_log_lvl(current, &stack, NULL, "");
++}
++EXPORT_SYMBOL(dump_stack);
++
+ static const char *cpu_modes[] = {
+       "Application", "Supervisor", "Interrupt level 0", "Interrupt level 1",
+       "Interrupt level 2", "Interrupt level 3", "Exception", "NMI"
+ };
+-void show_regs(struct pt_regs *regs)
++void show_regs_log_lvl(struct pt_regs *regs, const char *log_lvl)
+ {
+       unsigned long sp = regs->sp;
+       unsigned long lr = regs->lr;
+       unsigned long mode = (regs->sr & MODE_MASK) >> MODE_SHIFT;
+-      if (!user_mode(regs))
++      if (!user_mode(regs)) {
+               sp = (unsigned long)regs + FRAME_SIZE_FULL;
+-      print_symbol("PC is at %s\n", instruction_pointer(regs));
+-      print_symbol("LR is at %s\n", lr);
+-      printk("pc : [<%08lx>]    lr : [<%08lx>]    %s\n"
+-             "sp : %08lx  r12: %08lx  r11: %08lx\n",
+-             instruction_pointer(regs),
+-             lr, print_tainted(), sp, regs->r12, regs->r11);
+-      printk("r10: %08lx  r9 : %08lx  r8 : %08lx\n",
+-             regs->r10, regs->r9, regs->r8);
+-      printk("r7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
+-             regs->r7, regs->r6, regs->r5, regs->r4);
+-      printk("r3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
+-             regs->r3, regs->r2, regs->r1, regs->r0);
+-      printk("Flags: %c%c%c%c%c\n",
++              printk("%s", log_lvl);
++              print_symbol("PC is at %s\n", instruction_pointer(regs));
++              printk("%s", log_lvl);
++              print_symbol("LR is at %s\n", lr);
++      }
++
++      printk("%spc : [<%08lx>]    lr : [<%08lx>]    %s\n"
++             "%ssp : %08lx  r12: %08lx  r11: %08lx\n",
++             log_lvl, instruction_pointer(regs), lr, print_tainted(),
++             log_lvl, sp, regs->r12, regs->r11);
++      printk("%sr10: %08lx  r9 : %08lx  r8 : %08lx\n",
++             log_lvl, regs->r10, regs->r9, regs->r8);
++      printk("%sr7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
++             log_lvl, regs->r7, regs->r6, regs->r5, regs->r4);
++      printk("%sr3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
++             log_lvl, regs->r3, regs->r2, regs->r1, regs->r0);
++      printk("%sFlags: %c%c%c%c%c\n", log_lvl,
+              regs->sr & SR_Q ? 'Q' : 'q',
+              regs->sr & SR_V ? 'V' : 'v',
+              regs->sr & SR_N ? 'N' : 'n',
+              regs->sr & SR_Z ? 'Z' : 'z',
+              regs->sr & SR_C ? 'C' : 'c');
+-      printk("Mode bits: %c%c%c%c%c%c%c%c%c\n",
++      printk("%sMode bits: %c%c%c%c%c%c%c%c%c\n", log_lvl,
+              regs->sr & SR_H ? 'H' : 'h',
+              regs->sr & SR_R ? 'R' : 'r',
+              regs->sr & SR_J ? 'J' : 'j',
+@@ -156,9 +297,21 @@
+              regs->sr & SR_I1M ? '1' : '.',
+              regs->sr & SR_I0M ? '0' : '.',
+              regs->sr & SR_GM ? 'G' : 'g');
+-      printk("CPU Mode: %s\n", cpu_modes[mode]);
++      printk("%sCPU Mode: %s\n", log_lvl, cpu_modes[mode]);
++      printk("%sProcess: %s [%d] (task: %p thread: %p)\n",
++             log_lvl, current->comm, current->pid, current,
++             task_thread_info(current));
++}
++
++void show_regs(struct pt_regs *regs)
++{
++      unsigned long sp = regs->sp;
++
++      if (!user_mode(regs))
++              sp = (unsigned long)regs + FRAME_SIZE_FULL;
+-      show_trace(NULL, (unsigned long *)sp, regs);
++      show_regs_log_lvl(regs, "");
++      show_trace_log_lvl(current, (unsigned long *)sp, regs, "");
+ }
+ EXPORT_SYMBOL(show_regs);
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/setup.c avr32-git/arch/avr32/kernel/setup.c
+--- linux-2.6.21.3/arch/avr32/kernel/setup.c   2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/setup.c        2007-06-06 11:33:46.000000000 +0200
+@@ -8,12 +8,14 @@
+ #include <linux/clk.h>
+ #include <linux/init.h>
++#include <linux/initrd.h>
+ #include <linux/sched.h>
+ #include <linux/console.h>
+ #include <linux/ioport.h>
+ #include <linux/bootmem.h>
+ #include <linux/fs.h>
+ #include <linux/module.h>
++#include <linux/pfn.h>
+ #include <linux/root_dev.h>
+ #include <linux/cpu.h>
+ #include <linux/kernel.h>
+@@ -30,13 +32,6 @@
+ extern int root_mountflags;
+ /*
+- * Bootloader-provided information about physical memory
+- */
+-struct tag_mem_range *mem_phys;
+-struct tag_mem_range *mem_reserved;
+-struct tag_mem_range *mem_ramdisk;
+-
+-/*
+  * Initialize loops_per_jiffy as 5000000 (500MIPS).
+  * Better make it too large than too small...
+  */
+@@ -48,48 +43,193 @@
+ static char __initdata command_line[COMMAND_LINE_SIZE];
+ /*
+- * Should be more than enough, but if you have a _really_ complex
+- * setup, you might need to increase the size of this...
++ * Standard memory resources
+  */
+-static struct tag_mem_range __initdata mem_range_cache[32];
+-static unsigned mem_range_next_free;
++static struct resource __initdata kernel_data = {
++      .name   = "Kernel data",
++      .start  = 0,
++      .end    = 0,
++      .flags  = IORESOURCE_MEM,
++};
++static struct resource __initdata kernel_code = {
++      .name   = "Kernel code",
++      .start  = 0,
++      .end    = 0,
++      .flags  = IORESOURCE_MEM,
++      .sibling = &kernel_data,
++};
+ /*
+- * Standard memory resources
++ * Available system RAM and reserved regions as singly linked
++ * lists. These lists are traversed using the sibling pointer in
++ * struct resource and are kept sorted at all times.
+  */
+-static struct resource mem_res[] = {
+-      {
+-              .name   = "Kernel code",
+-              .start  = 0,
+-              .end    = 0,
+-              .flags  = IORESOURCE_MEM
+-      },
+-      {
+-              .name   = "Kernel data",
+-              .start  = 0,
+-              .end    = 0,
+-              .flags  = IORESOURCE_MEM,
+-      },
+-};
++static struct resource *__initdata system_ram;
++static struct resource *__initdata reserved = &kernel_code;
++
++/*
++ * We need to allocate these before the bootmem allocator is up and
++ * running, so we need this "cache". 32 entries are probably enough
++ * for all but the most insanely complex systems.
++ */
++static struct resource __initdata res_cache[32];
++static unsigned int __initdata res_cache_next_free;
++
++static void __init resource_init(void)
++{
++      struct resource *mem, *res;
++      struct resource *new;
++
++      kernel_code.start = __pa(init_mm.start_code);
++
++      for (mem = system_ram; mem; mem = mem->sibling) {
++              new = alloc_bootmem_low(sizeof(struct resource));
++              memcpy(new, mem, sizeof(struct resource));
++
++              new->sibling = NULL;
++              if (request_resource(&iomem_resource, new))
++                      printk(KERN_WARNING "Bad RAM resource %08x-%08x\n",
++                             mem->start, mem->end);
++      }
++
++      for (res = reserved; res; res = res->sibling) {
++              new = alloc_bootmem_low(sizeof(struct resource));
++              memcpy(new, res, sizeof(struct resource));
++
++              new->sibling = NULL;
++              if (insert_resource(&iomem_resource, new))
++                      printk(KERN_WARNING
++                             "Bad reserved resource %s (%08x-%08x)\n",
++                             res->name, res->start, res->end);
++      }
++}
++
++static void __init
++add_physical_memory(resource_size_t start, resource_size_t end)
++{
++      struct resource *new, *next, **pprev;
++
++      for (pprev = &system_ram, next = system_ram; next;
++           pprev = &next->sibling, next = next->sibling) {
++              if (end < next->start)
++                      break;
++              if (start <= next->end) {
++                      printk(KERN_WARNING
++                             "Warning: Physical memory map is broken\n");
++                      printk(KERN_WARNING
++                             "Warning: %08x-%08x overlaps %08x-%08x\n",
++                             start, end, next->start, next->end);
++                      return;
++              }
++      }
++
++      if (res_cache_next_free >= ARRAY_SIZE(res_cache)) {
++              printk(KERN_WARNING
++                     "Warning: Failed to add physical memory %08x-%08x\n",
++                     start, end);
++              return;
++      }
++
++      new = &res_cache[res_cache_next_free++];
++      new->start = start;
++      new->end = end;
++      new->name = "System RAM";
++      new->flags = IORESOURCE_MEM;
++
++      *pprev = new;
++}
++
++static int __init
++add_reserved_region(resource_size_t start, resource_size_t end,
++                  const char *name)
++{
++      struct resource *new, *next, **pprev;
++
++      if (end < start)
++              return -EINVAL;
++
++      if (res_cache_next_free >= ARRAY_SIZE(res_cache))
++              return -ENOMEM;
++
++      for (pprev = &reserved, next = reserved; next;
++           pprev = &next->sibling, next = next->sibling) {
++              if (end < next->start)
++                      break;
++              if (start <= next->end)
++                      return -EBUSY;
++      }
++
++      new = &res_cache[res_cache_next_free++];
++      new->start = start;
++      new->end = end;
++      new->name = name;
++      new->flags = IORESOURCE_MEM;
+-#define kernel_code   mem_res[0]
+-#define kernel_data   mem_res[1]
++      *pprev = new;
++
++      return 0;
++}
++
++static unsigned long __init
++find_free_region(const struct resource *mem, resource_size_t size,
++               resource_size_t align)
++{
++      struct resource *res;
++      unsigned long target;
++
++      target = ALIGN(mem->start, align);
++      for (res = reserved; res; res = res->sibling) {
++              if ((target + size) <= res->start)
++                      break;
++              if (target <= res->end)
++                      target = ALIGN(res->end + 1, align);
++      }
++
++      if ((target + size) > (mem->end + 1))
++              return mem->end + 1;
++
++      return target;
++}
++
++static int __init
++alloc_reserved_region(resource_size_t *start, resource_size_t size,
++                    resource_size_t align, const char *name)
++{
++      struct resource *mem;
++      resource_size_t target;
++      int ret;
++
++      for (mem = system_ram; mem; mem = mem->sibling) {
++              target = find_free_region(mem, size, align);
++              if (target <= mem->end) {
++                      ret = add_reserved_region(target, target + size - 1,
++                                                name);
++                      if (!ret)
++                              *start = target;
++                      return ret;
++              }
++      }
++
++      return -ENOMEM;
++}
+ /*
+  * Early framebuffer allocation. Works as follows:
+  *   - If fbmem_size is zero, nothing will be allocated or reserved.
+  *   - If fbmem_start is zero when setup_bootmem() is called,
+- *     fbmem_size bytes will be allocated from the bootmem allocator.
++ *     a block of fbmem_size bytes will be reserved before bootmem
++ *     initialization. It will be aligned to the largest page size
++ *     that fbmem_size is a multiple of.
+  *   - If fbmem_start is nonzero, an area of size fbmem_size will be
+- *     reserved at the physical address fbmem_start if necessary. If
+- *     the area isn't in a memory region known to the kernel, it will
+- *     be left alone.
++ *     reserved at the physical address fbmem_start if possible. If
++ *     it collides with other reserved memory, a different block of
++ *     same size will be allocated, just as if fbmem_start was zero.
+  *
+  * Board-specific code may use these variables to set up platform data
+  * for the framebuffer driver if fbmem_size is nonzero.
+  */
+-static unsigned long __initdata fbmem_start;
+-static unsigned long __initdata fbmem_size;
++resource_size_t __initdata fbmem_start;
++resource_size_t __initdata fbmem_size;
+ /*
+  * "fbmem=xxx[kKmM]" allocates the specified amount of boot memory for
+@@ -103,48 +243,42 @@
+  */
+ static int __init early_parse_fbmem(char *p)
+ {
++      int ret;
++      unsigned long align;
++
+       fbmem_size = memparse(p, &p);
+-      if (*p == '@')
++      if (*p == '@') {
+               fbmem_start = memparse(p, &p);
+-      return 0;
+-}
+-early_param("fbmem", early_parse_fbmem);
+-
+-static inline void __init resource_init(void)
+-{
+-      struct tag_mem_range *region;
+-
+-      kernel_code.start = __pa(init_mm.start_code);
+-      kernel_code.end = __pa(init_mm.end_code - 1);
+-      kernel_data.start = __pa(init_mm.end_code);
+-      kernel_data.end = __pa(init_mm.brk - 1);
++              ret = add_reserved_region(fbmem_start,
++                                        fbmem_start + fbmem_size - 1,
++                                        "Framebuffer");
++              if (ret) {
++                      printk(KERN_WARNING
++                             "Failed to reserve framebuffer memory\n");
++                      fbmem_start = 0;
++              }
++      }
+-      for (region = mem_phys; region; region = region->next) {
+-              struct resource *res;
+-              unsigned long phys_start, phys_end;
+-
+-              if (region->size == 0)
+-                      continue;
+-
+-              phys_start = region->addr;
+-              phys_end = phys_start + region->size - 1;
+-
+-              res = alloc_bootmem_low(sizeof(*res));
+-              res->name = "System RAM";
+-              res->start = phys_start;
+-              res->end = phys_end;
+-              res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
+-
+-              request_resource (&iomem_resource, res);
+-
+-              if (kernel_code.start >= res->start &&
+-                  kernel_code.end <= res->end)
+-                      request_resource (res, &kernel_code);
+-              if (kernel_data.start >= res->start &&
+-                  kernel_data.end <= res->end)
+-                      request_resource (res, &kernel_data);
++      if (!fbmem_start) {
++              if ((fbmem_size & 0x000fffffUL) == 0)
++                      align = 0x100000;       /* 1 MiB */
++              else if ((fbmem_size & 0x0000ffffUL) == 0)
++                      align = 0x10000;        /* 64 KiB */
++              else
++                      align = 0x1000;         /* 4 KiB */
++
++              ret = alloc_reserved_region(&fbmem_start, fbmem_size,
++                                          align, "Framebuffer");
++              if (ret) {
++                      printk(KERN_WARNING
++                             "Failed to allocate framebuffer memory\n");
++                      fbmem_size = 0;
++              }
+       }
++
++      return 0;
+ }
++early_param("fbmem", early_parse_fbmem);
+ static int __init parse_tag_core(struct tag *tag)
+ {
+@@ -157,11 +291,9 @@
+ }
+ __tagtable(ATAG_CORE, parse_tag_core);
+-static int __init parse_tag_mem_range(struct tag *tag,
+-                                    struct tag_mem_range **root)
++static int __init parse_tag_mem(struct tag *tag)
+ {
+-      struct tag_mem_range *cur, **pprev;
+-      struct tag_mem_range *new;
++      unsigned long start, end;
+       /*
+        * Ignore zero-sized entries. If we're running standalone, the
+@@ -171,34 +303,53 @@
+       if (tag->u.mem_range.size == 0)
+               return 0;
+-      /*
+-       * Copy the data so the bootmem init code doesn't need to care
+-       * about it.
+-       */
+-      if (mem_range_next_free >= ARRAY_SIZE(mem_range_cache))
+-              panic("Physical memory map too complex!\n");
++      start = tag->u.mem_range.addr;
++      end = tag->u.mem_range.addr + tag->u.mem_range.size - 1;
+-      new = &mem_range_cache[mem_range_next_free++];
+-      *new = tag->u.mem_range;
++      add_physical_memory(start, end);
++      return 0;
++}
++__tagtable(ATAG_MEM, parse_tag_mem);
+-      pprev = root;
+-      cur = *root;
+-      while (cur) {
+-              pprev = &cur->next;
+-              cur = cur->next;
++static int __init parse_tag_rdimg(struct tag *tag)
++{
++#ifdef CONFIG_INITRD
++      struct tag_mem_range *mem = &tag->u.mem_range;
++      int ret;
++
++      if (initrd_start) {
++              printk(KERN_WARNING
++                     "Warning: Only the first initrd image will be used\n");
++              return 0;
+       }
+-      *pprev = new;
+-      new->next = NULL;
++      ret = add_reserved_region(mem->start, mem->start + mem->size - 1,
++                                "initrd");
++      if (ret) {
++              printk(KERN_WARNING
++                     "Warning: Failed to reserve initrd memory\n");
++              return ret;
++      }
++
++      initrd_start = (unsigned long)__va(mem->addr);
++      initrd_end = initrd_start + mem->size;
++#else
++      printk(KERN_WARNING "RAM disk image present, but "
++             "no initrd support in kernel, ignoring\n");
++#endif
+       return 0;
+ }
++__tagtable(ATAG_RDIMG, parse_tag_rdimg);
+-static int __init parse_tag_mem(struct tag *tag)
++static int __init parse_tag_rsvd_mem(struct tag *tag)
+ {
+-      return parse_tag_mem_range(tag, &mem_phys);
++      struct tag_mem_range *mem = &tag->u.mem_range;
++
++      return add_reserved_region(mem->addr, mem->addr + mem->size - 1,
++                                 "Reserved");
+ }
+-__tagtable(ATAG_MEM, parse_tag_mem);
++__tagtable(ATAG_RSVD_MEM, parse_tag_rsvd_mem);
+ static int __init parse_tag_cmdline(struct tag *tag)
+ {
+@@ -207,12 +358,6 @@
+ }
+ __tagtable(ATAG_CMDLINE, parse_tag_cmdline);
+-static int __init parse_tag_rdimg(struct tag *tag)
+-{
+-      return parse_tag_mem_range(tag, &mem_ramdisk);
+-}
+-__tagtable(ATAG_RDIMG, parse_tag_rdimg);
+-
+ static int __init parse_tag_clock(struct tag *tag)
+ {
+       /*
+@@ -223,12 +368,6 @@
+ }
+ __tagtable(ATAG_CLOCK, parse_tag_clock);
+-static int __init parse_tag_rsvd_mem(struct tag *tag)
+-{
+-      return parse_tag_mem_range(tag, &mem_reserved);
+-}
+-__tagtable(ATAG_RSVD_MEM, parse_tag_rsvd_mem);
+-
+ /*
+  * Scan the tag table for this tag, and call its parse function. The
+  * tag table is built by the linker from all the __tagtable
+@@ -260,10 +399,137 @@
+                              t->hdr.tag);
+ }
++/*
++ * Find a free memory region large enough for storing the
++ * bootmem bitmap.
++ */
++static unsigned long __init
++find_bootmap_pfn(const struct resource *mem)
++{
++      unsigned long bootmap_pages, bootmap_len;
++      unsigned long node_pages = PFN_UP(mem->end - mem->start + 1);
++      unsigned long bootmap_start;
++
++      bootmap_pages = bootmem_bootmap_pages(node_pages);
++      bootmap_len = bootmap_pages << PAGE_SHIFT;
++
++      /*
++       * Find a large enough region without reserved pages for
++       * storing the bootmem bitmap. We can take advantage of the
++       * fact that all lists have been sorted.
++       *
++       * We have to check that we don't collide with any reserved
++       * regions, which includes the kernel image and any RAMDISK
++       * images.
++       */
++      bootmap_start = find_free_region(mem, bootmap_len, PAGE_SIZE);
++
++      return bootmap_start >> PAGE_SHIFT;
++}
++
++#define MAX_LOWMEM    HIGHMEM_START
++#define MAX_LOWMEM_PFN        PFN_DOWN(MAX_LOWMEM)
++
++static void __init setup_bootmem(void)
++{
++      unsigned bootmap_size;
++      unsigned long first_pfn, bootmap_pfn, pages;
++      unsigned long max_pfn, max_low_pfn;
++      unsigned node = 0;
++      struct resource *res;
++
++      printk(KERN_INFO "Physical memory:\n");
++      for (res = system_ram; res; res = res->sibling)
++              printk("  %08x-%08x\n", res->start, res->end);
++      printk(KERN_INFO "Reserved memory:\n");
++      for (res = reserved; res; res = res->sibling)
++              printk("  %08x-%08x: %s\n",
++                     res->start, res->end, res->name);
++
++      nodes_clear(node_online_map);
++
++      if (system_ram->sibling)
++              printk(KERN_WARNING "Only using first memory bank\n");
++
++      for (res = system_ram; res; res = NULL) {
++              first_pfn = PFN_UP(res->start);
++              max_low_pfn = max_pfn = PFN_DOWN(res->end + 1);
++              bootmap_pfn = find_bootmap_pfn(res);
++              if (bootmap_pfn > max_pfn)
++                      panic("No space for bootmem bitmap!\n");
++
++              if (max_low_pfn > MAX_LOWMEM_PFN) {
++                      max_low_pfn = MAX_LOWMEM_PFN;
++#ifndef CONFIG_HIGHMEM
++                      /*
++                       * Lowmem is memory that can be addressed
++                       * directly through P1/P2
++                       */
++                      printk(KERN_WARNING
++                             "Node %u: Only %ld MiB of memory will be used.\n",
++                             node, MAX_LOWMEM >> 20);
++                      printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
++#else
++#error HIGHMEM is not supported by AVR32 yet
++#endif
++              }
++
++              /* Initialize the boot-time allocator with low memory only. */
++              bootmap_size = init_bootmem_node(NODE_DATA(node), bootmap_pfn,
++                                               first_pfn, max_low_pfn);
++
++              /*
++               * Register fully available RAM pages with the bootmem
++               * allocator.
++               */
++              pages = max_low_pfn - first_pfn;
++              free_bootmem_node (NODE_DATA(node), PFN_PHYS(first_pfn),
++                                 PFN_PHYS(pages));
++
++              /* Reserve space for the bootmem bitmap... */
++              reserve_bootmem_node(NODE_DATA(node),
++                                   PFN_PHYS(bootmap_pfn),
++                                   bootmap_size);
++
++              /* ...and any other reserved regions. */
++              for (res = reserved; res; res = res->sibling) {
++                      if (res->start > PFN_PHYS(max_pfn))
++                              break;
++
++                      /*
++                       * resource_init will complain about partial
++                       * overlaps, so we'll just ignore such
++                       * resources for now.
++                       */
++                      if (res->start >= PFN_PHYS(first_pfn)
++                          && res->end < PFN_PHYS(max_pfn))
++                              reserve_bootmem_node(
++                                      NODE_DATA(node), res->start,
++                                      res->end - res->start + 1);
++              }
++
++              node_set_online(node);
++      }
++}
++
+ void __init setup_arch (char **cmdline_p)
+ {
+       struct clk *cpu_clk;
++      init_mm.start_code = (unsigned long)_text;
++      init_mm.end_code = (unsigned long)_etext;
++      init_mm.end_data = (unsigned long)_edata;
++      init_mm.brk = (unsigned long)_end;
++
++      /*
++       * Include .init section to make allocations easier. It will
++       * be removed before the resource is actually requested.
++       */
++      kernel_code.start = __pa(__init_begin);
++      kernel_code.end = __pa(init_mm.end_code - 1);
++      kernel_data.start = __pa(init_mm.end_code);
++      kernel_data.end = __pa(init_mm.brk - 1);
++
+       parse_tags(bootloader_tags);
+       setup_processor();
+@@ -289,24 +555,16 @@
+                      ((cpu_hz + 500) / 1000) % 1000);
+       }
+-      init_mm.start_code = (unsigned long) &_text;
+-      init_mm.end_code = (unsigned long) &_etext;
+-      init_mm.end_data = (unsigned long) &_edata;
+-      init_mm.brk = (unsigned long) &_end;
+-
+       strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
+       *cmdline_p = command_line;
+       parse_early_param();
+       setup_bootmem();
+-      board_setup_fbmem(fbmem_start, fbmem_size);
+-
+ #ifdef CONFIG_VT
+       conswitchp = &dummy_con;
+ #endif
+       paging_init();
+-
+       resource_init();
+ }
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/time.c avr32-git/arch/avr32/kernel/time.c
+--- linux-2.6.21.3/arch/avr32/kernel/time.c    2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/time.c 2007-06-06 11:33:46.000000000 +0200
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (C) 2004-2006 Atmel Corporation
++ * Copyright (C) 2004-2007 Atmel Corporation
+  *
+  * Based on MIPS implementation arch/mips/kernel/time.c
+  *   Copyright 2001 MontaVista Software Inc.
+@@ -20,18 +20,25 @@
+ #include <linux/init.h>
+ #include <linux/profile.h>
+ #include <linux/sysdev.h>
++#include <linux/err.h>
+ #include <asm/div64.h>
+ #include <asm/sysreg.h>
+ #include <asm/io.h>
+ #include <asm/sections.h>
+-static cycle_t read_cycle_count(void)
++/* how many counter cycles in a jiffy? */
++static u32 cycles_per_jiffy;
++
++/* the count value for the next timer interrupt */
++static u32 expirelo;
++
++cycle_t __weak read_cycle_count(void)
+ {
+       return (cycle_t)sysreg_read(COUNT);
+ }
+-static struct clocksource clocksource_avr32 = {
++struct clocksource __weak clocksource_avr32 = {
+       .name           = "avr32",
+       .rating         = 350,
+       .read           = read_cycle_count,
+@@ -40,12 +47,20 @@
+       .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
+ };
++irqreturn_t __weak timer_interrupt(int irq, void *dev_id);
++
++struct irqaction timer_irqaction = {
++      .handler        = timer_interrupt,
++      .flags          = IRQF_DISABLED,
++      .name           = "timer",
++};
++
+ /*
+  * By default we provide the null RTC ops
+  */
+ static unsigned long null_rtc_get_time(void)
+ {
+-      return mktime(2004, 1, 1, 0, 0, 0);
++      return mktime(2007, 1, 1, 0, 0, 0);
+ }
+ static int null_rtc_set_time(unsigned long sec)
+@@ -56,23 +71,14 @@
+ static unsigned long (*rtc_get_time)(void) = null_rtc_get_time;
+ static int (*rtc_set_time)(unsigned long) = null_rtc_set_time;
+-/* how many counter cycles in a jiffy? */
+-static unsigned long cycles_per_jiffy;
+-
+-/* cycle counter value at the previous timer interrupt */
+-static unsigned int timerhi, timerlo;
+-
+-/* the count value for the next timer interrupt */
+-static unsigned int expirelo;
+-
+ static void avr32_timer_ack(void)
+ {
+-      unsigned int count;
++      u32 count;
+       /* Ack this timer interrupt and set the next one */
+       expirelo += cycles_per_jiffy;
++      /* setting COMPARE to 0 stops the COUNT-COMPARE */
+       if (expirelo == 0) {
+-              printk(KERN_DEBUG "expirelo == 0\n");
+               sysreg_write(COMPARE, expirelo + 1);
+       } else {
+               sysreg_write(COMPARE, expirelo);
+@@ -86,27 +92,56 @@
+       }
+ }
+-static unsigned int avr32_hpt_read(void)
++int __weak avr32_hpt_init(void)
+ {
+-      return sysreg_read(COUNT);
++      int ret;
++      unsigned long mult, shift, count_hz;
++
++      count_hz = clk_get_rate(boot_cpu_data.clk);
++      shift = clocksource_avr32.shift;
++      mult = clocksource_hz2mult(count_hz, shift);
++      clocksource_avr32.mult = mult;
++
++      {
++              u64 tmp;
++
++              tmp = TICK_NSEC;
++              tmp <<= shift;
++              tmp += mult / 2;
++              do_div(tmp, mult);
++
++              cycles_per_jiffy = tmp;
++      }
++
++      ret = setup_irq(0, &timer_irqaction);
++      if (ret) {
++              pr_debug("timer: could not request IRQ 0: %d\n", ret);
++              return -ENODEV;
++      }
++
++      printk(KERN_INFO "timer: AT32AP COUNT-COMPARE at irq 0, "
++                      "%lu.%03lu MHz\n",
++                      ((count_hz + 500) / 1000) / 1000,
++                      ((count_hz + 500) / 1000) % 1000);
++
++      return 0;
+ }
+ /*
+  * Taken from MIPS c0_hpt_timer_init().
+  *
+- * Why is it so complicated, and what is "count"?  My assumption is
+- * that `count' specifies the "reference cycle", i.e. the cycle since
+- * reset that should mean "zero". The reason COUNT is written twice is
+- * probably to make sure we don't get any timer interrupts while we
+- * are messing with the counter.
++ * The reason COUNT is written twice is probably to make sure we don't get any
++ * timer interrupts while we are messing with the counter.
+  */
+-static void avr32_hpt_init(unsigned int count)
++int __weak avr32_hpt_start(void)
+ {
+-      count = sysreg_read(COUNT) - count;
++      u32 count = sysreg_read(COUNT);
+       expirelo = (count / cycles_per_jiffy + 1) * cycles_per_jiffy;
+       sysreg_write(COUNT, expirelo - cycles_per_jiffy);
+       sysreg_write(COMPARE, expirelo);
+       sysreg_write(COUNT, count);
++
++      return 0;
+ }
+ /*
+@@ -115,26 +150,18 @@
+  *
+  * In UP mode, it is invoked from the (global) timer_interrupt.
+  */
+-static void local_timer_interrupt(int irq, void *dev_id)
++void local_timer_interrupt(int irq, void *dev_id)
+ {
+       if (current->pid)
+               profile_tick(CPU_PROFILING);
+       update_process_times(user_mode(get_irq_regs()));
+ }
+-static irqreturn_t
+-timer_interrupt(int irq, void *dev_id)
++irqreturn_t __weak timer_interrupt(int irq, void *dev_id)
+ {
+-      unsigned int count;
+-
+       /* ack timer interrupt and try to set next interrupt */
+-      count = avr32_hpt_read();
+       avr32_timer_ack();
+-      /* Update timerhi/timerlo for intra-jiffy calibration */
+-      timerhi += count < timerlo;     /* Wrap around */
+-      timerlo = count;
+-
+       /*
+        * Call the generic timer interrupt handler
+        */
+@@ -153,60 +180,37 @@
+       return IRQ_HANDLED;
+ }
+-static struct irqaction timer_irqaction = {
+-      .handler        = timer_interrupt,
+-      .flags          = IRQF_DISABLED,
+-      .name           = "timer",
+-};
+-
+ void __init time_init(void)
+ {
+-      unsigned long mult, shift, count_hz;
+       int ret;
++      /*
++       * Make sure we don't get any COMPARE interrupts before we can
++       * handle them.
++       */
++      sysreg_write(COMPARE, 0);
++
+       xtime.tv_sec = rtc_get_time();
+       xtime.tv_nsec = 0;
+       set_normalized_timespec(&wall_to_monotonic,
+                               -xtime.tv_sec, -xtime.tv_nsec);
+-      printk("Before time_init: count=%08lx, compare=%08lx\n",
+-             (unsigned long)sysreg_read(COUNT),
+-             (unsigned long)sysreg_read(COMPARE));
+-
+-      count_hz = clk_get_rate(boot_cpu_data.clk);
+-      shift = clocksource_avr32.shift;
+-      mult = clocksource_hz2mult(count_hz, shift);
+-      clocksource_avr32.mult = mult;
+-
+-      printk("Cycle counter: mult=%lu, shift=%lu\n", mult, shift);
+-
+-      {
+-              u64 tmp;
+-
+-              tmp = TICK_NSEC;
+-              tmp <<= shift;
+-              tmp += mult / 2;
+-              do_div(tmp, mult);
+-
+-              cycles_per_jiffy = tmp;
++      ret = avr32_hpt_init();
++      if (ret) {
++              pr_debug("timer: failed setup: %d\n", ret);
++              return;
+       }
+-      /* This sets up the high precision timer for the first interrupt. */
+-      avr32_hpt_init(avr32_hpt_read());
+-
+-      printk("After time_init: count=%08lx, compare=%08lx\n",
+-             (unsigned long)sysreg_read(COUNT),
+-             (unsigned long)sysreg_read(COMPARE));
+-
+       ret = clocksource_register(&clocksource_avr32);
+       if (ret)
+-              printk(KERN_ERR
+-                     "timer: could not register clocksource: %d\n", ret);
++              pr_debug("timer: could not register clocksource: %d\n", ret);
+-      ret = setup_irq(0, &timer_irqaction);
+-      if (ret)
+-              printk("timer: could not request IRQ 0: %d\n", ret);
++      ret = avr32_hpt_start();
++      if (ret) {
++              pr_debug("timer: failed starting: %d\n", ret);
++              return;
++      }
+ }
+ static struct sysdev_class timer_class = {
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/traps.c avr32-git/arch/avr32/kernel/traps.c
+--- linux-2.6.21.3/arch/avr32/kernel/traps.c   2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/traps.c        2007-06-06 11:33:46.000000000 +0200
+@@ -5,158 +5,25 @@
+  * it under the terms of the GNU General Public License version 2 as
+  * published by the Free Software Foundation.
+  */
+-#undef DEBUG
+-#include <linux/sched.h>
++
++#include <linux/bug.h>
+ #include <linux/init.h>
+-#include <linux/module.h>
+ #include <linux/kallsyms.h>
++#include <linux/module.h>
+ #include <linux/notifier.h>
++#include <linux/sched.h>
++#include <linux/uaccess.h>
+-#include <asm/traps.h>
+-#include <asm/sysreg.h>
+ #include <asm/addrspace.h>
+-#include <asm/ocd.h>
+ #include <asm/mmu_context.h>
+-#include <asm/uaccess.h>
+-
+-static void dump_mem(const char *str, unsigned long bottom, unsigned long top)
+-{
+-      unsigned long p;
+-      int i;
+-
+-      printk("%s(0x%08lx to 0x%08lx)\n", str, bottom, top);
+-
+-      for (p = bottom & ~31; p < top; ) {
+-              printk("%04lx: ", p & 0xffff);
+-
+-              for (i = 0; i < 8; i++, p += 4) {
+-                      unsigned int val;
+-
+-                      if (p < bottom || p >= top)
+-                              printk("         ");
+-                      else {
+-                              if (__get_user(val, (unsigned int __user *)p)) {
+-                                      printk("\n");
+-                                      goto out;
+-                              }
+-                              printk("%08x ", val);
+-                      }
+-              }
+-              printk("\n");
+-      }
+-
+-out:
+-      return;
+-}
+-
+-static inline int valid_stack_ptr(struct thread_info *tinfo, unsigned long p)
+-{
+-      return (p > (unsigned long)tinfo)
+-              && (p < (unsigned long)tinfo + THREAD_SIZE - 3);
+-}
+-
+-#ifdef CONFIG_FRAME_POINTER
+-static inline void __show_trace(struct task_struct *tsk, unsigned long *sp,
+-                              struct pt_regs *regs)
+-{
+-      unsigned long lr, fp;
+-      struct thread_info *tinfo;
+-
+-      tinfo = (struct thread_info *)
+-              ((unsigned long)sp & ~(THREAD_SIZE - 1));
+-
+-      if (regs)
+-              fp = regs->r7;
+-      else if (tsk == current)
+-              asm("mov %0, r7" : "=r"(fp));
+-      else
+-              fp = tsk->thread.cpu_context.r7;
+-
+-      /*
+-       * Walk the stack as long as the frame pointer (a) is within
+-       * the kernel stack of the task, and (b) it doesn't move
+-       * downwards.
+-       */
+-      while (valid_stack_ptr(tinfo, fp)) {
+-              unsigned long new_fp;
+-
+-              lr = *(unsigned long *)fp;
+-              printk(" [<%08lx>] ", lr);
+-              print_symbol("%s\n", lr);
+-
+-              new_fp = *(unsigned long *)(fp + 4);
+-              if (new_fp <= fp)
+-                      break;
+-              fp = new_fp;
+-      }
+-      printk("\n");
+-}
+-#else
+-static inline void __show_trace(struct task_struct *tsk, unsigned long *sp,
+-                              struct pt_regs *regs)
+-{
+-      unsigned long addr;
+-
+-      while (!kstack_end(sp)) {
+-              addr = *sp++;
+-              if (kernel_text_address(addr)) {
+-                      printk(" [<%08lx>] ", addr);
+-                      print_symbol("%s\n", addr);
+-              }
+-      }
+-}
+-#endif
+-
+-void show_trace(struct task_struct *tsk, unsigned long *sp,
+-                     struct pt_regs *regs)
+-{
+-      if (regs &&
+-          (((regs->sr & MODE_MASK) == MODE_EXCEPTION) ||
+-           ((regs->sr & MODE_MASK) == MODE_USER)))
+-              return;
+-
+-      printk ("Call trace:");
+-#ifdef CONFIG_KALLSYMS
+-      printk("\n");
+-#endif
+-
+-      __show_trace(tsk, sp, regs);
+-      printk("\n");
+-}
+-
+-void show_stack(struct task_struct *tsk, unsigned long *sp)
+-{
+-      unsigned long stack;
+-
+-      if (!tsk)
+-              tsk = current;
+-      if (sp == 0) {
+-              if (tsk == current) {
+-                      register unsigned long *real_sp __asm__("sp");
+-                      sp = real_sp;
+-              } else {
+-                      sp = (unsigned long *)tsk->thread.cpu_context.ksp;
+-              }
+-      }
+-
+-      stack = (unsigned long)sp;
+-      dump_mem("Stack: ", stack,
+-               THREAD_SIZE + (unsigned long)tsk->thread_info);
+-      show_trace(tsk, sp, NULL);
+-}
+-
+-void dump_stack(void)
+-{
+-      show_stack(NULL, NULL);
+-}
+-EXPORT_SYMBOL(dump_stack);
++#include <asm/ocd.h>
++#include <asm/sysreg.h>
++#include <asm/traps.h>
+ ATOMIC_NOTIFIER_HEAD(avr32_die_chain);
+ int register_die_notifier(struct notifier_block *nb)
+ {
+-      pr_debug("register_die_notifier: %p\n", nb);
+-
+       return atomic_notifier_chain_register(&avr32_die_chain, nb);
+ }
+ EXPORT_SYMBOL(register_die_notifier);
+@@ -169,98 +36,108 @@
+ static DEFINE_SPINLOCK(die_lock);
+-void __die(const char *str, struct pt_regs *regs, unsigned long err,
+-         const char *file, const char *func, unsigned long line)
++void NORET_TYPE die(const char *str, struct pt_regs *regs, long err)
+ {
+-      struct task_struct *tsk = current;
+       static int die_counter;
+       console_verbose();
+       spin_lock_irq(&die_lock);
+       bust_spinlocks(1);
+-      printk(KERN_ALERT "%s", str);
+-      if (file && func)
+-              printk(" in %s:%s, line %ld", file, func, line);
+-      printk("[#%d]:\n", ++die_counter);
+-      print_modules();
+-      show_regs(regs);
+-      printk("Process %s (pid: %d, stack limit = 0x%p)\n",
+-             tsk->comm, tsk->pid, tsk->thread_info + 1);
+-
+-      if (!user_mode(regs) || in_interrupt()) {
+-              dump_mem("Stack: ", regs->sp,
+-                       THREAD_SIZE + (unsigned long)tsk->thread_info);
++      printk(KERN_ALERT "Oops: %s, sig: %ld [#%d]\n" KERN_EMERG,
++             str, err, ++die_counter);
++#ifdef CONFIG_PREEMPT
++      printk("PREEMPT ");
++#endif
++#ifdef CONFIG_FRAME_POINTER
++      printk("FRAME_POINTER ");
++#endif
++      if (current_cpu_data.features & AVR32_FEATURE_OCD) {
++              unsigned long did = __mfdr(DBGREG_DID);
++              printk("chip: 0x%03lx:0x%04lx rev %lu\n",
++                     (did >> 1) & 0x7ff,
++                     (did >> 12) & 0x7fff,
++                     (did >> 28) & 0xf);
++      } else {
++              printk("cpu: arch %u r%u / core %u r%u\n",
++                     current_cpu_data.arch_type,
++                     current_cpu_data.arch_revision,
++                     current_cpu_data.cpu_type,
++                     current_cpu_data.cpu_revision);
+       }
++      print_modules();
++      show_regs_log_lvl(regs, KERN_EMERG);
++      show_stack_log_lvl(current, regs->sp, regs, KERN_EMERG);
+       bust_spinlocks(0);
+       spin_unlock_irq(&die_lock);
+-      do_exit(SIGSEGV);
++
++      if (in_interrupt())
++              panic("Fatal exception in interrupt");
++
++      if (panic_on_oops)
++              panic("Fatal exception");
++
++      do_exit(err);
+ }
+-void __die_if_kernel(const char *str, struct pt_regs *regs, unsigned long err,
+-                   const char *file, const char *func, unsigned long line)
++void _exception(long signr, struct pt_regs *regs, int code,
++              unsigned long addr)
+ {
++      siginfo_t info;
++
+       if (!user_mode(regs))
+-              __die(str, regs, err, file, func, line);
+-}
++              die("Unhandled exception in kernel mode", regs, signr);
++
++      memset(&info, 0, sizeof(info));
++      info.si_signo = signr;
++      info.si_code = code;
++      info.si_addr = (void __user *)addr;
++      force_sig_info(signr, &info, current);
+-asmlinkage void do_nmi(unsigned long ecr, struct pt_regs *regs)
+-{
+-#ifdef CONFIG_SUBARCH_AVR32B
+       /*
+-       * The exception entry always saves RSR_EX. For NMI, this is
+-       * wrong; it should be RSR_NMI
++       * Init gets no signals that it doesn't have a handler for.
++       * That's all very well, but if it has caused a synchronous
++       * exception and we ignore the resulting signal, it will just
++       * generate the same exception over and over again and we get
++       * nowhere.  Better to kill it and let the kernel panic.
+        */
+-      regs->sr = sysreg_read(RSR_NMI);
+-#endif
++      if (is_init(current)) {
++              __sighandler_t handler;
+-      printk("NMI taken!!!!\n");
+-      die("NMI", regs, ecr);
+-      BUG();
++              spin_lock_irq(&current->sighand->siglock);
++              handler = current->sighand->action[signr-1].sa.sa_handler;
++              spin_unlock_irq(&current->sighand->siglock);
++              if (handler == SIG_DFL) {
++                      /* init has generated a synchronous exception
++                         and it doesn't have a handler for the signal */
++                      printk(KERN_CRIT "init has generated signal %ld "
++                             "but has no handler for it\n", signr);
++                      do_exit(signr);
++              }
++      }
++}
++
++asmlinkage void do_nmi(unsigned long ecr, struct pt_regs *regs)
++{
++      printk(KERN_ALERT "Got Non-Maskable Interrupt, dumping regs\n");
++      show_regs_log_lvl(regs, KERN_ALERT);
++      show_stack_log_lvl(current, regs->sp, regs, KERN_ALERT);
+ }
+ asmlinkage void do_critical_exception(unsigned long ecr, struct pt_regs *regs)
+ {
+-      printk("Unable to handle critical exception %lu at pc = %08lx!\n",
+-             ecr, regs->pc);
+-      die("Oops", regs, ecr);
+-      BUG();
++      die("Critical exception", regs, SIGKILL);
+ }
+ asmlinkage void do_address_exception(unsigned long ecr, struct pt_regs *regs)
+ {
+-      siginfo_t info;
+-
+-      die_if_kernel("Oops: Address exception in kernel mode", regs, ecr);
+-
+-#ifdef DEBUG
+-      if (ecr == ECR_ADDR_ALIGN_X)
+-              pr_debug("Instruction Address Exception at pc = %08lx\n",
+-                       regs->pc);
+-      else if (ecr == ECR_ADDR_ALIGN_R)
+-              pr_debug("Data Address Exception (Read) at pc = %08lx\n",
+-                       regs->pc);
+-      else if (ecr == ECR_ADDR_ALIGN_W)
+-              pr_debug("Data Address Exception (Write) at pc = %08lx\n",
+-                       regs->pc);
+-      else
+-              BUG();
+-
+-      show_regs(regs);
+-#endif
+-
+-      info.si_signo = SIGBUS;
+-      info.si_errno = 0;
+-      info.si_code = BUS_ADRALN;
+-      info.si_addr = (void __user *)regs->pc;
+-
+-      force_sig_info(SIGBUS, &info, current);
++      _exception(SIGBUS, regs, BUS_ADRALN, regs->pc);
+ }
+ /* This way of handling undefined instructions is stolen from ARM */
+ static LIST_HEAD(undef_hook);
+-static spinlock_t undef_lock = SPIN_LOCK_UNLOCKED;
++static DEFINE_SPINLOCK(undef_lock);
+ void register_undef_hook(struct undef_hook *hook)
+ {
+@@ -280,7 +157,8 @@
+ {
+       int cop_nr;
+       u32 cpucr;
+-      if ( (insn & 0xfdf00000) == 0xf1900000 )
++
++      if ((insn & 0xfdf00000) == 0xf1900000)
+               /* LDC0 */
+               cop_nr = 0;
+       else
+@@ -292,136 +170,91 @@
+       sysreg_write(CPUCR, cpucr);
+       cpucr = sysreg_read(CPUCR);
+-      if ( !(cpucr & (1 << (24 + cop_nr))) ){
+-              printk("Coprocessor #%i not found!\n", cop_nr);
+-              return -1;
+-      }
++      if (!(cpucr & (1 << (24 + cop_nr))))
++              return -ENODEV;
+       return 0;
+ }
+-#ifdef CONFIG_BUG
+-#ifdef CONFIG_DEBUG_BUGVERBOSE
+-static inline void do_bug_verbose(struct pt_regs *regs, u32 insn)
+-{
+-      char *file;
+-      u16 line;
+-      char c;
+-
+-      if (__get_user(line, (u16 __user *)(regs->pc + 2)))
+-              return;
+-      if (__get_user(file, (char * __user *)(regs->pc + 4))
+-          || (unsigned long)file < PAGE_OFFSET
+-          || __get_user(c, file))
+-              file = "<bad filename>";
+-
+-      printk(KERN_ALERT "kernel BUG at %s:%d!\n", file, line);
+-}
+-#else
+-static inline void do_bug_verbose(struct pt_regs *regs, u32 insn)
++int is_valid_bugaddr(unsigned long pc)
+ {
++      unsigned short opcode;
++
++      if (pc < PAGE_OFFSET)
++              return 0;
++      if (probe_kernel_address((u16 *)pc, opcode))
++              return 0;
++      return opcode == AVR32_BUG_OPCODE;
+ }
+-#endif
+-#endif
+ asmlinkage void do_illegal_opcode(unsigned long ecr, struct pt_regs *regs)
+ {
+       u32 insn;
+       struct undef_hook *hook;
+-      siginfo_t info;
+       void __user *pc;
++      long code;
+-      if (!user_mode(regs))
+-              goto kernel_trap;
++      if (!user_mode(regs) && (ecr == ECR_ILLEGAL_OPCODE)) {
++              enum bug_trap_type type;
++
++              type = report_bug(regs->pc);
++              switch (type) {
++              case BUG_TRAP_TYPE_NONE:
++                      break;
++              case BUG_TRAP_TYPE_WARN:
++                      regs->pc += 2;
++                      return;
++              case BUG_TRAP_TYPE_BUG:
++                      die("Kernel BUG", regs, SIGKILL);
++              }
++      }
+       local_irq_enable();
+-      pc = (void __user *)instruction_pointer(regs);
+-      if (__get_user(insn, (u32 __user *)pc))
+-              goto invalid_area;
++      if (user_mode(regs)) {
++              pc = (void __user *)instruction_pointer(regs);
++              if (get_user(insn, (u32 __user *)pc))
++                      goto invalid_area;
+-        if (ecr == ECR_COPROC_ABSENT) {
+-              if (do_cop_absent(insn) == 0)
++              if (ecr == ECR_COPROC_ABSENT && !do_cop_absent(insn))
+                       return;
+-        }
+-      spin_lock_irq(&undef_lock);
+-      list_for_each_entry(hook, &undef_hook, node) {
+-              if ((insn & hook->insn_mask) == hook->insn_val) {
+-                      if (hook->fn(regs, insn) == 0) {
+-                              spin_unlock_irq(&undef_lock);
+-                              return;
++              spin_lock_irq(&undef_lock);
++              list_for_each_entry(hook, &undef_hook, node) {
++                      if ((insn & hook->insn_mask) == hook->insn_val) {
++                              if (hook->fn(regs, insn) == 0) {
++                                      spin_unlock_irq(&undef_lock);
++                                      return;
++                              }
+                       }
+               }
++              spin_unlock_irq(&undef_lock);
+       }
+-      spin_unlock_irq(&undef_lock);
+-
+-invalid_area:
+-#ifdef DEBUG
+-      printk("Illegal instruction at pc = %08lx\n", regs->pc);
+-      if (regs->pc < TASK_SIZE) {
+-              unsigned long ptbr, pgd, pte, *p;
+-
+-              ptbr = sysreg_read(PTBR);
+-              p = (unsigned long *)ptbr;
+-              pgd = p[regs->pc >> 22];
+-              p = (unsigned long *)((pgd & 0x1ffff000) | 0x80000000);
+-              pte = p[(regs->pc >> 12) & 0x3ff];
+-              printk("page table: 0x%08lx -> 0x%08lx -> 0x%08lx\n", ptbr, pgd, pte);
+-      }
+-#endif
+-
+-      info.si_signo = SIGILL;
+-      info.si_errno = 0;
+-      info.si_addr = (void __user *)regs->pc;
+       switch (ecr) {
+-      case ECR_ILLEGAL_OPCODE:
+-      case ECR_UNIMPL_INSTRUCTION:
+-              info.si_code = ILL_ILLOPC;
+-              break;
+       case ECR_PRIVILEGE_VIOLATION:
+-              info.si_code = ILL_PRVOPC;
++              code = ILL_PRVOPC;
+               break;
+       case ECR_COPROC_ABSENT:
+-              info.si_code = ILL_COPROC;
++              code = ILL_COPROC;
+               break;
+       default:
+-              BUG();
++              code = ILL_ILLOPC;
++              break;
+       }
+-      force_sig_info(SIGILL, &info, current);
++      _exception(SIGILL, regs, code, regs->pc);
+       return;
+-kernel_trap:
+-#ifdef CONFIG_BUG
+-      if (__kernel_text_address(instruction_pointer(regs))) {
+-              insn = *(u16 *)instruction_pointer(regs);
+-              if (insn == AVR32_BUG_OPCODE) {
+-                      do_bug_verbose(regs, insn);
+-                      die("Kernel BUG", regs, 0);
+-                      return;
+-              }
+-      }
+-#endif
+-
+-      die("Oops: Illegal instruction in kernel code", regs, ecr);
++invalid_area:
++      _exception(SIGSEGV, regs, SEGV_MAPERR, regs->pc);
+ }
+ asmlinkage void do_fpe(unsigned long ecr, struct pt_regs *regs)
+ {
+-      siginfo_t info;
+-
+-      printk("Floating-point exception at pc = %08lx\n", regs->pc);
+-
+-      /* We have no FPU... */
+-      info.si_signo = SIGILL;
+-      info.si_errno = 0;
+-      info.si_addr = (void __user *)regs->pc;
+-      info.si_code = ILL_COPROC;
+-
+-      force_sig_info(SIGILL, &info, current);
++      /* We have no FPU yet */
++      _exception(SIGILL, regs, ILL_COPROC, regs->pc);
+ }
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/vmlinux.lds.c avr32-git/arch/avr32/kernel/vmlinux.lds.c
+--- linux-2.6.21.3/arch/avr32/kernel/vmlinux.lds.c     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/kernel/vmlinux.lds.c  2007-06-06 11:33:46.000000000 +0200
+@@ -26,10 +26,16 @@
+                       _sinittext = .;
+                       *(.text.reset)
+                       *(.init.text)
++                      /*
++                       * .exit.text is discarded at runtime, not
++                       * link time, to deal with references from
++                       * __bug_table
++                       */
++                      *(.exit.text)
+                       _einittext = .;
+               . = ALIGN(4);
+               __tagtable_begin = .;
+-                      *(.taglist)
++                      *(.taglist.init)
+               __tagtable_end = .;
+                       *(.init.data)
+               . = ALIGN(16);
+@@ -86,6 +92,8 @@
+               __stop___ex_table = .;
+       }
++      BUG_TABLE
++
+       RODATA
+       . = ALIGN(8192);
+@@ -126,7 +134,6 @@
+        * thrown away, as cleanup code is never called unless it's a module.
+        */
+       /DISCARD/               : {
+-              *(.exit.text)
+               *(.exit.data)
+               *(.exitcall.exit)
+       }
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000.c avr32-git/arch/avr32/mach-at32ap/at32ap7000.c
+--- linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000.c 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/mach-at32ap/at32ap7000.c      2007-06-06 11:33:46.000000000 +0200
+@@ -6,6 +6,7 @@
+  * published by the Free Software Foundation.
+  */
+ #include <linux/clk.h>
++#include <linux/fb.h>
+ #include <linux/init.h>
+ #include <linux/platform_device.h>
+ #include <linux/spi/spi.h>
+@@ -17,7 +18,10 @@
+ #include <asm/arch/portmux.h>
+ #include <asm/arch/sm.h>
++#include <video/atmel_lcdc.h>
++
+ #include "clock.h"
++#include "hmatrix.h"
+ #include "pio.h"
+ #include "sm.h"
+@@ -416,7 +420,15 @@
+       .resource       = sm_resource,
+       .num_resources  = ARRAY_SIZE(sm_resource),
+ };
+-DEV_CLK(pclk, at32_sm, pbb, 0);
++static struct clk at32_sm_pclk = {
++      .name           = "pclk",
++      .dev            = &at32_sm_device.dev,
++      .parent         = &pbb_clk,
++      .mode           = pbb_clk_mode,
++      .get_rate       = pbb_clk_get_rate,
++      .users          = 1,
++      .index          = 0,
++};
+ static struct resource intc0_resource[] = {
+       PBMEM(0xfff00400),
+@@ -442,6 +454,7 @@
+       .mode           = hsb_clk_mode,
+       .get_rate       = hsb_clk_get_rate,
+       .users          = 1,
++      .index          = 3,
+ };
+ static struct resource smc0_resource[] = {
+@@ -466,6 +479,68 @@
+       .users          = 1,
+ };
++static struct resource dmaca0_resource[] = {
++      {
++              .start  = 0xff200000,
++              .end    = 0xff20ffff,
++              .flags  = IORESOURCE_MEM,
++      },
++      IRQ(2),
++};
++DEFINE_DEV(dmaca, 0);
++DEV_CLK(hclk, dmaca0, hsb, 10);
++
++/* --------------------------------------------------------------------
++ * HMATRIX
++ * -------------------------------------------------------------------- */
++
++static struct clk hmatrix_clk = {
++      .name           = "hmatrix_clk",
++      .parent         = &pbb_clk,
++      .mode           = pbb_clk_mode,
++      .get_rate       = pbb_clk_get_rate,
++      .index          = 2,
++      .users          = 1,
++};
++#define HMATRIX_BASE  ((void __iomem *)0xfff00800)
++
++#define hmatrix_readl(reg)                                    \
++      __raw_readl((HMATRIX_BASE) + HMATRIX_##reg)
++#define hmatrix_writel(reg,value)                             \
++      __raw_writel((value), (HMATRIX_BASE) + HMATRIX_##reg)
++
++/*
++ * Set bits in the HMATRIX Special Function Register (SFR) used by the
++ * External Bus Interface (EBI). This can be used to enable special
++ * features like CompactFlash support, NAND Flash support, etc. on
++ * certain chipselects.
++ */
++static inline void set_ebi_sfr_bits(u32 mask)
++{
++      u32 sfr;
++
++      clk_enable(&hmatrix_clk);
++      sfr = hmatrix_readl(SFR4);
++      sfr |= mask;
++      hmatrix_writel(SFR4, sfr);
++      clk_disable(&hmatrix_clk);
++}
++
++/* --------------------------------------------------------------------
++ *  System Timer/Counter (TC)
++ * -------------------------------------------------------------------- */
++static struct resource at32_systc0_resource[] = {
++      PBMEM(0xfff00c00),
++      IRQ(22),
++};
++struct platform_device at32_systc0_device = {
++      .name           = "systc",
++      .id             = 0,
++      .resource       = at32_systc0_resource,
++      .num_resources  = ARRAY_SIZE(at32_systc0_resource),
++};
++DEV_CLK(pclk, at32_systc0, pbb, 3);
++
+ /* --------------------------------------------------------------------
+  *  PIO
+  * -------------------------------------------------------------------- */
+@@ -513,6 +588,9 @@
+       platform_device_register(&at32_intc0_device);
+       platform_device_register(&smc0_device);
+       platform_device_register(&pdc_device);
++      platform_device_register(&dmaca0_device);
++
++      platform_device_register(&at32_systc0_device);
+       platform_device_register(&pio0_device);
+       platform_device_register(&pio1_device);
+@@ -816,22 +894,105 @@
+ }
+ /* --------------------------------------------------------------------
++ *  TWI
++ * -------------------------------------------------------------------- */
++
++static struct resource atmel_twi0_resource[] = {
++      PBMEM(0xffe00800),
++      IRQ(5),
++};
++DEFINE_DEV(atmel_twi, 0);
++DEV_CLK(pclk,atmel_twi0,pba,2);
++
++struct platform_device *__init
++at32_add_device_twi(unsigned int id)
++{
++      struct platform_device *pdev;
++
++      switch (id) {
++      case 0:
++              pdev = &atmel_twi0_device;
++              select_peripheral(PA(6),  PERIPH_A, 0); /* SDA  */
++              select_peripheral(PA(7),  PERIPH_A, 0); /* SCL  */
++              break;
++
++      default:
++              return NULL;
++      }
++
++      platform_device_register(pdev);
++      return pdev;
++}
++
++/* --------------------------------------------------------------------
++ * MMC
++ * -------------------------------------------------------------------- */
++static struct mci_platform_data atmel_mci0_data = {
++      .detect_pin     = GPIO_PIN_NONE,
++      .wp_pin         = GPIO_PIN_NONE,
++};
++static struct resource atmel_mci0_resource[] = {
++      PBMEM(0xfff02400),
++      IRQ(28),
++};
++DEFINE_DEV_DATA(atmel_mci, 0);
++DEV_CLK(mci_clk, atmel_mci0, pbb, 9);
++
++struct platform_device *__init
++at32_add_device_mci(unsigned int id, struct mci_platform_data *data)
++{
++      struct platform_device *pdev;
++
++      switch (id) {
++      case 0:
++              pdev = &atmel_mci0_device;
++              select_peripheral(PA(10), PERIPH_A, 0); /* CLK   */
++              select_peripheral(PA(11), PERIPH_A, 0); /* CMD   */
++              select_peripheral(PA(12), PERIPH_A, 0); /* DATA0 */
++              select_peripheral(PA(13), PERIPH_A, 0); /* DATA1 */
++              select_peripheral(PA(14), PERIPH_A, 0); /* DATA2 */
++              select_peripheral(PA(15), PERIPH_A, 0); /* DATA3 */
++              break;
++      default:
++              return NULL;
++      }
++
++      if (data) {
++              if (data->detect_pin != GPIO_PIN_NONE)
++                      at32_select_gpio(data->detect_pin, 0);
++              if (data->wp_pin != GPIO_PIN_NONE)
++                      at32_select_gpio(data->wp_pin, 0);
++              memcpy(pdev->dev.platform_data, data,
++                     sizeof(struct mci_platform_data));
++      }
++
++      platform_device_register(pdev);
++      return pdev;
++}
++
++/* --------------------------------------------------------------------
+  *  LCDC
+  * -------------------------------------------------------------------- */
+-static struct lcdc_platform_data lcdc0_data;
+-static struct resource lcdc0_resource[] = {
++static struct atmel_lcdfb_info atmel_lcdfb0_data;
++static struct resource atmel_lcdfb0_resource[] = {
+       {
+               .start          = 0xff000000,
+               .end            = 0xff000fff,
+               .flags          = IORESOURCE_MEM,
+       },
+       IRQ(1),
++      {
++              /* Placeholder for pre-allocated fb memory */
++              .start          = 0x00000000,
++              .end            = 0x00000000,
++              .flags          = 0,
++      },
+ };
+-DEFINE_DEV_DATA(lcdc, 0);
+-DEV_CLK(hclk, lcdc0, hsb, 7);
+-static struct clk lcdc0_pixclk = {
+-      .name           = "pixclk",
+-      .dev            = &lcdc0_device.dev,
++DEFINE_DEV_DATA(atmel_lcdfb, 0);
++DEV_CLK(hck1, atmel_lcdfb0, hsb, 7);
++static struct clk atmel_lcdfb0_pixclk = {
++      .name           = "lcdc_clk",
++      .dev            = &atmel_lcdfb0_device.dev,
+       .mode           = genclk_mode,
+       .get_rate       = genclk_get_rate,
+       .set_rate       = genclk_set_rate,
+@@ -840,13 +1001,34 @@
+ };
+ struct platform_device *__init
+-at32_add_device_lcdc(unsigned int id, struct lcdc_platform_data *data)
++at32_add_device_lcdc(unsigned int id, struct atmel_lcdfb_info *data,
++                   unsigned long fbmem_start, unsigned long fbmem_len)
+ {
+       struct platform_device *pdev;
++      struct atmel_lcdfb_info *info;
++      struct fb_monspecs *monspecs;
++      struct fb_videomode *modedb;
++      unsigned int modedb_size;
++
++      /*
++       * Do a deep copy of the fb data, monspecs and modedb. Make
++       * sure all allocations are done before setting up the
++       * portmux.
++       */
++      monspecs = kmemdup(data->default_monspecs,
++                         sizeof(struct fb_monspecs), GFP_KERNEL);
++      if (!monspecs)
++              return NULL;
++
++      modedb_size = sizeof(struct fb_videomode) * monspecs->modedb_len;
++      modedb = kmemdup(monspecs->modedb, modedb_size, GFP_KERNEL);
++      if (!modedb)
++              goto err_dup_modedb;
++      monspecs->modedb = modedb;
+       switch (id) {
+       case 0:
+-              pdev = &lcdc0_device;
++              pdev = &atmel_lcdfb0_device;
+               select_peripheral(PC(19), PERIPH_A, 0); /* CC     */
+               select_peripheral(PC(20), PERIPH_A, 0); /* HSYNC  */
+               select_peripheral(PC(21), PERIPH_A, 0); /* PCLK   */
+@@ -879,16 +1061,133 @@
+               select_peripheral(PD(16), PERIPH_A, 0); /* DATA22 */
+               select_peripheral(PD(17), PERIPH_A, 0); /* DATA23 */
+-              clk_set_parent(&lcdc0_pixclk, &pll0);
+-              clk_set_rate(&lcdc0_pixclk, clk_get_rate(&pll0));
++              clk_set_parent(&atmel_lcdfb0_pixclk, &pll0);
++              clk_set_rate(&atmel_lcdfb0_pixclk, clk_get_rate(&pll0));
++              break;
++
++      default:
++              goto err_invalid_id;
++      }
++
++      if (fbmem_len) {
++              pdev->resource[2].start = fbmem_start;
++              pdev->resource[2].end = fbmem_start + fbmem_len - 1;
++              pdev->resource[2].flags = IORESOURCE_MEM;
++      }
++
++      info = pdev->dev.platform_data;
++      memcpy(info, data, sizeof(struct atmel_lcdfb_info));
++      info->default_monspecs = monspecs;
++
++      platform_device_register(pdev);
++      return pdev;
++
++err_invalid_id:
++      kfree(modedb);
++err_dup_modedb:
++      kfree(monspecs);
++      return NULL;
++}
++
++/* --------------------------------------------------------------------
++ *  USB Device Controller
++ * -------------------------------------------------------------------- */
++static struct resource usba0_resource[] = {
++      {
++              .start          = 0xff300000,
++              .end            = 0xff3fffff,
++              .flags          = IORESOURCE_MEM,
++      },
++      PBMEM(0xfff03000),
++      IRQ(31),
++};
++DEFINE_DEV(usba, 0);
++DEV_CLK(pclk, usba0, pbb, 12);
++DEV_CLK(hclk, usba0, hsb, 6);
++
++struct platform_device *__init at32_add_device_usba(unsigned int id)
++{
++      struct platform_device *pdev;
++
++      switch (id) {
++      case 0:
++              pdev = &usba0_device;
++              /* USB pads are not multiplexed */
+               break;
++      default:
++              return NULL;
++      }
++
++      platform_device_register(pdev);
++      return pdev;
++}
++
++/* --------------------------------------------------------------------
++ *  AC97C
++ * -------------------------------------------------------------------- */
++static struct resource atmel_ac97c0_resource[] = {
++      PBMEM(0xfff02800),
++      IRQ(29),
++};
++DEFINE_DEV(atmel_ac97c, 0);
++DEV_CLK(pclk, atmel_ac97c0, pbb, 10);
++struct platform_device *__init
++at32_add_device_ac97c(unsigned int id)
++{
++      struct platform_device *pdev;
++
++      switch (id) {
++      case 0:
++              pdev = &atmel_ac97c0_device;
++              select_peripheral(PB(20), PERIPH_B, 0); /* SYNC */
++              select_peripheral(PB(21), PERIPH_B, 0); /* SDO  */
++              select_peripheral(PB(22), PERIPH_B, 0); /* SDI  */
++              select_peripheral(PB(23), PERIPH_B, 0); /* SCLK */
++              break;
+       default:
+               return NULL;
+       }
+-      memcpy(pdev->dev.platform_data, data,
+-             sizeof(struct lcdc_platform_data));
++      platform_device_register(pdev);
++      return pdev;
++}
++
++/* --------------------------------------------------------------------
++ *  DAC
++ * -------------------------------------------------------------------- */
++static struct resource abdac0_resource[] = {
++      PBMEM(0xfff02000),
++      IRQ(27),
++};
++DEFINE_DEV(abdac, 0);
++DEV_CLK(pclk, abdac0, pbb, 8);
++static struct clk abdac0_sample_clk = {
++      .name           = "sample_clk",
++      .dev            = &abdac0_device.dev,
++      .mode           = genclk_mode,
++      .get_rate       = genclk_get_rate,
++      .set_rate       = genclk_set_rate,
++      .set_parent     = genclk_set_parent,
++      .index          = 6,
++};
++
++struct platform_device *__init
++at32_add_device_abdac(unsigned int id)
++{
++      struct platform_device *pdev;
++
++      switch (id) {
++      case 0:
++              pdev = &abdac0_device;
++              select_peripheral(PB(20), PERIPH_A, 0); /* DATA1        */
++              select_peripheral(PB(21), PERIPH_A, 0); /* DATA0        */
++              select_peripheral(PB(22), PERIPH_A, 0); /* DATAN1       */
++              select_peripheral(PB(23), PERIPH_A, 0); /* DATAN0       */
++              break;
++      default:
++              return NULL;
++      }
+       platform_device_register(pdev);
+       return pdev;
+@@ -950,18 +1249,21 @@
+       &pbb_clk,
+       &at32_sm_pclk,
+       &at32_intc0_pclk,
++      &hmatrix_clk,
+       &ebi_clk,
+       &hramc_clk,
+       &smc0_pclk,
+       &smc0_mck,
+       &pdc_hclk,
+       &pdc_pclk,
++      &dmaca0_hclk,
+       &pico_clk,
+       &pio0_mck,
+       &pio1_mck,
+       &pio2_mck,
+       &pio3_mck,
+       &pio4_mck,
++      &at32_systc0_pclk,
+       &atmel_usart0_usart,
+       &atmel_usart1_usart,
+       &atmel_usart2_usart,
+@@ -972,8 +1274,15 @@
+       &macb1_pclk,
+       &atmel_spi0_spi_clk,
+       &atmel_spi1_spi_clk,
+-      &lcdc0_hclk,
+-      &lcdc0_pixclk,
++      &atmel_twi0_pclk,
++      &atmel_mci0_mci_clk,
++      &atmel_lcdfb0_hck1,
++      &atmel_lcdfb0_pixclk,
++      &usba0_pclk,
++      &usba0_hclk,
++      &atmel_ac97c0_pclk,
++      &abdac0_pclk,
++      &abdac0_sample_clk,
+       &gclk0,
+       &gclk1,
+       &gclk2,
+@@ -1012,7 +1321,8 @@
+       genclk_init_parent(&gclk2);
+       genclk_init_parent(&gclk3);
+       genclk_init_parent(&gclk4);
+-      genclk_init_parent(&lcdc0_pixclk);
++      genclk_init_parent(&atmel_lcdfb0_pixclk);
++      genclk_init_parent(&abdac0_sample_clk);
+       /*
+        * Turn on all clocks that have at least one user already, and
+@@ -1024,6 +1334,9 @@
+       for (i = 0; i < ARRAY_SIZE(at32_clock_list); i++) {
+               struct clk *clk = at32_clock_list[i];
++              if (clk->users == 0)
++                      continue;
++
+               if (clk->mode == &cpu_clk_mode)
+                       cpu_mask |= 1 << clk->index;
+               else if (clk->mode == &hsb_clk_mode)
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/clock.c avr32-git/arch/avr32/mach-at32ap/clock.c
+--- linux-2.6.21.3/arch/avr32/mach-at32ap/clock.c      2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/mach-at32ap/clock.c   2007-06-06 11:33:46.000000000 +0200
+@@ -18,7 +18,7 @@
+ #include "clock.h"
+-static spinlock_t clk_lock = SPIN_LOCK_UNLOCKED;
++static DEFINE_SPINLOCK(clk_lock);
+ struct clk *clk_get(struct device *dev, const char *id)
+ {
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/hmatrix.h avr32-git/arch/avr32/mach-at32ap/hmatrix.h
+--- linux-2.6.21.3/arch/avr32/mach-at32ap/hmatrix.h    1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/mach-at32ap/hmatrix.h 2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,182 @@
++/*
++ * Register definitions for High-Speed Bus Matrix
++ */
++#ifndef __HMATRIX_H
++#define __HMATRIX_H
++
++/* HMATRIX register offsets */
++#define HMATRIX_MCFG0                         0x0000
++#define HMATRIX_MCFG1                         0x0004
++#define HMATRIX_MCFG2                         0x0008
++#define HMATRIX_MCFG3                         0x000c
++#define HMATRIX_MCFG4                         0x0010
++#define HMATRIX_MCFG5                         0x0014
++#define HMATRIX_MCFG6                         0x0018
++#define HMATRIX_MCFG7                         0x001c
++#define HMATRIX_MCFG8                         0x0020
++#define HMATRIX_MCFG9                         0x0024
++#define HMATRIX_MCFG10                                0x0028
++#define HMATRIX_MCFG11                                0x002c
++#define HMATRIX_MCFG12                                0x0030
++#define HMATRIX_MCFG13                                0x0034
++#define HMATRIX_MCFG14                                0x0038
++#define HMATRIX_MCFG15                                0x003c
++#define HMATRIX_SCFG0                         0x0040
++#define HMATRIX_SCFG1                         0x0044
++#define HMATRIX_SCFG2                         0x0048
++#define HMATRIX_SCFG3                         0x004c
++#define HMATRIX_SCFG4                         0x0050
++#define HMATRIX_SCFG5                         0x0054
++#define HMATRIX_SCFG6                         0x0058
++#define HMATRIX_SCFG7                         0x005c
++#define HMATRIX_SCFG8                         0x0060
++#define HMATRIX_SCFG9                         0x0064
++#define HMATRIX_SCFG10                                0x0068
++#define HMATRIX_SCFG11                                0x006c
++#define HMATRIX_SCFG12                                0x0070
++#define HMATRIX_SCFG13                                0x0074
++#define HMATRIX_SCFG14                                0x0078
++#define HMATRIX_SCFG15                                0x007c
++#define HMATRIX_PRAS0                         0x0080
++#define HMATRIX_PRBS0                         0x0084
++#define HMATRIX_PRAS1                         0x0088
++#define HMATRIX_PRBS1                         0x008c
++#define HMATRIX_PRAS2                         0x0090
++#define HMATRIX_PRBS2                         0x0094
++#define HMATRIX_PRAS3                         0x0098
++#define HMATRIX_PRBS3                         0x009c
++#define HMATRIX_PRAS4                         0x00a0
++#define HMATRIX_PRBS4                         0x00a4
++#define HMATRIX_PRAS5                         0x00a8
++#define HMATRIX_PRBS5                         0x00ac
++#define HMATRIX_PRAS6                         0x00b0
++#define HMATRIX_PRBS6                         0x00b4
++#define HMATRIX_PRAS7                         0x00b8
++#define HMATRIX_PRBS7                         0x00bc
++#define HMATRIX_PRAS8                         0x00c0
++#define HMATRIX_PRBS8                         0x00c4
++#define HMATRIX_PRAS9                         0x00c8
++#define HMATRIX_PRBS9                         0x00cc
++#define HMATRIX_PRAS10                                0x00d0
++#define HMATRIX_PRBS10                                0x00d4
++#define HMATRIX_PRAS11                                0x00d8
++#define HMATRIX_PRBS11                                0x00dc
++#define HMATRIX_PRAS12                                0x00e0
++#define HMATRIX_PRBS12                                0x00e4
++#define HMATRIX_PRAS13                                0x00e8
++#define HMATRIX_PRBS13                                0x00ec
++#define HMATRIX_PRAS14                                0x00f0
++#define HMATRIX_PRBS14                                0x00f4
++#define HMATRIX_PRAS15                                0x00f8
++#define HMATRIX_PRBS15                                0x00fc
++#define HMATRIX_MRCR                          0x0100
++#define HMATRIX_SFR0                          0x0110
++#define HMATRIX_SFR1                          0x0114
++#define HMATRIX_SFR2                          0x0118
++#define HMATRIX_SFR3                          0x011c
++#define HMATRIX_SFR4                          0x0120
++#define HMATRIX_SFR5                          0x0124
++#define HMATRIX_SFR6                          0x0128
++#define HMATRIX_SFR7                          0x012c
++#define HMATRIX_SFR8                          0x0130
++#define HMATRIX_SFR9                          0x0134
++#define HMATRIX_SFR10                         0x0138
++#define HMATRIX_SFR11                         0x013c
++#define HMATRIX_SFR12                         0x0140
++#define HMATRIX_SFR13                         0x0144
++#define HMATRIX_SFR14                         0x0148
++#define HMATRIX_SFR15                         0x014c
++
++/* Bitfields in MCFGx */
++#define HMATRIX_ULBT_OFFSET                   0
++#define HMATRIX_ULBT_SIZE                     3
++
++/* Bitfields in SCFGx */
++#define HMATRIX_SLOT_CYCLE_OFFSET             0
++#define HMATRIX_SLOT_CYCLE_SIZE                       8
++#define HMATRIX_DEFMSTR_TYPE_OFFSET           16
++#define HMATRIX_DEFMSTR_TYPE_SIZE             2
++#define HMATRIX_FIXED_DEFMSTR_OFFSET          18
++#define HMATRIX_FIXED_DEFMSTR_SIZE            4
++#define HMATRIX_ARBT_OFFSET                   24
++#define HMATRIX_ARBT_SIZE                     2
++
++/* Bitfields in PRASx */
++#define HMATRIX_M0PR_OFFSET                   0
++#define HMATRIX_M0PR_SIZE                     4
++#define HMATRIX_M1PR_OFFSET                   4
++#define HMATRIX_M1PR_SIZE                     4
++#define HMATRIX_M2PR_OFFSET                   8
++#define HMATRIX_M2PR_SIZE                     4
++#define HMATRIX_M3PR_OFFSET                   12
++#define HMATRIX_M3PR_SIZE                     4
++#define HMATRIX_M4PR_OFFSET                   16
++#define HMATRIX_M4PR_SIZE                     4
++#define HMATRIX_M5PR_OFFSET                   20
++#define HMATRIX_M5PR_SIZE                     4
++#define HMATRIX_M6PR_OFFSET                   24
++#define HMATRIX_M6PR_SIZE                     4
++#define HMATRIX_M7PR_OFFSET                   28
++#define HMATRIX_M7PR_SIZE                     4
++
++/* Bitfields in PRBSx */
++#define HMATRIX_M8PR_OFFSET                   0
++#define HMATRIX_M8PR_SIZE                     4
++#define HMATRIX_M9PR_OFFSET                   4
++#define HMATRIX_M9PR_SIZE                     4
++#define HMATRIX_M10PR_OFFSET                  8
++#define HMATRIX_M10PR_SIZE                    4
++#define HMATRIX_M11PR_OFFSET                  12
++#define HMATRIX_M11PR_SIZE                    4
++#define HMATRIX_M12PR_OFFSET                  16
++#define HMATRIX_M12PR_SIZE                    4
++#define HMATRIX_M13PR_OFFSET                  20
++#define HMATRIX_M13PR_SIZE                    4
++#define HMATRIX_M14PR_OFFSET                  24
++#define HMATRIX_M14PR_SIZE                    4
++#define HMATRIX_M15PR_OFFSET                  28
++#define HMATRIX_M15PR_SIZE                    4
++
++/* Bitfields in SFR4 */
++#define HMATRIX_CS1A_OFFSET                   1
++#define HMATRIX_CS1A_SIZE                     1
++#define HMATRIX_CS3A_OFFSET                   3
++#define HMATRIX_CS3A_SIZE                     1
++#define HMATRIX_CS4A_OFFSET                   4
++#define HMATRIX_CS4A_SIZE                     1
++#define HMATRIX_CS5A_OFFSET                   5
++#define HMATRIX_CS5A_SIZE                     1
++#define HMATRIX_DBPUC_OFFSET                  8
++#define HMATRIX_DBPUC_SIZE                    1
++
++/* Constants for ULBT */
++#define HMATRIX_ULBT_INFINITE                 0
++#define HMATRIX_ULBT_SINGLE                   1
++#define HMATRIX_ULBT_FOUR_BEAT                        2
++#define HMATRIX_ULBT_EIGHT_BEAT                       3
++#define HMATRIX_ULBT_SIXTEEN_BEAT             4
++
++/* Constants for DEFMSTR_TYPE */
++#define HMATRIX_DEFMSTR_TYPE_NO_DEFAULT               0
++#define HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT     1
++#define HMATRIX_DEFMSTR_TYPE_FIXED_DEFAULT    2
++
++/* Constants for ARBT */
++#define HMATRIX_ARBT_ROUND_ROBIN              0
++#define HMATRIX_ARBT_FIXED_PRIORITY           1
++
++/* Bit manipulation macros */
++#define HMATRIX_BIT(name)                                     \
++      (1 << HMATRIX_##name##_OFFSET)
++#define HMATRIX_BF(name,value)                                        \
++      (((value) & ((1 << HMATRIX_##name##_SIZE) - 1))         \
++       << HMATRIX_##name##_OFFSET)
++#define HMATRIX_BFEXT(name,value)                             \
++      (((value) >> HMATRIX_##name##_OFFSET)                   \
++       & ((1 << HMATRIX_##name##_SIZE) - 1))
++#define HMATRIX_BFINS(name,value,old)                         \
++      (((old) & ~(((1 << HMATRIX_##name##_SIZE) - 1)          \
++                  << HMATRIX_##name##_OFFSET))                \
++       | HMATRIX_BF(name,value))
++
++#endif /* __HMATRIX_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/hsmc.c avr32-git/arch/avr32/mach-at32ap/hsmc.c
+--- linux-2.6.21.3/arch/avr32/mach-at32ap/hsmc.c       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/mach-at32ap/hsmc.c    2007-06-06 11:33:46.000000000 +0200
+@@ -75,12 +75,35 @@
+               return -EINVAL;
+       }
++      switch (config->nwait_mode) {
++      case 0:
++              mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_DISABLED);
++              break;
++      case 1:
++              mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_RESERVED);
++              break;
++      case 2:
++              mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_FROZEN);
++              break;
++      case 3:
++              mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_READY);
++              break;
++      default:
++              return -EINVAL;
++      }
++
++      if (config->tdf_cycles) {
++              mode |= HSMC_BF(TDF_CYCLES, config->tdf_cycles);
++      }
++
+       if (config->nrd_controlled)
+               mode |= HSMC_BIT(READ_MODE);
+       if (config->nwe_controlled)
+               mode |= HSMC_BIT(WRITE_MODE);
+       if (config->byte_write)
+               mode |= HSMC_BIT(BAT);
++      if (config->tdf_mode)
++              mode |= HSMC_BIT(TDF_MODE);
+       pr_debug("smc cs%d: setup/%08x pulse/%08x cycle/%08x mode/%08x\n",
+                cs, setup, pulse, cycle, mode);
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/Kconfig avr32-git/arch/avr32/mach-at32ap/Kconfig
+--- linux-2.6.21.3/arch/avr32/mach-at32ap/Kconfig      1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/mach-at32ap/Kconfig   2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,31 @@
++if PLATFORM_AT32AP
++
++menu "Atmel AVR32 AP options"
++
++choice
++      prompt "AT32AP7000 static memory bus width"
++      depends on CPU_AT32AP7000
++      default AP7000_16_BIT_SMC
++      help
++        Define the width of the AP7000 external static memory interface.
++        This is used to determine how to mangle the address and/or data
++        when doing little-endian port access.
++
++        The current code can only support a single external memory bus
++        width for all chip selects, excluding the flash (which is using
++        raw access and is thus not affected by any of this.)
++
++config AP7000_32_BIT_SMC
++      bool "32 bit"
++
++config AP7000_16_BIT_SMC
++      bool "16 bit"
++
++config AP7000_8_BIT_SMC
++      bool "8 bit"
++
++endchoice
++
++endmenu
++
++endif # PLATFORM_AT32AP
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/Makefile avr32-git/arch/avr32/mach-at32ap/Makefile
+--- linux-2.6.21.3/arch/avr32/mach-at32ap/Makefile     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/mach-at32ap/Makefile  2007-06-06 11:33:46.000000000 +0200
+@@ -1,2 +1,3 @@
+ obj-y                         += at32ap.o clock.o intc.o extint.o pio.o hsmc.o
+ obj-$(CONFIG_CPU_AT32AP7000)  += at32ap7000.o
++obj-$(CONFIG_CPU_AT32AP7000)  += time-tc.o
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/time-tc.c avr32-git/arch/avr32/mach-at32ap/time-tc.c
+--- linux-2.6.21.3/arch/avr32/mach-at32ap/time-tc.c    1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/arch/avr32/mach-at32ap/time-tc.c 2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,218 @@
++/*
++ * Copyright (C) 2004-2007 Atmel Corporation
++ *
++ * Based on MIPS implementation arch/mips/kernel/time.c
++ *   Copyright 2001 MontaVista Software Inc.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++
++#include <linux/clk.h>
++#include <linux/clocksource.h>
++#include <linux/time.h>
++#include <linux/module.h>
++#include <linux/interrupt.h>
++#include <linux/irq.h>
++#include <linux/kernel_stat.h>
++#include <linux/errno.h>
++#include <linux/init.h>
++#include <linux/profile.h>
++#include <linux/sysdev.h>
++#include <linux/err.h>
++
++#include <asm/div64.h>
++#include <asm/sysreg.h>
++#include <asm/io.h>
++#include <asm/sections.h>
++
++#include <asm/arch/time.h>
++
++/* how many counter cycles in a jiffy? */
++static u32 cycles_per_jiffy;
++
++/* the count value for the next timer interrupt */
++static u32 expirelo;
++
++/* the I/O registers of the TC module */
++static void __iomem *ioregs;
++
++cycle_t read_cycle_count(void)
++{
++      return (cycle_t)timer_read(ioregs, 0, CV);
++}
++
++struct clocksource clocksource_avr32 = {
++      .name           = "avr32",
++      .rating         = 342,
++      .read           = read_cycle_count,
++      .mask           = CLOCKSOURCE_MASK(16),
++      .shift          = 16,
++      .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
++};
++
++static void avr32_timer_ack(void)
++{
++      u16 count = expirelo;
++
++      /* Ack this timer interrupt and set the next one, use a u16
++       * variable so it will wrap around correctly */
++      count += cycles_per_jiffy;
++      expirelo = count;
++      timer_write(ioregs, 0, RC, expirelo);
++
++      /* Check to see if we have missed any timer interrupts */
++      count = timer_read(ioregs, 0, CV);
++      if ((count - expirelo) < 0x7fff) {
++              expirelo = count + cycles_per_jiffy;
++              timer_write(ioregs, 0, RC, expirelo);
++      }
++}
++
++u32 avr32_hpt_read(void)
++{
++      return timer_read(ioregs, 0, CV);
++}
++
++static int avr32_timer_calc_div_and_set_jiffies(struct clk *pclk)
++{
++      unsigned int cycles_max = (clocksource_avr32.mask + 1) / 2;
++      unsigned int divs[] = { 4, 8, 16, 32 };
++      int divs_size = sizeof(divs) / sizeof(*divs);
++      int i = 0;
++      unsigned long count_hz;
++      unsigned long shift;
++      unsigned long mult;
++      int clock_div = -1;
++      u64 tmp;
++
++      shift = clocksource_avr32.shift;
++
++      do {
++              count_hz = clk_get_rate(pclk) / divs[i];
++              mult = clocksource_hz2mult(count_hz, shift);
++              clocksource_avr32.mult = mult;
++
++              tmp = TICK_NSEC;
++              tmp <<= shift;
++              tmp += mult / 2;
++              do_div(tmp, mult);
++
++              cycles_per_jiffy = tmp;
++      } while (cycles_per_jiffy > cycles_max && ++i < divs_size);
++
++      clock_div = i + 1;
++
++      if (clock_div > divs_size) {
++              pr_debug("timer: could not calculate clock divider\n");
++              return -EFAULT;
++      }
++
++      /* Set the clock divider */
++      timer_write(ioregs, 0, CMR, TIMER_BF(CMR_TCCLKS, clock_div));
++
++      return 0;
++}
++
++int avr32_hpt_init(unsigned int count)
++{
++      struct resource *regs;
++      struct clk *pclk;
++      int irq = -1;
++      int ret = 0;
++
++      ret = -ENXIO;
++
++      irq = platform_get_irq(&at32_systc0_device, 0);
++      if (irq < 0) {
++              pr_debug("timer: could not get irq\n");
++              goto out_error;
++      }
++
++      pclk = clk_get(&at32_systc0_device.dev, "pclk");
++      if (IS_ERR(pclk)) {
++              pr_debug("timer: could not get clk: %ld\n", PTR_ERR(pclk));
++              goto out_error;
++      }
++      clk_enable(pclk);
++
++      regs = platform_get_resource(&at32_systc0_device, IORESOURCE_MEM, 0);
++      if (!regs) {
++              pr_debug("timer: could not get resource\n");
++              goto out_error_clk;
++      }
++
++      ioregs = ioremap(regs->start, regs->end - regs->start + 1);
++      if (!ioregs) {
++              pr_debug("timer: could not get ioregs\n");
++              goto out_error_clk;
++      }
++
++      ret = avr32_timer_calc_div_and_set_jiffies(pclk);
++      if (ret)
++              goto out_error_io;
++
++      ret = setup_irq(irq, &timer_irqaction);
++      if (ret) {
++              pr_debug("timer: could not request irq %d: %d\n",
++                              irq, ret);
++              goto out_error_io;
++      }
++
++      expirelo = (timer_read(ioregs, 0, CV) / cycles_per_jiffy + 1)
++              * cycles_per_jiffy;
++
++      /* Enable clock and interrupts on RC compare */
++      timer_write(ioregs, 0, CCR, TIMER_BIT(CCR_CLKEN));
++      timer_write(ioregs, 0, IER, TIMER_BIT(IER_CPCS));
++      /* Set cycles to first interrupt */
++      timer_write(ioregs, 0,  RC, expirelo);
++
++      printk(KERN_INFO "timer: AT32AP system timer/counter at 0x%p irq %d\n",
++                      ioregs, irq);
++
++      return 0;
++
++out_error_io:
++      iounmap(ioregs);
++out_error_clk:
++      clk_put(pclk);
++out_error:
++      return ret;
++}
++
++int avr32_hpt_start(void)
++{
++      timer_write(ioregs, 0, CCR, TIMER_BIT(CCR_SWTRG));
++      return 0;
++}
++
++irqreturn_t timer_interrupt(int irq, void *dev_id)
++{
++      unsigned int sr = timer_read(ioregs, 0, SR);
++
++      if (sr & TIMER_BIT(SR_CPCS)) {
++              /* ack timer interrupt and try to set next interrupt */
++              avr32_timer_ack();
++
++              /*
++               * Call the generic timer interrupt handler
++               */
++              write_seqlock(&xtime_lock);
++              do_timer(1);
++              write_sequnlock(&xtime_lock);
++
++              /*
++               * In UP mode, we call local_timer_interrupt() to do profiling
++               * and process accounting.
++               *
++               * SMP is not supported yet.
++               */
++              local_timer_interrupt(irq, dev_id);
++
++              return IRQ_HANDLED;
++      }
++
++      return IRQ_NONE;
++}
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/Makefile avr32-git/arch/avr32/Makefile
+--- linux-2.6.21.3/arch/avr32/Makefile 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/Makefile      2007-06-06 11:33:46.000000000 +0200
+@@ -16,7 +16,7 @@
+ CFLAGS_MODULE += -mno-relax
+ LDFLAGS_vmlinux       += --relax
+-cpuflags-$(CONFIG_CPU_AP7000) += -mcpu=ap7000
++cpuflags-$(CONFIG_CPU_AT32AP7000)     += -mcpu=ap7000
+ CFLAGS                += $(cpuflags-y)
+ AFLAGS                += $(cpuflags-y)
+@@ -27,9 +27,11 @@
+ head-y                                        += arch/avr32/kernel/head.o
+ core-$(CONFIG_PLATFORM_AT32AP)                += arch/avr32/mach-at32ap/
+ core-$(CONFIG_BOARD_ATSTK1000)                += arch/avr32/boards/atstk1000/
++core-$(CONFIG_BOARD_ATNGW100)         += arch/avr32/boards/atngw100/
+ core-$(CONFIG_LOADER_U_BOOT)          += arch/avr32/boot/u-boot/
+ core-y                                        += arch/avr32/kernel/
+ core-y                                        += arch/avr32/mm/
++drivers-y                             += arch/avr32/drivers/
+ libs-y                                        += arch/avr32/lib/
+ archincdir-$(CONFIG_PLATFORM_AT32AP)  := arch-at32ap
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mm/dma-coherent.c avr32-git/arch/avr32/mm/dma-coherent.c
+--- linux-2.6.21.3/arch/avr32/mm/dma-coherent.c        2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/mm/dma-coherent.c     2007-06-06 11:33:46.000000000 +0200
+@@ -112,16 +112,21 @@
+ }
+ EXPORT_SYMBOL(dma_free_coherent);
+-#if 0
+ void *dma_alloc_writecombine(struct device *dev, size_t size,
+                            dma_addr_t *handle, gfp_t gfp)
+ {
+       struct page *page;
++      dma_addr_t phys;
+       page = __dma_alloc(dev, size, handle, gfp);
++      if (!page)
++              return NULL;
++
++      phys = page_to_phys(page);
++      *handle = phys;
+       /* Now, map the page into P3 with write-combining turned on */
+-      return __ioremap(page_to_phys(page), size, _PAGE_BUFFER);
++      return __ioremap(phys, size, _PAGE_BUFFER);
+ }
+ EXPORT_SYMBOL(dma_alloc_writecombine);
+@@ -132,8 +137,7 @@
+       iounmap(cpu_addr);
+-      page = bus_to_page(handle);
++      page = phys_to_page(handle);
+       __dma_free(dev, size, page, handle);
+ }
+ EXPORT_SYMBOL(dma_free_writecombine);
+-#endif
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mm/fault.c avr32-git/arch/avr32/mm/fault.c
+--- linux-2.6.21.3/arch/avr32/mm/fault.c       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/mm/fault.c    2007-06-06 11:33:46.000000000 +0200
+@@ -12,73 +12,46 @@
+ #include <linux/mm.h>
+ #include <linux/module.h>
+ #include <linux/pagemap.h>
++#include <linux/kprobes.h>
+ #include <asm/kdebug.h>
+ #include <asm/mmu_context.h>
+ #include <asm/sysreg.h>
+-#include <asm/uaccess.h>
+ #include <asm/tlb.h>
+-
+-#ifdef DEBUG
+-static void dump_code(unsigned long pc)
+-{
+-      char *p = (char *)pc;
+-      char val;
+-      int i;
+-
+-
+-      printk(KERN_DEBUG "Code:");
+-      for (i = 0; i < 16; i++) {
+-              if (__get_user(val, p + i))
+-                      break;
+-              printk(" %02x", val);
+-      }
+-      printk("\n");
+-}
+-#endif
++#include <asm/uaccess.h>
+ #ifdef CONFIG_KPROBES
+-ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain);
+-
+-/* Hook to register for page fault notifications */
+-int register_page_fault_notifier(struct notifier_block *nb)
++static inline int notify_page_fault(struct pt_regs *regs, int trap)
+ {
+-      return atomic_notifier_chain_register(&notify_page_fault_chain, nb);
+-}
++      int ret = 0;
+-int unregister_page_fault_notifier(struct notifier_block *nb)
+-{
+-      return atomic_notifier_chain_unregister(&notify_page_fault_chain, nb);
+-}
++      if (!user_mode(regs)) {
++              if (kprobe_running() && kprobe_fault_handler(regs, trap))
++                      ret = 1;
++      }
+-static inline int notify_page_fault(enum die_val val, struct pt_regs *regs,
+-                                  int trap, int sig)
+-{
+-      struct die_args args = {
+-              .regs = regs,
+-              .trapnr = trap,
+-      };
+-      return atomic_notifier_call_chain(&notify_page_fault_chain, val, &args);
++      return ret;
+ }
+ #else
+-static inline int notify_page_fault(enum die_val val, struct pt_regs *regs,
+-                                  int trap, int sig)
++static inline int notify_page_fault(struct pt_regs *regs, int trap)
+ {
+-      return NOTIFY_DONE;
++      return 0;
+ }
+ #endif
++int exception_trace = 1;
++
+ /*
+  * This routine handles page faults. It determines the address and the
+  * problem, and then passes it off to one of the appropriate routines.
+  *
+  * ecr is the Exception Cause Register. Possible values are:
+- *   5:  Page not found (instruction access)
+  *   6:  Protection fault (instruction access)
+- *   12: Page not found (read access)
+- *   13: Page not found (write access)
+- *   14: Protection fault (read access)
+- *   15: Protection fault (write access)
++ *   15: Protection fault (read access)
++ *   16: Protection fault (write access)
++ *   20: Page not found (instruction access)
++ *   24: Page not found (read access)
++ *   28: Page not found (write access)
+  */
+ asmlinkage void do_page_fault(unsigned long ecr, struct pt_regs *regs)
+ {
+@@ -88,10 +61,11 @@
+       const struct exception_table_entry *fixup;
+       unsigned long address;
+       unsigned long page;
+-      int writeaccess = 0;
++      int writeaccess;
++      long signr;
++      int code;
+-      if (notify_page_fault(DIE_PAGE_FAULT, regs,
+-                            ecr, SIGSEGV) == NOTIFY_STOP)
++      if (notify_page_fault(regs, ecr))
+               return;
+       address = sysreg_read(TLBEAR);
+@@ -99,6 +73,9 @@
+       tsk = current;
+       mm = tsk->mm;
++      signr = SIGSEGV;
++      code = SEGV_MAPERR;
++
+       /*
+        * If we're in an interrupt or have no user context, we must
+        * not take the fault...
+@@ -125,7 +102,9 @@
+        * can handle it...
+        */
+ good_area:
+-      //pr_debug("good area: vm_flags = 0x%lx\n", vma->vm_flags);
++      code = SEGV_ACCERR;
++      writeaccess = 0;
++
+       switch (ecr) {
+       case ECR_PROTECTION_X:
+       case ECR_TLB_MISS_X:
+@@ -176,46 +155,24 @@
+        * map. Fix it, but check if it's kernel or user first...
+        */
+ bad_area:
+-      pr_debug("Bad area [%s:%u]: addr %08lx, ecr %lu\n",
+-               tsk->comm, tsk->pid, address, ecr);
+-
+       up_read(&mm->mmap_sem);
+       if (user_mode(regs)) {
+-              /* Hmm...we have to pass address and ecr somehow... */
+-              /* tsk->thread.address = address;
+-                 tsk->thread.error_code = ecr; */
+-#ifdef DEBUG
+-              show_regs(regs);
+-              dump_code(regs->pc);
+-
+-              page = sysreg_read(PTBR);
+-              printk("ptbr = %08lx", page);
+-              if (page) {
+-                      page = ((unsigned long *)page)[address >> 22];
+-                      printk(" pgd = %08lx", page);
+-                      if (page & _PAGE_PRESENT) {
+-                              page &= PAGE_MASK;
+-                              address &= 0x003ff000;
+-                              page = ((unsigned long *)__va(page))[address >> PAGE_SHIFT];
+-                              printk(" pte = %08lx\n", page);
+-                      }
+-              }
+-#endif
+-              pr_debug("Sending SIGSEGV to PID %d...\n",
+-                      tsk->pid);
+-              force_sig(SIGSEGV, tsk);
++              if (exception_trace && printk_ratelimit())
++                      printk("%s%s[%d]: segfault at %08lx pc %08lx "
++                             "sp %08lx ecr %lu\n",
++                             is_init(tsk) ? KERN_EMERG : KERN_INFO,
++                             tsk->comm, tsk->pid, address, regs->pc,
++                             regs->sp, ecr);
++              _exception(SIGSEGV, regs, code, address);
+               return;
+       }
+ no_context:
+-      pr_debug("No context\n");
+-
+       /* Are we prepared to handle this kernel fault? */
+       fixup = search_exception_tables(regs->pc);
+       if (fixup) {
+               regs->pc = fixup->fixup;
+-              pr_debug("Found fixup at %08lx\n", fixup->fixup);
+               return;
+       }
+@@ -230,7 +187,6 @@
+               printk(KERN_ALERT
+                      "Unable to handle kernel paging request");
+       printk(" at virtual address %08lx\n", address);
+-      printk(KERN_ALERT "pc = %08lx\n", regs->pc);
+       page = sysreg_read(PTBR);
+       printk(KERN_ALERT "ptbr = %08lx", page);
+@@ -241,20 +197,20 @@
+                       page &= PAGE_MASK;
+                       address &= 0x003ff000;
+                       page = ((unsigned long *)__va(page))[address >> PAGE_SHIFT];
+-                      printk(" pte = %08lx\n", page);
++                      printk(" pte = %08lx", page);
+               }
+       }
+-      die("\nOops", regs, ecr);
+-      do_exit(SIGKILL);
++      printk("\n");
++      die("Kernel access of bad area", regs, signr);
++      return;
+       /*
+        * We ran out of memory, or some other thing happened to us
+        * that made us unable to handle the page fault gracefully.
+        */
+ out_of_memory:
+-      printk("Out of memory\n");
+       up_read(&mm->mmap_sem);
+-      if (current->pid == 1) {
++      if (is_init(current)) {
+               yield();
+               down_read(&mm->mmap_sem);
+               goto survive;
+@@ -267,21 +223,20 @@
+ do_sigbus:
+       up_read(&mm->mmap_sem);
+-      /*
+-       * Send a sigbus, regardless of whether we were in kernel or
+-       * user mode.
+-       */
+-      /* address, error_code, trap_no, ... */
+-#ifdef DEBUG
+-      show_regs(regs);
+-      dump_code(regs->pc);
+-#endif
+-      pr_debug("Sending SIGBUS to PID %d...\n", tsk->pid);
+-      force_sig(SIGBUS, tsk);
+-
+       /* Kernel mode? Handle exceptions or die */
++      signr = SIGBUS;
++      code = BUS_ADRERR;
+       if (!user_mode(regs))
+               goto no_context;
++
++      if (exception_trace)
++              printk("%s%s[%d]: bus error at %08lx pc %08lx "
++                     "sp %08lx ecr %lu\n",
++                     is_init(tsk) ? KERN_EMERG : KERN_INFO,
++                     tsk->comm, tsk->pid, address, regs->pc,
++                     regs->sp, ecr);
++
++      _exception(SIGBUS, regs, BUS_ADRERR, address);
+ }
+ asmlinkage void do_bus_error(unsigned long addr, int write_access,
+@@ -292,8 +247,7 @@
+              addr, write_access ? "write" : "read");
+       printk(KERN_INFO "DTLB dump:\n");
+       dump_dtlb();
+-      die("Bus Error", regs, write_access);
+-      do_exit(SIGKILL);
++      die("Bus Error", regs, SIGKILL);
+ }
+ /*
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mm/init.c avr32-git/arch/avr32/mm/init.c
+--- linux-2.6.21.3/arch/avr32/mm/init.c        2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/arch/avr32/mm/init.c     2007-06-06 11:33:46.000000000 +0200
+@@ -10,11 +10,9 @@
+ #include <linux/mm.h>
+ #include <linux/swap.h>
+ #include <linux/init.h>
+-#include <linux/initrd.h>
+ #include <linux/mmzone.h>
+ #include <linux/bootmem.h>
+ #include <linux/pagemap.h>
+-#include <linux/pfn.h>
+ #include <linux/nodemask.h>
+ #include <asm/page.h>
+@@ -78,242 +76,6 @@
+       printk ("%d pages swap cached\n", cached);
+ }
+-static void __init print_memory_map(const char *what,
+-                                  struct tag_mem_range *mem)
+-{
+-      printk ("%s:\n", what);
+-      for (; mem; mem = mem->next) {
+-              printk ("  %08lx - %08lx\n",
+-                      (unsigned long)mem->addr,
+-                      (unsigned long)(mem->addr + mem->size));
+-      }
+-}
+-
+-#define MAX_LOWMEM    HIGHMEM_START
+-#define MAX_LOWMEM_PFN        PFN_DOWN(MAX_LOWMEM)
+-
+-/*
+- * Sort a list of memory regions in-place by ascending address.
+- *
+- * We're using bubble sort because we only have singly linked lists
+- * with few elements.
+- */
+-static void __init sort_mem_list(struct tag_mem_range **pmem)
+-{
+-      int done;
+-      struct tag_mem_range **a, **b;
+-
+-      if (!*pmem)
+-              return;
+-
+-      do {
+-              done = 1;
+-              a = pmem, b = &(*pmem)->next;
+-              while (*b) {
+-                      if ((*a)->addr > (*b)->addr) {
+-                              struct tag_mem_range *tmp;
+-                              tmp = (*b)->next;
+-                              (*b)->next = *a;
+-                              *a = *b;
+-                              *b = tmp;
+-                              done = 0;
+-                      }
+-                      a = &(*a)->next;
+-                      b = &(*a)->next;
+-              }
+-      } while (!done);
+-}
+-
+-/*
+- * Find a free memory region large enough for storing the
+- * bootmem bitmap.
+- */
+-static unsigned long __init
+-find_bootmap_pfn(const struct tag_mem_range *mem)
+-{
+-      unsigned long bootmap_pages, bootmap_len;
+-      unsigned long node_pages = PFN_UP(mem->size);
+-      unsigned long bootmap_addr = mem->addr;
+-      struct tag_mem_range *reserved = mem_reserved;
+-      struct tag_mem_range *ramdisk = mem_ramdisk;
+-      unsigned long kern_start = virt_to_phys(_stext);
+-      unsigned long kern_end = virt_to_phys(_end);
+-
+-      bootmap_pages = bootmem_bootmap_pages(node_pages);
+-      bootmap_len = bootmap_pages << PAGE_SHIFT;
+-
+-      /*
+-       * Find a large enough region without reserved pages for
+-       * storing the bootmem bitmap. We can take advantage of the
+-       * fact that all lists have been sorted.
+-       *
+-       * We have to check explicitly reserved regions as well as the
+-       * kernel image and any RAMDISK images...
+-       *
+-       * Oh, and we have to make sure we don't overwrite the taglist
+-       * since we're going to use it until the bootmem allocator is
+-       * fully up and running.
+-       */
+-      while (1) {
+-              if ((bootmap_addr < kern_end) &&
+-                  ((bootmap_addr + bootmap_len) > kern_start))
+-                      bootmap_addr = kern_end;
+-
+-              while (reserved &&
+-                     (bootmap_addr >= (reserved->addr + reserved->size)))
+-                      reserved = reserved->next;
+-
+-              if (reserved &&
+-                  ((bootmap_addr + bootmap_len) >= reserved->addr)) {
+-                      bootmap_addr = reserved->addr + reserved->size;
+-                      continue;
+-              }
+-
+-              while (ramdisk &&
+-                     (bootmap_addr >= (ramdisk->addr + ramdisk->size)))
+-                      ramdisk = ramdisk->next;
+-
+-              if (!ramdisk ||
+-                  ((bootmap_addr + bootmap_len) < ramdisk->addr))
+-                      break;
+-
+-              bootmap_addr = ramdisk->addr + ramdisk->size;
+-      }
+-
+-      if ((PFN_UP(bootmap_addr) + bootmap_len) >= (mem->addr + mem->size))
+-              return ~0UL;
+-
+-      return PFN_UP(bootmap_addr);
+-}
+-
+-void __init setup_bootmem(void)
+-{
+-      unsigned bootmap_size;
+-      unsigned long first_pfn, bootmap_pfn, pages;
+-      unsigned long max_pfn, max_low_pfn;
+-      unsigned long kern_start = virt_to_phys(_stext);
+-      unsigned long kern_end = virt_to_phys(_end);
+-      unsigned node = 0;
+-      struct tag_mem_range *bank, *res;
+-
+-      sort_mem_list(&mem_phys);
+-      sort_mem_list(&mem_reserved);
+-
+-      print_memory_map("Physical memory", mem_phys);
+-      print_memory_map("Reserved memory", mem_reserved);
+-
+-      nodes_clear(node_online_map);
+-
+-      if (mem_ramdisk) {
+-#ifdef CONFIG_BLK_DEV_INITRD
+-              initrd_start = (unsigned long)__va(mem_ramdisk->addr);
+-              initrd_end = initrd_start + mem_ramdisk->size;
+-
+-              print_memory_map("RAMDISK images", mem_ramdisk);
+-              if (mem_ramdisk->next)
+-                      printk(KERN_WARNING
+-                             "Warning: Only the first RAMDISK image "
+-                             "will be used\n");
+-              sort_mem_list(&mem_ramdisk);
+-#else
+-              printk(KERN_WARNING "RAM disk image present, but "
+-                     "no initrd support in kernel!\n");
+-#endif
+-      }
+-
+-      if (mem_phys->next)
+-              printk(KERN_WARNING "Only using first memory bank\n");
+-
+-      for (bank = mem_phys; bank; bank = NULL) {
+-              first_pfn = PFN_UP(bank->addr);
+-              max_low_pfn = max_pfn = PFN_DOWN(bank->addr + bank->size);
+-              bootmap_pfn = find_bootmap_pfn(bank);
+-              if (bootmap_pfn > max_pfn)
+-                      panic("No space for bootmem bitmap!\n");
+-
+-              if (max_low_pfn > MAX_LOWMEM_PFN) {
+-                      max_low_pfn = MAX_LOWMEM_PFN;
+-#ifndef CONFIG_HIGHMEM
+-                      /*
+-                       * Lowmem is memory that can be addressed
+-                       * directly through P1/P2
+-                       */
+-                      printk(KERN_WARNING
+-                             "Node %u: Only %ld MiB of memory will be used.\n",
+-                             node, MAX_LOWMEM >> 20);
+-                      printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
+-#else
+-#error HIGHMEM is not supported by AVR32 yet
+-#endif
+-              }
+-
+-              /* Initialize the boot-time allocator with low memory only. */
+-              bootmap_size = init_bootmem_node(NODE_DATA(node), bootmap_pfn,
+-                                               first_pfn, max_low_pfn);
+-
+-              printk("Node %u: bdata = %p, bdata->node_bootmem_map = %p\n",
+-                     node, NODE_DATA(node)->bdata,
+-                     NODE_DATA(node)->bdata->node_bootmem_map);
+-
+-              /*
+-               * Register fully available RAM pages with the bootmem
+-               * allocator.
+-               */
+-              pages = max_low_pfn - first_pfn;
+-              free_bootmem_node (NODE_DATA(node), PFN_PHYS(first_pfn),
+-                                 PFN_PHYS(pages));
+-
+-              /*
+-               * Reserve space for the kernel image (if present in
+-               * this node)...
+-               */
+-              if ((kern_start >= PFN_PHYS(first_pfn)) &&
+-                  (kern_start < PFN_PHYS(max_pfn))) {
+-                      printk("Node %u: Kernel image %08lx - %08lx\n",
+-                             node, kern_start, kern_end);
+-                      reserve_bootmem_node(NODE_DATA(node), kern_start,
+-                                           kern_end - kern_start);
+-              }
+-
+-              /* ...the bootmem bitmap... */
+-              reserve_bootmem_node(NODE_DATA(node),
+-                                   PFN_PHYS(bootmap_pfn),
+-                                   bootmap_size);
+-
+-              /* ...any RAMDISK images... */
+-              for (res = mem_ramdisk; res; res = res->next) {
+-                      if (res->addr > PFN_PHYS(max_pfn))
+-                              break;
+-
+-                      if (res->addr >= PFN_PHYS(first_pfn)) {
+-                              printk("Node %u: RAMDISK %08lx - %08lx\n",
+-                                     node,
+-                                     (unsigned long)res->addr,
+-                                     (unsigned long)(res->addr + res->size));
+-                              reserve_bootmem_node(NODE_DATA(node),
+-                                                   res->addr, res->size);
+-                      }
+-              }
+-
+-              /* ...and any other reserved regions. */
+-              for (res = mem_reserved; res; res = res->next) {
+-                      if (res->addr > PFN_PHYS(max_pfn))
+-                              break;
+-
+-                      if (res->addr >= PFN_PHYS(first_pfn)) {
+-                              printk("Node %u: Reserved %08lx - %08lx\n",
+-                                     node,
+-                                     (unsigned long)res->addr,
+-                                     (unsigned long)(res->addr + res->size));
+-                              reserve_bootmem_node(NODE_DATA(node),
+-                                                   res->addr, res->size);
+-                      }
+-              }
+-
+-              node_set_online(node);
+-      }
+-}
+-
+ /*
+  * paging_init() sets up the page tables
+  *
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/atmeltwi.h avr32-git/drivers/i2c/busses/atmeltwi.h
+--- linux-2.6.21.3/drivers/i2c/busses/atmeltwi.h       1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/drivers/i2c/busses/atmeltwi.h    2007-06-06 11:33:51.000000000 +0200
+@@ -0,0 +1,117 @@
++/*
++ * Register definitions for the Atmel Two-Wire Interface
++ */
++
++#ifndef __ASM_AVR32_TWI_H__
++#define __ASM_AVR32_TWI_H__
++
++/* TWI register offsets */
++#define TWI_CR                                        0x0000
++#define TWI_MMR                                       0x0004
++#define TWI_SMR                                       0x0008
++#define TWI_IADR                              0x000c
++#define TWI_CWGR                              0x0010
++#define TWI_SR                                        0x0020
++#define TWI_IER                                       0x0024
++#define TWI_IDR                                       0x0028
++#define TWI_IMR                                       0x002c
++#define TWI_RHR                                       0x0030
++#define TWI_THR                                       0x0034
++
++/* Bitfields in CR */
++#define TWI_START_OFFSET                      0
++#define TWI_START_SIZE                                1
++#define TWI_STOP_OFFSET                               1
++#define TWI_STOP_SIZE                         1
++#define TWI_MSEN_OFFSET                               2
++#define TWI_MSEN_SIZE                         1
++#define TWI_MSDIS_OFFSET                      3
++#define TWI_MSDIS_SIZE                                1
++#define TWI_SVEN_OFFSET                               4
++#define TWI_SVEN_SIZE                         1
++#define TWI_SVDIS_OFFSET                      5
++#define TWI_SVDIS_SIZE                                1
++#define TWI_SWRST_OFFSET                      7
++#define TWI_SWRST_SIZE                                1
++
++/* Bitfields in MMR */
++#define TWI_IADRSZ_OFFSET                     8
++#define TWI_IADRSZ_SIZE                               2
++#define TWI_MREAD_OFFSET                      12
++#define TWI_MREAD_SIZE                                1
++#define TWI_DADR_OFFSET                               16
++#define TWI_DADR_SIZE                         7
++
++/* Bitfields in SMR */
++#define TWI_SADR_OFFSET                               16
++#define TWI_SADR_SIZE                         7
++
++/* Bitfields in IADR */
++#define TWI_IADR_OFFSET                               0
++#define TWI_IADR_SIZE                         24
++
++/* Bitfields in CWGR */
++#define TWI_CLDIV_OFFSET                      0
++#define TWI_CLDIV_SIZE                                8
++#define TWI_CHDIV_OFFSET                      8
++#define TWI_CHDIV_SIZE                                8
++#define TWI_CKDIV_OFFSET                      16
++#define TWI_CKDIV_SIZE                                3
++
++/* Bitfields in SR */
++#define TWI_TXCOMP_OFFSET                     0
++#define TWI_TXCOMP_SIZE                               1
++#define TWI_RXRDY_OFFSET                      1
++#define TWI_RXRDY_SIZE                                1
++#define TWI_TXRDY_OFFSET                      2
++#define TWI_TXRDY_SIZE                                1
++#define TWI_SVDIR_OFFSET                      3
++#define TWI_SVDIR_SIZE                                1
++#define TWI_SVACC_OFFSET                      4
++#define TWI_SVACC_SIZE                                1
++#define TWI_GCACC_OFFSET                      5
++#define TWI_GCACC_SIZE                                1
++#define TWI_OVRE_OFFSET                               6
++#define TWI_OVRE_SIZE                         1
++#define TWI_UNRE_OFFSET                               7
++#define TWI_UNRE_SIZE                         1
++#define TWI_NACK_OFFSET                               8
++#define TWI_NACK_SIZE                         1
++#define TWI_ARBLST_OFFSET                     9
++#define TWI_ARBLST_SIZE                               1
++
++/* Bitfields in RHR */
++#define TWI_RXDATA_OFFSET                     0
++#define TWI_RXDATA_SIZE                               8
++
++/* Bitfields in THR */
++#define TWI_TXDATA_OFFSET                     0
++#define TWI_TXDATA_SIZE                               8
++
++/* Constants for IADRSZ */
++#define TWI_IADRSZ_NO_ADDR                    0
++#define TWI_IADRSZ_ONE_BYTE                   1
++#define TWI_IADRSZ_TWO_BYTES                  2
++#define TWI_IADRSZ_THREE_BYTES                        3
++
++/* Bit manipulation macros */
++#define TWI_BIT(name)                                 \
++      (1 << TWI_##name##_OFFSET)
++#define TWI_BF(name,value)                            \
++      (((value) & ((1 << TWI_##name##_SIZE) - 1))     \
++       << TWI_##name##_OFFSET)
++#define TWI_BFEXT(name,value)                         \
++      (((value) >> TWI_##name##_OFFSET)               \
++       & ((1 << TWI_##name##_SIZE) - 1))
++#define TWI_BFINS(name,value,old)                     \
++      (((old) & ~(((1 << TWI_##name##_SIZE) - 1)      \
++                  << TWI_##name##_OFFSET))            \
++       | TWI_BF(name,value))
++
++/* Register access macros */
++#define twi_readl(port,reg)                           \
++      __raw_readl((port)->regs + TWI_##reg)
++#define twi_writel(port,reg,value)                    \
++      __raw_writel((value), (port)->regs + TWI_##reg)
++
++#endif /* __ASM_AVR32_TWI_H__ */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/i2c-atmeltwi.c avr32-git/drivers/i2c/busses/i2c-atmeltwi.c
+--- linux-2.6.21.3/drivers/i2c/busses/i2c-atmeltwi.c   1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/drivers/i2c/busses/i2c-atmeltwi.c        2007-06-06 11:33:51.000000000 +0200
+@@ -0,0 +1,348 @@
++/*
++ * i2c Support for Atmel's Two-Wire Interface (TWI)
++ *
++ * Based on the work of Copyright (C) 2004 Rick Bronson
++ * Converted to 2.6 by Andrew Victor <andrew at sanpeople.com>
++ * Ported to AVR32 and heavily modified by Espen Krangnes <ekrangnes at atmel.com>
++ *
++ * Copyright (C) 2006 Atmel Corporation
++ *
++ * Borrowed heavily from the original work by:
++ * Copyright (C) 2000 Philip Edelbrock <phil at stimpy.netroedge.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ */
++
++
++#include <linux/err.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/slab.h>
++#include <linux/types.h>
++#include <linux/delay.h>
++#include <linux/i2c.h>
++#include <linux/init.h>
++#include <linux/clk.h>
++#include <linux/interrupt.h>
++#include <linux/irq.h>
++#include <linux/platform_device.h>
++#include <linux/completion.h>
++#include <asm/io.h>
++#include <linux/time.h>
++#include "atmeltwi.h"
++
++static unsigned int baudrate = CONFIG_I2C_ATMELTWI_BAUDRATE;
++module_param(baudrate, uint, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
++MODULE_PARM_DESC(baudrate, "The TWI baudrate");
++
++
++struct atmel_twi {
++      void __iomem *regs;
++      struct i2c_adapter adapter;
++      struct clk *pclk;
++      spinlock_t lock;
++      struct completion comp;
++      u32 intmask;
++      u8 *buf;
++      u8 len;
++      u8 acks_left;
++      unsigned int irq;
++
++};
++#define to_atmel_twi(adap) container_of(adap, struct atmel_twi, adapter)
++
++/*
++ * Initialize the TWI hardware registers.
++ */
++static int __devinit twi_hwinit(struct atmel_twi *twi)
++{
++      unsigned long cdiv, ckdiv=0;
++
++      twi_writel(twi, IDR, ~0UL);
++      twi_writel(twi, CR, TWI_BIT(SWRST));    /*Reset peripheral*/
++      twi_readl(twi, SR);
++
++      cdiv = (clk_get_rate(twi->pclk) / (2 * baudrate)) - 4;
++
++      while (cdiv > 255) {
++              ckdiv++;
++              cdiv = cdiv >> 1;
++      }
++
++      if (ckdiv > 7)
++              return -EINVAL;
++      else
++              twi_writel(twi, CWGR, (TWI_BF(CKDIV, ckdiv)
++                             | TWI_BF(CHDIV, cdiv)
++                             | TWI_BF(CLDIV, cdiv)));
++      return 0;
++}
++
++/*
++ * Waits for the i2c status register to set the specified bitmask
++ * Returns 0 if timed out (~100ms).
++ */
++static short twi_wait_for_completion(struct atmel_twi *twi,
++              u32 mask)
++{
++      int timeout = msecs_to_jiffies(100);
++
++      twi->intmask = mask;
++      init_completion(&twi->comp);
++
++      twi_writel(twi, IER, mask);
++
++      if(!wait_for_completion_timeout(&twi->comp, timeout))
++              return -ETIMEDOUT;
++
++      return 0;
++}
++
++/*
++ * Generic i2c master transfer entrypoint.
++ */
++static int twi_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
++{
++      struct atmel_twi *twi = to_atmel_twi(adap);
++      struct i2c_msg *pmsg;
++      int i;
++
++      /* get first message */
++      pmsg = msgs;
++
++      dev_dbg(&adap->dev, "twi_xfer: processing %d messages:\n", num);
++
++      for (i = 0; i < num; i++, pmsg++) {
++
++              twi->len = pmsg->len;
++              twi->buf = pmsg->buf;
++              twi->acks_left = pmsg->len;
++              twi_writel(twi, MMR, TWI_BF(DADR, pmsg->addr) |
++                      (pmsg->flags & I2C_M_RD ? TWI_BIT(MREAD) : 0));
++              twi_writel(twi, IADR, TWI_BF(IADR, pmsg->addr));
++
++              dev_dbg(&adap->dev,"#%d: internal addr %d %s byte%s %s 0x%02x\n",
++                      i,pmsg->len, pmsg->flags & I2C_M_RD ? "reading" : "writing",
++                      pmsg->len > 1 ? "s" : "",
++                      pmsg->flags & I2C_M_RD ? "from" : "to", pmsg->addr);
++
++              /* enable */
++              twi_writel(twi, CR, TWI_BIT(MSEN));
++
++              if (pmsg->flags & I2C_M_RD) {
++                      twi_writel(twi, CR, TWI_BIT(START));
++                      if ( twi_wait_for_completion(twi,TWI_BIT(RXRDY))==-ETIMEDOUT ) {
++                              dev_dbg(&adap->dev, "RXRDY timeout. Stopped with %d bytes left\n",
++                                      twi->acks_left);
++                              return -ETIMEDOUT;
++                      }
++
++                      /* Send Stop, and Wait until transfer is finished */
++                      if ( twi_wait_for_completion(twi,TWI_BIT(TXCOMP))==-ETIMEDOUT ) {
++                              dev_dbg(&adap->dev, "TXCOMP timeout\n");
++                              return -ETIMEDOUT;
++                      }
++
++              } else {
++                      twi_writel(twi, THR, twi->buf[0]);
++                      if ( twi_wait_for_completion(twi,TWI_BIT(TXRDY))==-ETIMEDOUT ) {
++                              dev_dbg(&adap->dev, "TXRDY timeout. Stopped with %d bytes left\n",
++                              twi->acks_left);
++                              return -ETIMEDOUT;
++                      }
++              }
++
++              /* Disable TWI interface */
++              twi_writel(twi, CR, TWI_BIT(MSDIS));
++
++      } /* end cur msg */
++
++      return i;
++}
++
++
++static irqreturn_t twi_interrupt(int irq, void *dev_id, struct pt_regs *regs)
++{
++      struct atmel_twi *twi = dev_id;
++      int status = twi_readl(twi, SR);
++
++      if (twi->intmask & status){
++              if (twi->intmask & TWI_BIT(NACK)) {
++                      goto nack;
++              } else if (twi->intmask & TWI_BIT(RXRDY)){
++                      twi->buf[twi->len - twi->acks_left] = twi_readl(twi,RHR);
++                      if(--twi->acks_left==1)
++                              twi_writel(twi, CR, TWI_BIT(STOP));
++                      if (twi->acks_left==0)
++                              goto complete;
++              } else if (twi->intmask & TWI_BIT(TXRDY)) {
++                      twi->acks_left--;
++                      if (twi->acks_left==0) {
++                              twi->intmask = TWI_BIT(TXCOMP);
++                              twi_writel(twi, IER, TWI_BIT(TXCOMP));
++                      } else
++                              twi_writel(twi, THR, twi->buf[twi->len - twi->acks_left]);
++              } else if (twi->intmask & TWI_BIT(TXCOMP)) {
++                      goto complete;
++              }
++      }
++
++      return IRQ_HANDLED;
++
++nack:
++      printk(KERN_INFO "NACK received!\n");
++
++complete:
++      twi_writel(twi, IDR, ~0UL);
++      complete(&twi->comp);
++
++      return IRQ_HANDLED;
++
++}
++
++
++/*
++ * Return list of supported functionality.
++ */
++static u32 twi_func(struct i2c_adapter *adapter)
++{
++      return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
++}
++
++/* For now, we only handle combined mode (smbus) */
++static struct i2c_algorithm twi_algorithm = {
++      .master_xfer    = twi_xfer,
++      .functionality  = twi_func,
++};
++
++/*
++ * Main initialization routine.
++ */
++static int __devinit twi_probe(struct platform_device *pdev)
++{
++      struct atmel_twi *twi;
++      struct resource *regs;
++      struct clk *pclk;
++      struct i2c_adapter *adapter;
++      int rc, irq;
++
++      regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++      if (!regs)
++              return -ENXIO;
++
++      pclk = clk_get(&pdev->dev, "pclk");
++      if (IS_ERR(pclk))
++              return PTR_ERR(pclk);
++      clk_enable(pclk);
++
++      rc = -ENOMEM;
++      twi = kzalloc(sizeof(struct atmel_twi), GFP_KERNEL);
++      if (!twi) {
++              dev_err(&pdev->dev, "can't allocate interface!\n");
++              goto err_alloc_twi;
++      }
++
++      twi->pclk = pclk;
++      twi->regs = ioremap(regs->start, regs->end - regs->start + 1);
++      if (!twi->regs)
++              goto err_ioremap;
++
++      irq = platform_get_irq(pdev,0);
++      rc = request_irq(irq, twi_interrupt, 0, "twi", twi);
++      if (rc) {
++              dev_err(&pdev->dev, "can't bind irq!\n");
++              goto err_irq;
++      }
++      twi->irq = irq;
++
++      rc = twi_hwinit(twi);
++      if (rc) {
++              dev_err(&pdev->dev, "Unable to set baudrate\n");
++              goto err_hw_init;
++      }
++
++      adapter = &twi->adapter;
++      sprintf(adapter->name, "TWI");
++      adapter->algo = &twi_algorithm;
++      adapter->class = I2C_CLASS_HWMON;
++      adapter->dev.parent = &pdev->dev;
++
++      platform_set_drvdata(pdev, twi);
++
++      rc = i2c_add_adapter(adapter);
++      if (rc) {
++              dev_err(&pdev->dev, "Adapter %s registration failed\n",
++                      adapter->name);
++              goto err_register;
++      }
++
++      dev_info(&pdev->dev, "Atmel TWI i2c bus device (baudrate %dk) at 0x%08lx.\n",
++               baudrate/1000, (unsigned long)regs->start);
++
++      return 0;
++
++
++err_register:
++      platform_set_drvdata(pdev, NULL);
++
++err_hw_init:
++      free_irq(irq, twi);
++
++err_irq:
++      iounmap(twi->regs);
++
++err_ioremap:
++      kfree(twi);
++
++err_alloc_twi:
++      clk_disable(pclk);
++      clk_put(pclk);
++
++      return rc;
++}
++
++static int __devexit twi_remove(struct platform_device *pdev)
++{
++      struct atmel_twi *twi = platform_get_drvdata(pdev);
++      int res;
++
++      platform_set_drvdata(pdev, NULL);
++      res = i2c_del_adapter(&twi->adapter);
++      twi_writel(twi, CR, TWI_BIT(MSDIS));
++      iounmap(twi->regs);
++      clk_disable(twi->pclk);
++      clk_put(twi->pclk);
++      free_irq(twi->irq, twi);
++      kfree(twi);
++
++      return res;
++}
++
++static struct platform_driver twi_driver = {
++      .probe          = twi_probe,
++      .remove         = __devexit_p(twi_remove),
++      .driver         = {
++              .name   = "atmel_twi",
++              .owner  = THIS_MODULE,
++      },
++};
++
++static int __init atmel_twi_init(void)
++{
++      return platform_driver_register(&twi_driver);
++}
++
++static void __exit atmel_twi_exit(void)
++{
++      platform_driver_unregister(&twi_driver);
++}
++
++module_init(atmel_twi_init);
++module_exit(atmel_twi_exit);
++
++MODULE_AUTHOR("Espen Krangnes");
++MODULE_DESCRIPTION("I2C driver for Atmel TWI");
++MODULE_LICENSE("GPL");
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/i2c-gpio.c avr32-git/drivers/i2c/busses/i2c-gpio.c
+--- linux-2.6.21.3/drivers/i2c/busses/i2c-gpio.c       1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/drivers/i2c/busses/i2c-gpio.c    2007-06-06 11:33:51.000000000 +0200
+@@ -0,0 +1,215 @@
++/*
++ * Bitbanging I2C bus driver using the GPIO API
++ *
++ * Copyright (C) 2007 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#include <linux/i2c.h>
++#include <linux/i2c-algo-bit.h>
++#include <linux/i2c-gpio.h>
++#include <linux/init.h>
++#include <linux/module.h>
++#include <linux/platform_device.h>
++
++#include <asm/gpio.h>
++
++/* Toggle SDA by changing the direction of the pin */
++static void i2c_gpio_setsda_dir(void *data, int state)
++{
++      struct i2c_gpio_platform_data *pdata = data;
++
++      if (state)
++              gpio_direction_input(pdata->sda_pin);
++      else
++              gpio_direction_output(pdata->sda_pin, 0);
++}
++
++/*
++ * Toggle SDA by changing the output value of the pin. This is only
++ * valid for pins configured as open drain (i.e. setting the value
++ * high effectively turns off the output driver.)
++ */
++static void i2c_gpio_setsda_val(void *data, int state)
++{
++      struct i2c_gpio_platform_data *pdata = data;
++
++      gpio_set_value(pdata->sda_pin, state);
++}
++
++/* Toggle SCL by changing the direction of the pin. */
++static void i2c_gpio_setscl_dir(void *data, int state)
++{
++      struct i2c_gpio_platform_data *pdata = data;
++
++      if (state)
++              gpio_direction_input(pdata->scl_pin);
++      else
++              gpio_direction_output(pdata->scl_pin, 0);
++}
++
++/*
++ * Toggle SCL by changing the output value of the pin. This is used
++ * for pins that are configured as open drain and for output-only
++ * pins. The latter case will break the i2c protocol, but it will
++ * often work in practice.
++ */
++static void i2c_gpio_setscl_val(void *data, int state)
++{
++      struct i2c_gpio_platform_data *pdata = data;
++
++      gpio_set_value(pdata->scl_pin, state);
++}
++
++int i2c_gpio_getsda(void *data)
++{
++      struct i2c_gpio_platform_data *pdata = data;
++
++      return gpio_get_value(pdata->sda_pin);
++}
++
++int i2c_gpio_getscl(void *data)
++{
++      struct i2c_gpio_platform_data *pdata = data;
++
++      return gpio_get_value(pdata->scl_pin);
++}
++
++static int __init i2c_gpio_probe(struct platform_device *pdev)
++{
++      struct i2c_gpio_platform_data *pdata;
++      struct i2c_algo_bit_data *bit_data;
++      struct i2c_adapter *adap;
++      int ret;
++
++      pdata = pdev->dev.platform_data;
++      if (!pdata)
++              return -ENXIO;
++
++      ret = -ENOMEM;
++      adap = kzalloc(sizeof(struct i2c_adapter), GFP_KERNEL);
++      if (!adap)
++              goto err_alloc_adap;
++      bit_data = kzalloc(sizeof(struct i2c_algo_bit_data), GFP_KERNEL);
++      if (!bit_data)
++              goto err_alloc_bit_data;
++
++      ret = gpio_request(pdata->sda_pin, "sda");
++      if (ret)
++              goto err_request_sda;
++      ret = gpio_request(pdata->scl_pin, "scl");
++      if (ret)
++              goto err_request_scl;
++
++      if (pdata->sda_is_open_drain) {
++              gpio_direction_output(pdata->sda_pin, 1);
++              bit_data->setsda = i2c_gpio_setsda_val;
++      } else {
++              gpio_direction_input(pdata->sda_pin);
++              bit_data->setsda = i2c_gpio_setsda_dir;
++      }
++
++      if (pdata->scl_is_open_drain || pdata->scl_is_output_only) {
++              gpio_direction_output(pdata->scl_pin, 1);
++              bit_data->setscl = i2c_gpio_setscl_val;
++      } else {
++              gpio_direction_input(pdata->scl_pin);
++              bit_data->setscl = i2c_gpio_setscl_dir;
++      }
++
++      if (!pdata->scl_is_output_only)
++              bit_data->getscl = i2c_gpio_getscl;
++      bit_data->getsda = i2c_gpio_getsda;
++
++      if (pdata->udelay)
++              bit_data->udelay = pdata->udelay;
++      else if (pdata->scl_is_output_only)
++              bit_data->udelay = 50;                  /* 10 kHz */
++      else
++              bit_data->udelay = 5;                   /* 100 kHz */
++
++      if (pdata->timeout)
++              bit_data->timeout = pdata->timeout;
++      else
++              bit_data->timeout = HZ / 10;            /* 100 ms */
++
++      bit_data->data = pdata;
++
++      adap->owner = THIS_MODULE;
++      snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id);
++      adap->algo_data = bit_data;
++      adap->dev.parent = &pdev->dev;
++
++      ret = i2c_bit_add_bus(adap);
++      if (ret)
++              goto err_add_bus;
++
++      platform_set_drvdata(pdev, adap);
++
++      dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n",
++               pdata->sda_pin, pdata->scl_pin,
++               pdata->scl_is_output_only
++               ? ", no clock stretching" : "");
++
++      return 0;
++
++err_add_bus:
++      gpio_free(pdata->scl_pin);
++err_request_scl:
++      gpio_free(pdata->sda_pin);
++err_request_sda:
++      kfree(bit_data);
++err_alloc_bit_data:
++      kfree(adap);
++err_alloc_adap:
++      return ret;
++}
++
++static int __exit i2c_gpio_remove(struct platform_device *pdev)
++{
++      struct i2c_gpio_platform_data *pdata;
++      struct i2c_adapter *adap;
++
++      adap = platform_get_drvdata(pdev);
++      pdata = pdev->dev.platform_data;
++
++      i2c_del_adapter(adap);
++      gpio_free(pdata->scl_pin);
++      gpio_free(pdata->sda_pin);
++      kfree(adap->algo_data);
++      kfree(adap);
++
++      return 0;
++}
++
++static struct platform_driver i2c_gpio_driver = {
++      .driver         = {
++              .name   = "i2c-gpio",
++              .owner  = THIS_MODULE,
++      },
++      .remove         = __exit_p(i2c_gpio_remove),
++};
++
++static int __init i2c_gpio_init(void)
++{
++      int ret;
++
++      ret = platform_driver_probe(&i2c_gpio_driver, i2c_gpio_probe);
++      if (ret)
++              printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret);
++
++      return ret;
++}
++module_init(i2c_gpio_init);
++
++static void __exit i2c_gpio_exit(void)
++{
++      platform_driver_unregister(&i2c_gpio_driver);
++}
++module_exit(i2c_gpio_exit);
++
++MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>");
++MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver");
++MODULE_LICENSE("GPL");
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/Kconfig avr32-git/drivers/i2c/busses/Kconfig
+--- linux-2.6.21.3/drivers/i2c/busses/Kconfig  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/i2c/busses/Kconfig       2007-06-06 11:33:51.000000000 +0200
+@@ -5,6 +5,26 @@
+ menu "I2C Hardware Bus support"
+       depends on I2C
++config I2C_ATMELTWI
++      tristate "Atmel TWI/I2C"
++      depends on I2C
++      help
++        Atmel on-chip TWI controller. Say Y if you have an AT32 or
++        AT91-based device and want to use its built-in TWI
++        functionality. Atmel's TWI is compatible with Philips' I2C
++        protocol. If in doubt, say NO
++
++config I2C_ATMELTWI_BAUDRATE
++      prompt "Atmel TWI baudrate"
++      depends on I2C_ATMELTWI
++      int
++      default 100000
++      help
++        Set the TWI/I2C baudrate. This will alter the default value. A
++        different baudrate can be set by using a module parameter as well. If
++        no parameter is provided when loading, this is the value that will be
++        used.
++
+ config I2C_ALI1535
+       tristate "ALI 1535"
+       depends on I2C && PCI
+@@ -102,6 +122,14 @@
+         This support is also available as a module.  If so, the module 
+         will be called i2c-elektor.
++config I2C_GPIO
++      tristate "GPIO-based bitbanging I2C"
++      depends on GENERIC_GPIO
++      select I2C_ALGOBIT
++      help
++        This is a very simple bitbanging I2C driver utilizing the
++        arch-neutral GPIO API to control the SCL and SDA lines.
++
+ config I2C_HYDRA
+       tristate "CHRP Apple Hydra Mac I/O I2C interface"
+       depends on I2C && PCI && PPC_CHRP && EXPERIMENTAL
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/Makefile avr32-git/drivers/i2c/busses/Makefile
+--- linux-2.6.21.3/drivers/i2c/busses/Makefile 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/i2c/busses/Makefile      2007-06-06 11:33:51.000000000 +0200
+@@ -11,6 +11,7 @@
+ obj-$(CONFIG_I2C_AT91)                += i2c-at91.o
+ obj-$(CONFIG_I2C_AU1550)      += i2c-au1550.o
+ obj-$(CONFIG_I2C_ELEKTOR)     += i2c-elektor.o
++obj-$(CONFIG_I2C_GPIO)                += i2c-gpio.o
+ obj-$(CONFIG_I2C_HYDRA)               += i2c-hydra.o
+ obj-$(CONFIG_I2C_I801)                += i2c-i801.o
+ obj-$(CONFIG_I2C_I810)                += i2c-i810.o
+@@ -48,6 +49,7 @@
+ obj-$(CONFIG_I2C_VOODOO3)     += i2c-voodoo3.o
+ obj-$(CONFIG_SCx200_ACB)      += scx200_acb.o
+ obj-$(CONFIG_SCx200_I2C)      += scx200_i2c.o
++obj-$(CONFIG_I2C_ATMELTWI)    += i2c-atmeltwi.o
+ ifeq ($(CONFIG_I2C_DEBUG_BUS),y)
+ EXTRA_CFLAGS += -DDEBUG
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/mmc/atmel-mci.c avr32-git/drivers/mmc/atmel-mci.c
+--- linux-2.6.21.3/drivers/mmc/atmel-mci.c     1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/drivers/mmc/atmel-mci.c  2007-06-06 11:33:56.000000000 +0200
+@@ -0,0 +1,1218 @@
++/*
++ * Atmel MultiMedia Card Interface driver
++ *
++ * Copyright (C) 2004-2006 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#include <linux/blkdev.h>
++#include <linux/clk.h>
++#include <linux/device.h>
++#include <linux/dma-mapping.h>
++#include <linux/init.h>
++#include <linux/interrupt.h>
++#include <linux/ioport.h>
++#include <linux/module.h>
++#include <linux/platform_device.h>
++
++#include <linux/mmc/host.h>
++#include <linux/mmc/protocol.h>
++
++#include <asm/dma-controller.h>
++#include <asm/io.h>
++#include <asm/arch/board.h>
++#include <asm/arch/gpio.h>
++
++#include "atmel-mci.h"
++
++#define DRIVER_NAME "atmel_mci"
++
++#define MCI_CMD_ERROR_FLAGS   (MCI_BIT(RINDE) | MCI_BIT(RDIRE) |      \
++                               MCI_BIT(RCRCE) | MCI_BIT(RENDE) |      \
++                               MCI_BIT(RTOE))
++#define MCI_DATA_ERROR_FLAGS  (MCI_BIT(DCRCE) | MCI_BIT(DTOE) |       \
++                               MCI_BIT(OVRE) | MCI_BIT(UNRE))
++
++enum {
++      EVENT_CMD_COMPLETE = 0,
++      EVENT_CMD_ERROR,
++      EVENT_DATA_COMPLETE,
++      EVENT_DATA_ERROR,
++      EVENT_STOP_SENT,
++      EVENT_STOP_COMPLETE,
++      EVENT_STOP_ERROR,
++      EVENT_DMA_ERROR,
++      EVENT_CARD_DETECT,
++};
++
++struct atmel_mci_dma {
++      struct dma_request_sg   req;
++      unsigned short          rx_periph_id;
++      unsigned short          tx_periph_id;
++};
++
++struct atmel_mci {
++      struct mmc_host         *mmc;
++      void __iomem            *regs;
++      struct atmel_mci_dma    dma;
++
++      struct mmc_request      *mrq;
++      struct mmc_command      *cmd;
++      struct mmc_data         *data;
++
++      u32                     stop_cmdr;
++      u32                     stop_iflags;
++
++      struct tasklet_struct   tasklet;
++      unsigned long           pending_events;
++      unsigned long           completed_events;
++      u32                     error_status;
++
++      int                     present;
++      int                     detect_pin;
++      int                     wp_pin;
++
++      unsigned long           bus_hz;
++      unsigned long           mapbase;
++      struct clk              *mck;
++      struct platform_device  *pdev;
++
++#ifdef CONFIG_DEBUG_FS
++      struct dentry           *debugfs_root;
++      struct dentry           *debugfs_regs;
++      struct dentry           *debugfs_req;
++      struct dentry           *debugfs_pending_events;
++      struct dentry           *debugfs_completed_events;
++#endif
++};
++
++/* Those printks take an awful lot of time... */
++#ifndef DEBUG
++static unsigned int fmax = 15000000U;
++#else
++static unsigned int fmax = 1000000U;
++#endif
++module_param(fmax, uint, 0444);
++MODULE_PARM_DESC(fmax, "Max frequency in Hz of the MMC bus clock");
++
++/* Test bit macros for completed events */
++#define mci_cmd_is_complete(host)                     \
++      test_bit(EVENT_CMD_COMPLETE, &host->completed_events)
++#define mci_cmd_error_is_complete(host)                       \
++      test_bit(EVENT_CMD_ERROR, &host->completed_events)
++#define mci_data_is_complete(host)                    \
++      test_bit(EVENT_DATA_COMPLETE, &host->completed_events)
++#define mci_data_error_is_complete(host)              \
++      test_bit(EVENT_DATA_ERROR, &host->completed_events)
++#define mci_stop_sent_is_complete(host)                       \
++      test_bit(EVENT_STOP_SENT, &host->completed_events)
++#define mci_stop_is_complete(host)                    \
++      test_bit(EVENT_STOP_COMPLETE, &host->completed_events)
++#define mci_stop_error_is_complete(host)              \
++      test_bit(EVENT_STOP_ERROR, &host->completed_events)
++#define mci_dma_error_is_complete(host)                       \
++      test_bit(EVENT_DMA_ERROR, &host->completed_events)
++#define mci_card_detect_is_complete(host)                     \
++      test_bit(EVENT_CARD_DETECT, &host->completed_events)
++
++/* Test and clear bit macros for pending events */
++#define mci_clear_cmd_is_pending(host)                        \
++      test_and_clear_bit(EVENT_CMD_COMPLETE, &host->pending_events)
++#define mci_clear_cmd_error_is_pending(host)          \
++      test_and_clear_bit(EVENT_CMD_ERROR, &host->pending_events)
++#define mci_clear_data_is_pending(host)                       \
++      test_and_clear_bit(EVENT_DATA_COMPLETE, &host->pending_events)
++#define mci_clear_data_error_is_pending(host)         \
++      test_and_clear_bit(EVENT_DATA_ERROR, &host->pending_events)
++#define mci_clear_stop_sent_is_pending(host)          \
++      test_and_clear_bit(EVENT_STOP_SENT, &host->pending_events)
++#define mci_clear_stop_is_pending(host)                       \
++      test_and_clear_bit(EVENT_STOP_COMPLETE, &host->pending_events)
++#define mci_clear_stop_error_is_pending(host)         \
++      test_and_clear_bit(EVENT_STOP_ERROR, &host->pending_events)
++#define mci_clear_dma_error_is_pending(host)          \
++      test_and_clear_bit(EVENT_DMA_ERROR, &host->pending_events)
++#define mci_clear_card_detect_is_pending(host)                \
++      test_and_clear_bit(EVENT_CARD_DETECT, &host->pending_events)
++
++/* Test and set bit macros for completed events */
++#define mci_set_cmd_is_completed(host)                        \
++      test_and_set_bit(EVENT_CMD_COMPLETE, &host->completed_events)
++#define mci_set_cmd_error_is_completed(host)          \
++      test_and_set_bit(EVENT_CMD_ERROR, &host->completed_events)
++#define mci_set_data_is_completed(host)                       \
++      test_and_set_bit(EVENT_DATA_COMPLETE, &host->completed_events)
++#define mci_set_data_error_is_completed(host)         \
++      test_and_set_bit(EVENT_DATA_ERROR, &host->completed_events)
++#define mci_set_stop_sent_is_completed(host)          \
++      test_and_set_bit(EVENT_STOP_SENT, &host->completed_events)
++#define mci_set_stop_is_completed(host)                       \
++      test_and_set_bit(EVENT_STOP_COMPLETE, &host->completed_events)
++#define mci_set_stop_error_is_completed(host)         \
++      test_and_set_bit(EVENT_STOP_ERROR, &host->completed_events)
++#define mci_set_dma_error_is_completed(host)          \
++      test_and_set_bit(EVENT_DMA_ERROR, &host->completed_events)
++#define mci_set_card_detect_is_completed(host)                \
++      test_and_set_bit(EVENT_CARD_DETECT, &host->completed_events)
++
++/* Set bit macros for completed events */
++#define mci_set_cmd_complete(host)                    \
++      set_bit(EVENT_CMD_COMPLETE, &host->completed_events)
++#define mci_set_cmd_error_complete(host)              \
++      set_bit(EVENT_CMD_ERROR, &host->completed_events)
++#define mci_set_data_complete(host)                   \
++      set_bit(EVENT_DATA_COMPLETE, &host->completed_events)
++#define mci_set_data_error_complete(host)             \
++      set_bit(EVENT_DATA_ERROR, &host->completed_events)
++#define mci_set_stop_sent_complete(host)              \
++      set_bit(EVENT_STOP_SENT, &host->completed_events)
++#define mci_set_stop_complete(host)                   \
++      set_bit(EVENT_STOP_COMPLETE, &host->completed_events)
++#define mci_set_stop_error_complete(host)             \
++      set_bit(EVENT_STOP_ERROR, &host->completed_events)
++#define mci_set_dma_error_complete(host)              \
++      set_bit(EVENT_DMA_ERROR, &host->completed_events)
++#define mci_set_card_detect_complete(host)            \
++      set_bit(EVENT_CARD_DETECT, &host->completed_events)
++
++/* Set bit macros for pending events */
++#define mci_set_cmd_pending(host)                     \
++      set_bit(EVENT_CMD_COMPLETE, &host->pending_events)
++#define mci_set_cmd_error_pending(host)                       \
++      set_bit(EVENT_CMD_ERROR, &host->pending_events)
++#define mci_set_data_pending(host)                    \
++      set_bit(EVENT_DATA_COMPLETE, &host->pending_events)
++#define mci_set_data_error_pending(host)              \
++      set_bit(EVENT_DATA_ERROR, &host->pending_events)
++#define mci_set_stop_sent_pending(host)                       \
++      set_bit(EVENT_STOP_SENT, &host->pending_events)
++#define mci_set_stop_pending(host)                    \
++      set_bit(EVENT_STOP_COMPLETE, &host->pending_events)
++#define mci_set_stop_error_pending(host)              \
++      set_bit(EVENT_STOP_ERROR, &host->pending_events)
++#define mci_set_dma_error_pending(host)                       \
++      set_bit(EVENT_DMA_ERROR, &host->pending_events)
++#define mci_set_card_detect_pending(host)             \
++      set_bit(EVENT_CARD_DETECT, &host->pending_events)
++
++/* Clear bit macros for pending events */
++#define mci_clear_cmd_pending(host)                   \
++      clear_bit(EVENT_CMD_COMPLETE, &host->pending_events)
++#define mci_clear_cmd_error_pending(host)             \
++      clear_bit(EVENT_CMD_ERROR, &host->pending_events)
++#define mci_clear_data_pending(host)                  \
++      clear_bit(EVENT_DATA_COMPLETE, &host->pending_events)
++#define mci_clear_data_error_pending(host)            \
++      clear_bit(EVENT_DATA_ERROR, &host->pending_events)
++#define mci_clear_stop_sent_pending(host)             \
++      clear_bit(EVENT_STOP_SENT, &host->pending_events)
++#define mci_clear_stop_pending(host)                  \
++      clear_bit(EVENT_STOP_COMPLETE, &host->pending_events)
++#define mci_clear_stop_error_pending(host)            \
++      clear_bit(EVENT_STOP_ERROR, &host->pending_events)
++#define mci_clear_dma_error_pending(host)             \
++      clear_bit(EVENT_DMA_ERROR, &host->pending_events)
++#define mci_clear_card_detect_pending(host)           \
++      clear_bit(EVENT_CARD_DETECT, &host->pending_events)
++
++
++#ifdef CONFIG_DEBUG_FS
++#include <linux/debugfs.h>
++
++#define DBG_REQ_BUF_SIZE      (4096 - sizeof(unsigned int))
++
++struct req_dbg_data {
++      unsigned int nbytes;
++      char str[DBG_REQ_BUF_SIZE];
++};
++
++static int req_dbg_open(struct inode *inode, struct file *file)
++{
++      struct atmel_mci *host;
++      struct mmc_request *mrq;
++      struct mmc_command *cmd, *stop;
++      struct mmc_data *data;
++      struct req_dbg_data *priv;
++      char *str;
++      unsigned long n = 0;
++
++      priv = kzalloc(DBG_REQ_BUF_SIZE, GFP_KERNEL);
++      if (!priv)
++              return -ENOMEM;
++      str = priv->str;
++
++      mutex_lock(&inode->i_mutex);
++      host = inode->i_private;
++
++      spin_lock_irq(&host->mmc->lock);
++      mrq = host->mrq;
++      if (mrq) {
++              cmd = mrq->cmd;
++              data = mrq->data;
++              stop = mrq->stop;
++              n = snprintf(str, DBG_REQ_BUF_SIZE,
++                           "CMD%u(0x%x) %x %x %x %x %x (err %u)\n",
++                           cmd->opcode, cmd->arg, cmd->flags,
++                           cmd->resp[0], cmd->resp[1], cmd->resp[2],
++                           cmd->resp[3], cmd->error);
++              if (n < DBG_REQ_BUF_SIZE && data)
++                      n += snprintf(str + n, DBG_REQ_BUF_SIZE - n,
++                                    "DATA %u * %u (%u) %x (err %u)\n",
++                                    data->blocks, data->blksz,
++                                    data->bytes_xfered, data->flags,
++                                    data->error);
++              if (n < DBG_REQ_BUF_SIZE && stop)
++                      n += snprintf(str + n, DBG_REQ_BUF_SIZE - n,
++                                    "CMD%u(0x%x) %x %x %x %x %x (err %u)\n",
++                                    stop->opcode, stop->arg, stop->flags,
++                                    stop->resp[0], stop->resp[1],
++                                    stop->resp[2], stop->resp[3],
++                                    stop->error);
++      }
++      spin_unlock_irq(&host->mmc->lock);
++      mutex_unlock(&inode->i_mutex);
++
++      priv->nbytes = min(n, DBG_REQ_BUF_SIZE);
++      file->private_data = priv;
++
++      return 0;
++}
++
++static ssize_t req_dbg_read(struct file *file, char __user *buf,
++                          size_t nbytes, loff_t *ppos)
++{
++      struct req_dbg_data *priv = file->private_data;
++
++      return simple_read_from_buffer(buf, nbytes, ppos,
++                                     priv->str, priv->nbytes);
++}
++
++static int req_dbg_release(struct inode *inode, struct file *file)
++{
++      kfree(file->private_data);
++      return 0;
++}
++
++static const struct file_operations req_dbg_fops = {
++      .owner          = THIS_MODULE,
++      .open           = req_dbg_open,
++      .llseek         = no_llseek,
++      .read           = req_dbg_read,
++      .release        = req_dbg_release,
++};
++
++static int regs_dbg_open(struct inode *inode, struct file *file)
++{
++      struct atmel_mci *host;
++      unsigned int i;
++      u32 *data;
++      int ret = -ENOMEM;
++
++      mutex_lock(&inode->i_mutex);
++      host = inode->i_private;
++      data = kmalloc(inode->i_size, GFP_KERNEL);
++      if (!data)
++              goto out;
++
++      spin_lock_irq(&host->mmc->lock);
++      for (i = 0; i < inode->i_size / 4; i++)
++              data[i] = __raw_readl(host->regs + i * 4);
++      spin_unlock_irq(&host->mmc->lock);
++
++      file->private_data = data;
++      ret = 0;
++
++out:
++      mutex_unlock(&inode->i_mutex);
++
++      return ret;
++}
++
++static ssize_t regs_dbg_read(struct file *file, char __user *buf,
++                           size_t nbytes, loff_t *ppos)
++{
++      struct inode *inode = file->f_dentry->d_inode;
++      int ret;
++
++      mutex_lock(&inode->i_mutex);
++      ret = simple_read_from_buffer(buf, nbytes, ppos,
++                                    file->private_data,
++                                    file->f_dentry->d_inode->i_size);
++      mutex_unlock(&inode->i_mutex);
++
++      return ret;
++}
++
++static int regs_dbg_release(struct inode *inode, struct file *file)
++{
++      kfree(file->private_data);
++      return 0;
++}
++
++static const struct file_operations regs_dbg_fops = {
++      .owner          = THIS_MODULE,
++      .open           = regs_dbg_open,
++      .llseek         = generic_file_llseek,
++      .read           = regs_dbg_read,
++      .release        = regs_dbg_release,
++};
++
++static void atmci_init_debugfs(struct atmel_mci *host)
++{
++      struct mmc_host *mmc;
++      struct dentry *root, *regs;
++      struct resource *res;
++
++      mmc = host->mmc;
++      root = debugfs_create_dir(mmc_hostname(mmc), NULL);
++      if (IS_ERR(root) || !root)
++              goto err_root;
++      host->debugfs_root = root;
++
++      regs = debugfs_create_file("regs", 0400, root, host, &regs_dbg_fops);
++      if (!regs)
++              goto err_regs;
++
++      res = platform_get_resource(host->pdev, IORESOURCE_MEM, 0);
++      regs->d_inode->i_size = res->end - res->start + 1;
++      host->debugfs_regs = regs;
++
++      host->debugfs_req = debugfs_create_file("req", 0400, root,
++                                              host, &req_dbg_fops);
++      if (!host->debugfs_req)
++              goto err_req;
++
++      host->debugfs_pending_events
++              = debugfs_create_u32("pending_events", 0400, root,
++                                   (u32 *)&host->pending_events);
++      if (!host->debugfs_pending_events)
++              goto err_pending_events;
++
++      host->debugfs_completed_events
++              = debugfs_create_u32("completed_events", 0400, root,
++                                   (u32 *)&host->completed_events);
++      if (!host->debugfs_completed_events)
++              goto err_completed_events;
++
++      return;
++
++err_completed_events:
++      debugfs_remove(host->debugfs_pending_events);
++err_pending_events:
++      debugfs_remove(host->debugfs_req);
++err_req:
++      debugfs_remove(host->debugfs_regs);
++err_regs:
++      debugfs_remove(host->debugfs_root);
++err_root:
++      host->debugfs_root = NULL;
++      dev_err(&host->pdev->dev,
++              "failed to initialize debugfs for %s\n",
++              mmc_hostname(mmc));
++}
++
++static void atmci_cleanup_debugfs(struct atmel_mci *host)
++{
++      if (host->debugfs_root) {
++              debugfs_remove(host->debugfs_completed_events);
++              debugfs_remove(host->debugfs_pending_events);
++              debugfs_remove(host->debugfs_req);
++              debugfs_remove(host->debugfs_regs);
++              debugfs_remove(host->debugfs_root);
++              host->debugfs_root = NULL;
++      }
++}
++#else
++static inline void atmci_init_debugfs(struct atmel_mci *host)
++{
++
++}
++
++static inline void atmci_cleanup_debugfs(struct atmel_mci *host)
++{
++
++}
++#endif /* CONFIG_DEBUG_FS */
++
++static inline unsigned int ns_to_clocks(struct atmel_mci *host,
++                                      unsigned int ns)
++{
++      return (ns * (host->bus_hz / 1000000) + 999) / 1000;
++}
++
++static void atmci_set_timeout(struct atmel_mci *host,
++                            struct mmc_data *data)
++{
++      static unsigned dtomul_to_shift[] = {
++              0, 4, 7, 8, 10, 12, 16, 20
++      };
++      unsigned timeout;
++      unsigned dtocyc, dtomul;
++
++      timeout = ns_to_clocks(host, data->timeout_ns) + data->timeout_clks;
++
++      for (dtomul = 0; dtomul < 8; dtomul++) {
++              unsigned shift = dtomul_to_shift[dtomul];
++              dtocyc = (timeout + (1 << shift) - 1) >> shift;
++              if (dtocyc < 15)
++                      break;
++      }
++
++      if (dtomul >= 8) {
++              dtomul = 7;
++              dtocyc = 15;
++      }
++
++      pr_debug("%s: setting timeout to %u cycles\n",
++               mmc_hostname(host->mmc),
++               dtocyc << dtomul_to_shift[dtomul]);
++      mci_writel(host, DTOR, (MCI_BF(DTOMUL, dtomul)
++                              | MCI_BF(DTOCYC, dtocyc)));
++}
++
++/*
++ * Return mask with interrupt flags to be handled for this command.
++ */
++static u32 atmci_prepare_command(struct mmc_host *mmc,
++                               struct mmc_command *cmd,
++                               u32 *cmd_flags)
++{
++      u32 cmdr;
++      u32 iflags;
++
++      cmd->error = MMC_ERR_NONE;
++
++      cmdr = 0;
++      BUG_ON(MCI_BFEXT(CMDNB, cmdr) != 0);
++      cmdr = MCI_BFINS(CMDNB, cmd->opcode, cmdr);
++
++      if (cmd->flags & MMC_RSP_PRESENT) {
++              if (cmd->flags & MMC_RSP_136)
++                      cmdr |= MCI_BF(RSPTYP, MCI_RSPTYP_136_BIT);
++              else
++                      cmdr |= MCI_BF(RSPTYP, MCI_RSPTYP_48_BIT);
++      }
++
++      /*
++       * This should really be MAXLAT_5 for CMD2 and ACMD41, but
++       * it's too difficult to determine whether this is an ACMD or
++       * not. Better make it 64.
++       */
++      cmdr |= MCI_BIT(MAXLAT);
++
++      if (mmc->ios.bus_mode == MMC_BUSMODE_OPENDRAIN)
++              cmdr |= MCI_BIT(OPDCMD);
++
++      iflags = MCI_BIT(CMDRDY) | MCI_CMD_ERROR_FLAGS;
++      if (!(cmd->flags & MMC_RSP_CRC))
++              iflags &= ~MCI_BIT(RCRCE);
++
++      pr_debug("%s: cmd: op %02x arg %08x flags %08x, cmdflags %08lx\n",
++               mmc_hostname(mmc), cmd->opcode, cmd->arg, cmd->flags,
++               (unsigned long)cmdr);
++
++      *cmd_flags = cmdr;
++      return iflags;
++}
++
++static void atmci_start_command(struct atmel_mci *host,
++                              struct mmc_command *cmd,
++                              u32 cmd_flags)
++{
++      WARN_ON(host->cmd);
++      host->cmd = cmd;
++
++      mci_writel(host, ARGR, cmd->arg);
++      mci_writel(host, CMDR, cmd_flags);
++
++      if (cmd->data)
++              dma_start_request(host->dma.req.req.dmac,
++                                host->dma.req.req.channel);
++}
++
++/*
++ * Returns a mask of flags to be set in the command register when the
++ * command to start the transfer is to be sent.
++ */
++static u32 atmci_prepare_data(struct mmc_host *mmc, struct mmc_data *data)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++      u32 cmd_flags;
++
++      WARN_ON(host->data);
++      host->data = data;
++
++      atmci_set_timeout(host, data);
++      mci_writel(host, BLKR, (MCI_BF(BCNT, data->blocks)
++                              | MCI_BF(BLKLEN, data->blksz)));
++      host->dma.req.block_size = data->blksz;
++      host->dma.req.nr_blocks = data->blocks;
++
++      cmd_flags = MCI_BF(TRCMD, MCI_TRCMD_START_TRANS);
++      if (data->flags & MMC_DATA_STREAM)
++              cmd_flags |= MCI_BF(TRTYP, MCI_TRTYP_STREAM);
++      else if (data->blocks > 1)
++              cmd_flags |= MCI_BF(TRTYP, MCI_TRTYP_MULTI_BLOCK);
++      else
++              cmd_flags |= MCI_BF(TRTYP, MCI_TRTYP_BLOCK);
++
++      if (data->flags & MMC_DATA_READ) {
++              cmd_flags |= MCI_BIT(TRDIR);
++              host->dma.req.nr_sg
++                      = dma_map_sg(&host->pdev->dev, data->sg,
++                                   data->sg_len, DMA_FROM_DEVICE);
++              host->dma.req.periph_id = host->dma.rx_periph_id;
++              host->dma.req.direction = DMA_DIR_PERIPH_TO_MEM;
++              host->dma.req.data_reg = host->mapbase + MCI_RDR;
++      } else {
++              host->dma.req.nr_sg
++                      = dma_map_sg(&host->pdev->dev, data->sg,
++                                   data->sg_len, DMA_TO_DEVICE);
++              host->dma.req.periph_id = host->dma.tx_periph_id;
++              host->dma.req.direction = DMA_DIR_MEM_TO_PERIPH;
++              host->dma.req.data_reg = host->mapbase + MCI_TDR;
++      }
++      host->dma.req.sg = data->sg;
++
++      dma_prepare_request_sg(host->dma.req.req.dmac, &host->dma.req);
++
++      return cmd_flags;
++}
++
++static void atmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++      struct mmc_data *data = mrq->data;
++      u32 iflags;
++      u32 cmdflags = 0;
++
++      iflags = mci_readl(host, IMR);
++      if (iflags)
++              printk("WARNING: IMR=0x%08x\n", mci_readl(host, IMR));
++
++      WARN_ON(host->mrq != NULL);
++      host->mrq = mrq;
++      host->pending_events = 0;
++      host->completed_events = 0;
++
++      iflags = atmci_prepare_command(mmc, mrq->cmd, &cmdflags);
++
++      if (mrq->stop) {
++              BUG_ON(!data);
++
++              host->stop_iflags = atmci_prepare_command(mmc, mrq->stop,
++                                                        &host->stop_cmdr);
++              host->stop_cmdr |= MCI_BF(TRCMD, MCI_TRCMD_STOP_TRANS);
++              if (!(data->flags & MMC_DATA_WRITE))
++                      host->stop_cmdr |= MCI_BIT(TRDIR);
++              if (data->flags & MMC_DATA_STREAM)
++                      host->stop_cmdr |= MCI_BF(TRTYP, MCI_TRTYP_STREAM);
++              else
++                      host->stop_cmdr |= MCI_BF(TRTYP, MCI_TRTYP_MULTI_BLOCK);
++      }
++      if (data) {
++              cmdflags |= atmci_prepare_data(mmc, data);
++              iflags |= MCI_DATA_ERROR_FLAGS;
++      }
++
++      atmci_start_command(host, mrq->cmd, cmdflags);
++      mci_writel(host, IER, iflags);
++}
++
++static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++
++      if (ios->clock) {
++              u32 clkdiv;
++
++              clkdiv = host->bus_hz / (2 * ios->clock) - 1;
++              if (clkdiv > 255)
++                      clkdiv = 255;
++              mci_writel(host, MR, (clkdiv
++                                    | MCI_BIT(WRPROOF)
++                                    | MCI_BIT(RDPROOF)));
++      }
++
++      switch (ios->bus_width) {
++      case MMC_BUS_WIDTH_1:
++              mci_writel(host, SDCR, 0);
++              break;
++      case MMC_BUS_WIDTH_4:
++              mci_writel(host, SDCR, MCI_BIT(SDCBUS));
++              break;
++      }
++
++      switch (ios->power_mode) {
++      case MMC_POWER_OFF:
++              mci_writel(host, CR, MCI_BIT(MCIDIS));
++              break;
++      case MMC_POWER_UP:
++              mci_writel(host, CR, MCI_BIT(SWRST));
++              break;
++      case MMC_POWER_ON:
++              mci_writel(host, CR, MCI_BIT(MCIEN));
++              break;
++      }
++}
++
++static int atmci_get_ro(struct mmc_host *mmc)
++{
++      int read_only = 0;
++      struct atmel_mci *host = mmc_priv(mmc);
++
++      if (host->wp_pin >= 0) {
++              read_only = gpio_get_value(host->wp_pin);
++              pr_debug("%s: card is %s\n", mmc_hostname(mmc),
++                       read_only ? "read-only" : "read-write");
++      } else {
++              pr_debug("%s: no pin for checking read-only switch."
++                       " Assuming write-enable.\n", mmc_hostname(mmc));
++      }
++
++      return read_only;
++}
++
++static struct mmc_host_ops atmci_ops = {
++      .request        = atmci_request,
++      .set_ios        = atmci_set_ios,
++      .get_ro         = atmci_get_ro,
++};
++
++static void atmci_request_end(struct mmc_host *mmc, struct mmc_request *mrq)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++
++      WARN_ON(host->cmd || host->data);
++      host->mrq = NULL;
++
++      mmc_request_done(mmc, mrq);
++}
++
++static void send_stop_cmd(struct mmc_host *mmc, struct mmc_data *data,
++                        u32 flags)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++
++      atmci_start_command(host, data->stop, host->stop_cmdr | flags);
++      mci_writel(host, IER, host->stop_iflags);
++}
++
++static void atmci_data_complete(struct atmel_mci *host, struct mmc_data *data)
++{
++      host->data = NULL;
++      dma_unmap_sg(&host->pdev->dev, data->sg, host->dma.req.nr_sg,
++                   ((data->flags & MMC_DATA_WRITE)
++                    ? DMA_TO_DEVICE : DMA_FROM_DEVICE));
++
++      /*
++       * Data might complete before command for very short transfers
++       * (like READ_SCR)
++       */
++      if (mci_cmd_is_complete(host)
++          && (!data->stop || mci_stop_is_complete(host)))
++              atmci_request_end(host->mmc, data->mrq);
++}
++
++static void atmci_command_error(struct mmc_host *mmc,
++                              struct mmc_command *cmd,
++                              u32 status)
++{
++      pr_debug("%s: command error: status=0x%08x\n",
++               mmc_hostname(mmc), status);
++
++      if (status & MCI_BIT(RTOE))
++              cmd->error = MMC_ERR_TIMEOUT;
++      else if (status & MCI_BIT(RCRCE))
++              cmd->error = MMC_ERR_BADCRC;
++      else
++              cmd->error = MMC_ERR_FAILED;
++}
++
++static void atmci_tasklet_func(unsigned long priv)
++{
++      struct mmc_host *mmc = (struct mmc_host *)priv;
++      struct atmel_mci *host = mmc_priv(mmc);
++      struct mmc_request *mrq = host->mrq;
++      struct mmc_data *data = host->data;
++
++      pr_debug("atmci_tasklet: pending/completed/mask %lx/%lx/%x\n",
++               host->pending_events, host->completed_events,
++               mci_readl(host, IMR));
++
++      if (mci_clear_cmd_error_is_pending(host)) {
++              struct mmc_command *cmd;
++
++              mci_set_cmd_error_complete(host);
++              mci_clear_cmd_pending(host);
++              cmd = host->mrq->cmd;
++
++              if (cmd->data) {
++                      dma_stop_request(host->dma.req.req.dmac,
++                                       host->dma.req.req.channel);
++                      host->data = NULL;
++              }
++
++              atmci_command_error(mmc, cmd, host->error_status);
++              atmci_request_end(mmc, cmd->mrq);
++      }
++      if (mci_clear_stop_error_is_pending(host)) {
++              mci_set_stop_error_complete(host);
++              mci_clear_stop_pending(host);
++              atmci_command_error(mmc, host->mrq->stop,
++                                  host->error_status);
++              if (!host->data)
++                      atmci_request_end(mmc, host->mrq);
++      }
++      if (mci_clear_cmd_is_pending(host)) {
++              mci_set_cmd_complete(host);
++              if (!mrq->data || mci_data_is_complete(host)
++                  || mci_data_error_is_complete(host))
++                      atmci_request_end(mmc, mrq);
++      }
++      if (mci_clear_stop_is_pending(host)) {
++              mci_set_stop_complete(host);
++              if (mci_data_is_complete(host)
++                  || mci_data_error_is_complete(host))
++                      atmci_request_end(mmc, mrq);
++      }
++      if (mci_clear_dma_error_is_pending(host)) {
++              mci_set_dma_error_complete(host);
++              mci_clear_data_pending(host);
++
++              /* DMA controller got bus error => invalid address */
++              data->error = MMC_ERR_INVALID;
++
++              printk(KERN_DEBUG "%s: dma error after %u bytes xfered\n",
++                     mmc_hostname(mmc), host->data->bytes_xfered);
++
++              if (data->stop
++                  && !mci_set_stop_sent_is_completed(host))
++                      /* TODO: Check if card is still present */
++                      send_stop_cmd(host->mmc, data, 0);
++
++              atmci_data_complete(host, data);
++      }
++      if (mci_clear_data_error_is_pending(host)) {
++              u32 status = host->error_status;
++
++              mci_set_data_error_complete(host);
++              mci_clear_data_pending(host);
++
++              dma_stop_request(host->dma.req.req.dmac,
++                               host->dma.req.req.channel);
++
++              printk(KERN_DEBUG "%s: data error: status=0x%08x\n",
++                     mmc_hostname(host->mmc), status);
++
++              if (status & MCI_BIT(DCRCE)) {
++                      printk(KERN_DEBUG "%s: Data CRC error\n",
++                             mmc_hostname(host->mmc));
++                      data->error = MMC_ERR_BADCRC;
++              } else if (status & MCI_BIT(DTOE)) {
++                      printk(KERN_DEBUG "%s: Data Timeout error\n",
++                             mmc_hostname(host->mmc));
++                      data->error = MMC_ERR_TIMEOUT;
++              } else {
++                      printk(KERN_DEBUG "%s: Data FIFO error\n",
++                             mmc_hostname(host->mmc));
++                      data->error = MMC_ERR_FIFO;
++              }
++              printk(KERN_DEBUG "%s: Bytes xfered: %u\n",
++                     mmc_hostname(host->mmc), data->bytes_xfered);
++
++              if (data->stop
++                  && !mci_set_stop_sent_is_completed(host))
++                      /* TODO: Check if card is still present */
++                      send_stop_cmd(host->mmc, data, 0);
++
++              atmci_data_complete(host, data);
++      }
++      if (mci_clear_data_is_pending(host)) {
++              mci_set_data_complete(host);
++              data->bytes_xfered = data->blocks * data->blksz;
++              atmci_data_complete(host, data);
++      }
++      if (mci_clear_card_detect_is_pending(host)) {
++              /* Reset controller if card is gone */
++              if (!host->present) {
++                      mci_writel(host, CR, MCI_BIT(SWRST));
++                      mci_writel(host, IDR, ~0UL);
++                      mci_writel(host, CR, MCI_BIT(MCIEN));
++              }
++
++              /* Clean up queue if present */
++              if (mrq) {
++                      if (!mci_cmd_is_complete(host)
++                          && !mci_cmd_error_is_complete(host)) {
++                              mrq->cmd->error = MMC_ERR_TIMEOUT;
++                      }
++                      if (mrq->data && !mci_data_is_complete(host)
++                          && !mci_data_error_is_complete(host)) {
++                              dma_stop_request(host->dma.req.req.dmac,
++                                              host->dma.req.req.channel);
++                              host->data->error = MMC_ERR_TIMEOUT;
++                              atmci_data_complete(host, data);
++                      }
++                      if (mrq->stop && !mci_stop_is_complete(host)
++                          && !mci_stop_error_is_complete(host)) {
++                              mrq->stop->error = MMC_ERR_TIMEOUT;
++                      }
++
++                      host->cmd = NULL;
++                      atmci_request_end(mmc, mrq);
++              }
++              mmc_detect_change(host->mmc, msecs_to_jiffies(100));
++      }
++}
++
++static void atmci_cmd_interrupt(struct mmc_host *mmc, u32 status)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++      struct mmc_command *cmd = host->cmd;
++
++      /*
++       * Read the response now so that we're free to send a new
++       * command immediately.
++       */
++      cmd->resp[0] = mci_readl(host, RSPR);
++      cmd->resp[1] = mci_readl(host, RSPR);
++      cmd->resp[2] = mci_readl(host, RSPR);
++      cmd->resp[3] = mci_readl(host, RSPR);
++
++      mci_writel(host, IDR, MCI_BIT(CMDRDY) | MCI_CMD_ERROR_FLAGS);
++      host->cmd = NULL;
++
++      if (mci_stop_sent_is_complete(host))
++              mci_set_stop_pending(host);
++      else
++              mci_set_cmd_pending(host);
++
++      tasklet_schedule(&host->tasklet);
++}
++
++static void atmci_xfer_complete(struct dma_request *_req)
++{
++      struct dma_request_sg *req = to_dma_request_sg(_req);
++      struct atmel_mci_dma *dma;
++      struct atmel_mci *host;
++      struct mmc_data *data;
++
++      dma = container_of(req, struct atmel_mci_dma, req);
++      host = container_of(dma, struct atmel_mci, dma);
++      data = host->data;
++
++      if (data->stop && !mci_set_stop_sent_is_completed(host))
++              send_stop_cmd(host->mmc, data, 0);
++
++      if (data->flags & MMC_DATA_READ) {
++              mci_writel(host, IDR, MCI_DATA_ERROR_FLAGS);
++              mci_set_data_pending(host);
++              tasklet_schedule(&host->tasklet);
++      } else {
++              /*
++               * For the WRITE case, wait for NOTBUSY. This function
++               * is called when everything has been written to the
++               * controller, not when the card is done programming.
++               */
++              mci_writel(host, IER, MCI_BIT(NOTBUSY));
++      }
++}
++
++static void atmci_dma_error(struct dma_request *_req)
++{
++      struct dma_request_sg *req = to_dma_request_sg(_req);
++      struct atmel_mci_dma *dma;
++      struct atmel_mci *host;
++
++      dma = container_of(req, struct atmel_mci_dma, req);
++      host = container_of(dma, struct atmel_mci, dma);
++
++      mci_writel(host, IDR, (MCI_BIT(NOTBUSY)
++                             | MCI_DATA_ERROR_FLAGS));
++
++      mci_set_dma_error_pending(host);
++      tasklet_schedule(&host->tasklet);
++}
++
++static irqreturn_t atmci_interrupt(int irq, void *dev_id)
++{
++      struct mmc_host *mmc = dev_id;
++      struct atmel_mci *host = mmc_priv(mmc);
++      u32 status, mask, pending;
++
++      spin_lock(&mmc->lock);
++
++      status = mci_readl(host, SR);
++      mask = mci_readl(host, IMR);
++      pending = status & mask;
++
++      do {
++              if (pending & MCI_CMD_ERROR_FLAGS) {
++                      mci_writel(host, IDR, (MCI_BIT(CMDRDY)
++                                             | MCI_BIT(NOTBUSY)
++                                             | MCI_CMD_ERROR_FLAGS
++                                             | MCI_DATA_ERROR_FLAGS));
++                      host->error_status = status;
++                      host->cmd = NULL;
++                      if (mci_stop_sent_is_complete(host))
++                              mci_set_stop_error_pending(host);
++                      else
++                              mci_set_cmd_error_pending(host);
++                      tasklet_schedule(&host->tasklet);
++                      break;
++              }
++              if (pending & MCI_DATA_ERROR_FLAGS) {
++                      mci_writel(host, IDR, (MCI_BIT(NOTBUSY)
++                                             | MCI_DATA_ERROR_FLAGS));
++                      host->error_status = status;
++                      mci_set_data_error_pending(host);
++                      tasklet_schedule(&host->tasklet);
++                      break;
++              }
++              if (pending & MCI_BIT(CMDRDY))
++                      atmci_cmd_interrupt(mmc, status);
++              if (pending & MCI_BIT(NOTBUSY)) {
++                      mci_writel(host, IDR, (MCI_BIT(NOTBUSY)
++                                             | MCI_DATA_ERROR_FLAGS));
++                      mci_set_data_pending(host);
++                      tasklet_schedule(&host->tasklet);
++              }
++
++              status = mci_readl(host, SR);
++              mask = mci_readl(host, IMR);
++              pending = status & mask;
++      } while (pending);
++
++      spin_unlock(&mmc->lock);
++
++      return IRQ_HANDLED;
++}
++
++static irqreturn_t atmci_detect_change(int irq, void *dev_id)
++{
++      struct mmc_host *mmc = dev_id;
++      struct atmel_mci *host = mmc_priv(mmc);
++
++      int present = !gpio_get_value(irq_to_gpio(irq));
++
++      if (present != host->present) {
++              pr_debug("%s: card %s\n", mmc_hostname(host->mmc),
++                       present ? "inserted" : "removed");
++              host->present = present;
++              mci_set_card_detect_pending(host);
++              tasklet_schedule(&host->tasklet);
++      }
++      return IRQ_HANDLED;
++}
++
++static int __devinit atmci_probe(struct platform_device *pdev)
++{
++      struct mci_platform_data *board;
++      struct atmel_mci *host;
++      struct mmc_host *mmc;
++      struct resource *regs;
++      int irq;
++      int ret;
++
++      regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++      if (!regs)
++              return -ENXIO;
++      irq = platform_get_irq(pdev, 0);
++      if (irq < 0)
++              return irq;
++
++      board = pdev->dev.platform_data;
++
++      mmc = mmc_alloc_host(sizeof(struct atmel_mci), &pdev->dev);
++      if (!mmc)
++              return -ENOMEM;
++
++      host = mmc_priv(mmc);
++      host->pdev = pdev;
++      host->mmc = mmc;
++      if (board) {
++              host->detect_pin = board->detect_pin;
++              host->wp_pin = board->wp_pin;
++      } else {
++              host->detect_pin = -1;
++              host->detect_pin = -1;
++      }
++
++      host->mck = clk_get(&pdev->dev, "mci_clk");
++      if (IS_ERR(host->mck)) {
++              ret = PTR_ERR(host->mck);
++              goto out_free_host;
++      }
++      clk_enable(host->mck);
++
++      ret = -ENOMEM;
++      host->regs = ioremap(regs->start, regs->end - regs->start + 1);
++      if (!host->regs)
++              goto out_disable_clk;
++
++      host->bus_hz = clk_get_rate(host->mck);
++      host->mapbase = regs->start;
++
++      mmc->ops = &atmci_ops;
++      mmc->f_min = (host->bus_hz + 511) / 512;
++      mmc->f_max = min((unsigned int)(host->bus_hz / 2), fmax);
++      mmc->ocr_avail  = 0x00100000;
++      mmc->caps |= MMC_CAP_4_BIT_DATA;
++
++      tasklet_init(&host->tasklet, atmci_tasklet_func, (unsigned long)mmc);
++
++      ret = request_irq(irq, atmci_interrupt, 0, "mmci", mmc);
++      if (ret)
++              goto out_unmap;
++
++      /* Assume card is present if we don't have a detect pin */
++      host->present = 1;
++      if (host->detect_pin >= 0) {
++              if (gpio_request(host->detect_pin, "mmc_detect")) {
++                      printk(KERN_WARNING "%s: no detect pin available\n",
++                             mmc_hostname(host->mmc));
++                      host->detect_pin = -1;
++              } else {
++                      host->present = !gpio_get_value(host->detect_pin);
++              }
++      }
++      if (host->wp_pin >= 0) {
++              if (gpio_request(host->wp_pin, "mmc_wp")) {
++                      printk(KERN_WARNING "%s: no WP pin available\n",
++                             mmc_hostname(host->mmc));
++                      host->wp_pin = -1;
++              }
++      }
++
++      /* TODO: Get this information from platform data */
++      ret = -ENOMEM;
++      host->dma.req.req.dmac = find_dma_controller(0);
++      if (!host->dma.req.req.dmac) {
++              printk(KERN_ERR
++                     "mmci: No DMA controller available, aborting\n");
++              goto out_free_irq;
++      }
++      ret = dma_alloc_channel(host->dma.req.req.dmac);
++      if (ret < 0) {
++              printk(KERN_ERR
++                     "mmci: Unable to allocate DMA channel, aborting\n");
++              goto out_free_irq;
++      }
++      host->dma.req.req.channel = ret;
++      host->dma.req.width = DMA_WIDTH_32BIT;
++      host->dma.req.req.xfer_complete = atmci_xfer_complete;
++      host->dma.req.req.block_complete = NULL; // atmci_block_complete;
++      host->dma.req.req.error = atmci_dma_error;
++      host->dma.rx_periph_id = 0;
++      host->dma.tx_periph_id = 1;
++
++      mci_writel(host, CR, MCI_BIT(SWRST));
++      mci_writel(host, IDR, ~0UL);
++      mci_writel(host, CR, MCI_BIT(MCIEN));
++
++      platform_set_drvdata(pdev, host);
++
++      mmc_add_host(mmc);
++
++      if (host->detect_pin >= 0) {
++              ret = request_irq(gpio_to_irq(host->detect_pin),
++                                atmci_detect_change,
++                                IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
++                                DRIVER_NAME, mmc);
++              if (ret) {
++                      printk(KERN_ERR
++                             "%s: could not request IRQ %d for detect pin\n",
++                             mmc_hostname(mmc),
++                             gpio_to_irq(host->detect_pin));
++                      gpio_free(host->detect_pin);
++                      host->detect_pin = -1;
++              }
++      }
++
++      printk(KERN_INFO "%s: Atmel MCI controller at 0x%08lx irq %d\n",
++             mmc_hostname(mmc), host->mapbase, irq);
++
++      atmci_init_debugfs(host);
++
++      return 0;
++
++out_free_irq:
++      if (host->detect_pin >= 0)
++              gpio_free(host->detect_pin);
++      if (host->wp_pin >= 0)
++              gpio_free(host->wp_pin);
++      free_irq(irq, mmc);
++out_unmap:
++      iounmap(host->regs);
++out_disable_clk:
++      clk_disable(host->mck);
++      clk_put(host->mck);
++out_free_host:
++      mmc_free_host(mmc);
++      return ret;
++}
++
++static int __devexit atmci_remove(struct platform_device *pdev)
++{
++      struct atmel_mci *host = platform_get_drvdata(pdev);
++
++      platform_set_drvdata(pdev, NULL);
++
++      if (host) {
++              atmci_cleanup_debugfs(host);
++
++              if (host->detect_pin >= 0) {
++                      free_irq(gpio_to_irq(host->detect_pin), host->mmc);
++                      cancel_delayed_work(&host->mmc->detect);
++                      gpio_free(host->detect_pin);
++              }
++
++              mmc_remove_host(host->mmc);
++
++              mci_writel(host, IDR, ~0UL);
++              mci_writel(host, CR, MCI_BIT(MCIDIS));
++              mci_readl(host, SR);
++
++              dma_release_channel(host->dma.req.req.dmac,
++                                  host->dma.req.req.channel);
++
++              if (host->wp_pin >= 0)
++                      gpio_free(host->wp_pin);
++
++              free_irq(platform_get_irq(pdev, 0), host->mmc);
++              iounmap(host->regs);
++
++              clk_disable(host->mck);
++              clk_put(host->mck);
++
++              mmc_free_host(host->mmc);
++      }
++      return 0;
++}
++
++static struct platform_driver atmci_driver = {
++      .probe          = atmci_probe,
++      .remove         = __devexit_p(atmci_remove),
++      .driver         = {
++              .name           = DRIVER_NAME,
++      },
++};
++
++static int __init atmci_init(void)
++{
++      return platform_driver_register(&atmci_driver);
++}
++
++static void __exit atmci_exit(void)
++{
++      platform_driver_unregister(&atmci_driver);
++}
++
++module_init(atmci_init);
++module_exit(atmci_exit);
++
++MODULE_DESCRIPTION("Atmel Multimedia Card Interface driver");
++MODULE_LICENSE("GPL");
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/mmc/atmel-mci.h avr32-git/drivers/mmc/atmel-mci.h
+--- linux-2.6.21.3/drivers/mmc/atmel-mci.h     1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/drivers/mmc/atmel-mci.h  2007-06-06 11:33:56.000000000 +0200
+@@ -0,0 +1,192 @@
++/*
++ * Atmel MultiMedia Card Interface driver
++ *
++ * Copyright (C) 2004-2006 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#ifndef __DRIVERS_MMC_ATMEL_MCI_H__
++#define __DRIVERS_MMC_ATMEL_MCI_H__
++
++/* MCI register offsets */
++#define MCI_CR                                        0x0000
++#define MCI_MR                                        0x0004
++#define MCI_DTOR                              0x0008
++#define MCI_SDCR                              0x000c
++#define MCI_ARGR                              0x0010
++#define MCI_CMDR                              0x0014
++#define MCI_BLKR                              0x0018
++#define MCI_RSPR                              0x0020
++#define MCI_RSPR1                             0x0024
++#define MCI_RSPR2                             0x0028
++#define MCI_RSPR3                             0x002c
++#define MCI_RDR                                       0x0030
++#define MCI_TDR                                       0x0034
++#define MCI_SR                                        0x0040
++#define MCI_IER                                       0x0044
++#define MCI_IDR                                       0x0048
++#define MCI_IMR                                       0x004c
++
++/* Bitfields in CR */
++#define MCI_MCIEN_OFFSET                      0
++#define MCI_MCIEN_SIZE                                1
++#define MCI_MCIDIS_OFFSET                     1
++#define MCI_MCIDIS_SIZE                               1
++#define MCI_PWSEN_OFFSET                      2
++#define MCI_PWSEN_SIZE                                1
++#define MCI_PWSDIS_OFFSET                     3
++#define MCI_PWSDIS_SIZE                               1
++#define MCI_SWRST_OFFSET                      7
++#define MCI_SWRST_SIZE                                1
++
++/* Bitfields in MR */
++#define MCI_CLKDIV_OFFSET                     0
++#define MCI_CLKDIV_SIZE                               8
++#define MCI_PWSDIV_OFFSET                     8
++#define MCI_PWSDIV_SIZE                               3
++#define MCI_RDPROOF_OFFSET                    11
++#define MCI_RDPROOF_SIZE                      1
++#define MCI_WRPROOF_OFFSET                    12
++#define MCI_WRPROOF_SIZE                      1
++#define MCI_DMAPADV_OFFSET                    14
++#define MCI_DMAPADV_SIZE                      1
++#define MCI_BLKLEN_OFFSET                     16
++#define MCI_BLKLEN_SIZE                               16
++
++/* Bitfields in DTOR */
++#define MCI_DTOCYC_OFFSET                     0
++#define MCI_DTOCYC_SIZE                               4
++#define MCI_DTOMUL_OFFSET                     4
++#define MCI_DTOMUL_SIZE                               3
++
++/* Bitfields in SDCR */
++#define MCI_SDCSEL_OFFSET                     0
++#define MCI_SDCSEL_SIZE                               4
++#define MCI_SDCBUS_OFFSET                     7
++#define MCI_SDCBUS_SIZE                               1
++
++/* Bitfields in ARGR */
++#define MCI_ARG_OFFSET                                0
++#define MCI_ARG_SIZE                          32
++
++/* Bitfields in CMDR */
++#define MCI_CMDNB_OFFSET                      0
++#define MCI_CMDNB_SIZE                                6
++#define MCI_RSPTYP_OFFSET                     6
++#define MCI_RSPTYP_SIZE                               2
++#define MCI_SPCMD_OFFSET                      8
++#define MCI_SPCMD_SIZE                                3
++#define MCI_OPDCMD_OFFSET                     11
++#define MCI_OPDCMD_SIZE                               1
++#define MCI_MAXLAT_OFFSET                     12
++#define MCI_MAXLAT_SIZE                               1
++#define MCI_TRCMD_OFFSET                      16
++#define MCI_TRCMD_SIZE                                2
++#define MCI_TRDIR_OFFSET                      18
++#define MCI_TRDIR_SIZE                                1
++#define MCI_TRTYP_OFFSET                      19
++#define MCI_TRTYP_SIZE                                2
++
++/* Bitfields in BLKR */
++#define MCI_BCNT_OFFSET                               0
++#define MCI_BCNT_SIZE                         16
++
++/* Bitfields in RSPRn */
++#define MCI_RSP_OFFSET                                0
++#define MCI_RSP_SIZE                          32
++
++/* Bitfields in SR/IER/IDR/IMR */
++#define MCI_CMDRDY_OFFSET                     0
++#define MCI_CMDRDY_SIZE                               1
++#define MCI_RXRDY_OFFSET                      1
++#define MCI_RXRDY_SIZE                                1
++#define MCI_TXRDY_OFFSET                      2
++#define MCI_TXRDY_SIZE                                1
++#define MCI_BLKE_OFFSET                               3
++#define MCI_BLKE_SIZE                         1
++#define MCI_DTIP_OFFSET                               4
++#define MCI_DTIP_SIZE                         1
++#define MCI_NOTBUSY_OFFSET                    5
++#define MCI_NOTBUSY_SIZE                      1
++#define MCI_ENDRX_OFFSET                      6
++#define MCI_ENDRX_SIZE                                1
++#define MCI_ENDTX_OFFSET                      7
++#define MCI_ENDTX_SIZE                                1
++#define MCI_RXBUFF_OFFSET                     14
++#define MCI_RXBUFF_SIZE                               1
++#define MCI_TXBUFE_OFFSET                     15
++#define MCI_TXBUFE_SIZE                               1
++#define MCI_RINDE_OFFSET                      16
++#define MCI_RINDE_SIZE                                1
++#define MCI_RDIRE_OFFSET                      17
++#define MCI_RDIRE_SIZE                                1
++#define MCI_RCRCE_OFFSET                      18
++#define MCI_RCRCE_SIZE                                1
++#define MCI_RENDE_OFFSET                      19
++#define MCI_RENDE_SIZE                                1
++#define MCI_RTOE_OFFSET                               20
++#define MCI_RTOE_SIZE                         1
++#define MCI_DCRCE_OFFSET                      21
++#define MCI_DCRCE_SIZE                                1
++#define MCI_DTOE_OFFSET                               22
++#define MCI_DTOE_SIZE                         1
++#define MCI_OVRE_OFFSET                               30
++#define MCI_OVRE_SIZE                         1
++#define MCI_UNRE_OFFSET                               31
++#define MCI_UNRE_SIZE                         1
++
++/* Constants for DTOMUL */
++#define MCI_DTOMUL_1_CYCLE                    0
++#define MCI_DTOMUL_16_CYCLES                  1
++#define MCI_DTOMUL_128_CYCLES                 2
++#define MCI_DTOMUL_256_CYCLES                 3
++#define MCI_DTOMUL_1024_CYCLES                        4
++#define MCI_DTOMUL_4096_CYCLES                        5
++#define MCI_DTOMUL_65536_CYCLES                       6
++#define MCI_DTOMUL_1048576_CYCLES             7
++
++/* Constants for RSPTYP */
++#define MCI_RSPTYP_NO_RESP                    0
++#define MCI_RSPTYP_48_BIT                     1
++#define MCI_RSPTYP_136_BIT                    2
++
++/* Constants for SPCMD */
++#define MCI_SPCMD_NO_SPEC_CMD                 0
++#define MCI_SPCMD_INIT_CMD                    1
++#define MCI_SPCMD_SYNC_CMD                    2
++#define MCI_SPCMD_INT_CMD                     4
++#define MCI_SPCMD_INT_RESP                    5
++
++/* Constants for TRCMD */
++#define MCI_TRCMD_NO_TRANS                    0
++#define MCI_TRCMD_START_TRANS                 1
++#define MCI_TRCMD_STOP_TRANS                  2
++
++/* Constants for TRTYP */
++#define MCI_TRTYP_BLOCK                               0
++#define MCI_TRTYP_MULTI_BLOCK                 1
++#define MCI_TRTYP_STREAM                      2
++
++/* Bit manipulation macros */
++#define MCI_BIT(name)                                 \
++      (1 << MCI_##name##_OFFSET)
++#define MCI_BF(name,value)                            \
++      (((value) & ((1 << MCI_##name##_SIZE) - 1))     \
++       << MCI_##name##_OFFSET)
++#define MCI_BFEXT(name,value)                         \
++      (((value) >> MCI_##name##_OFFSET)               \
++       & ((1 << MCI_##name##_SIZE) - 1))
++#define MCI_BFINS(name,value,old)                     \
++      (((old) & ~(((1 << MCI_##name##_SIZE) - 1)      \
++                  << MCI_##name##_OFFSET))            \
++       | MCI_BF(name,value))
++
++/* Register access macros */
++#define mci_readl(port,reg)                           \
++      __raw_readl((port)->regs + MCI_##reg)
++#define mci_writel(port,reg,value)                    \
++      __raw_writel((value), (port)->regs + MCI_##reg)
++
++#endif /* __DRIVERS_MMC_ATMEL_MCI_H__ */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/mmc/Kconfig avr32-git/drivers/mmc/Kconfig
+--- linux-2.6.21.3/drivers/mmc/Kconfig 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/mmc/Kconfig      2007-06-06 11:33:56.000000000 +0200
+@@ -71,6 +71,16 @@
+         If unsure, say N.
++config MMC_ATMELMCI
++      tristate "Atmel Multimedia Card Interface support"
++      depends on AVR32 && MMC
++      help
++        This selects the Atmel Multimedia Card Interface. If you have
++        a AT91 (ARM) or AT32 (AVR32) platform with a Multimedia Card
++        slot, say Y or M here.
++
++        If unsure, say N.
++
+ config MMC_WBSD
+       tristate "Winbond W83L51xD SD/MMC Card Interface support"
+       depends on MMC && ISA_DMA_API
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/mmc/Makefile avr32-git/drivers/mmc/Makefile
+--- linux-2.6.21.3/drivers/mmc/Makefile        2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/mmc/Makefile     2007-06-06 11:33:56.000000000 +0200
+@@ -23,6 +23,7 @@
+ obj-$(CONFIG_MMC_AU1X)                += au1xmmc.o
+ obj-$(CONFIG_MMC_OMAP)                += omap.o
+ obj-$(CONFIG_MMC_AT91)                += at91_mci.o
++obj-$(CONFIG_MMC_ATMELMCI)    += atmel-mci.o
+ obj-$(CONFIG_MMC_TIFM_SD)     += tifm_sd.o
+ mmc_core-y := mmc.o mmc_sysfs.o
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/mtd/chips/cfi_cmdset_0001.c avr32-git/drivers/mtd/chips/cfi_cmdset_0001.c
+--- linux-2.6.21.3/drivers/mtd/chips/cfi_cmdset_0001.c 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/mtd/chips/cfi_cmdset_0001.c      2007-06-06 11:33:56.000000000 +0200
+@@ -47,6 +47,7 @@
+ #define I82802AC      0x00ac
+ #define MANUFACTURER_ST         0x0020
+ #define M50LPW080       0x002F
++#define AT49BV640D    0x02de
+ static int cfi_intelext_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
+ static int cfi_intelext_write_words(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
+@@ -153,6 +154,47 @@
+ }
+ #endif
++/* Atmel chips don't use the same PRI format as Intel chips */
++static void fixup_convert_atmel_pri(struct mtd_info *mtd, void *param)
++{
++      struct map_info *map = mtd->priv;
++      struct cfi_private *cfi = map->fldrv_priv;
++      struct cfi_pri_intelext *extp = cfi->cmdset_priv;
++      struct cfi_pri_atmel atmel_pri;
++      uint32_t features = 0;
++
++      /* Reverse byteswapping */
++      extp->FeatureSupport = cpu_to_le32(extp->FeatureSupport);
++      extp->BlkStatusRegMask = cpu_to_le16(extp->BlkStatusRegMask);
++      extp->ProtRegAddr = cpu_to_le16(extp->ProtRegAddr);
++
++      memcpy(&atmel_pri, extp, sizeof(atmel_pri));
++      memset((char *)extp + 5, 0, sizeof(*extp) - 5);
++
++      printk(KERN_ERR "atmel Features: %02x\n", atmel_pri.Features);
++
++      if (atmel_pri.Features & 0x01) /* chip erase supported */
++              features |= (1<<0);
++      if (atmel_pri.Features & 0x02) /* erase suspend supported */
++              features |= (1<<1);
++      if (atmel_pri.Features & 0x04) /* program suspend supported */
++              features |= (1<<2);
++      if (atmel_pri.Features & 0x08) /* simultaneous operations supported */
++              features |= (1<<9);
++      if (atmel_pri.Features & 0x20) /* page mode read supported */
++              features |= (1<<7);
++      if (atmel_pri.Features & 0x40) /* queued erase supported */
++              features |= (1<<4);
++      if (atmel_pri.Features & 0x80) /* Protection bits supported */
++              features |= (1<<6);
++
++      extp->FeatureSupport = features;
++
++      /* burst write mode not supported */
++      cfi->cfiq->BufWriteTimeoutTyp = 0;
++      cfi->cfiq->BufWriteTimeoutMax = 0;
++}
++
+ #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
+ /* Some Intel Strata Flash prior to FPO revision C has bugs in this area */
+ static void fixup_intel_strataflash(struct mtd_info *mtd, void* param)
+@@ -221,6 +263,7 @@
+ }
+ static struct cfi_fixup cfi_fixup_table[] = {
++      { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri, NULL },
+ #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
+       { CFI_MFR_ANY, CFI_ID_ANY, fixup_intel_strataflash, NULL },
+ #endif
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/mtd/chips/cfi_cmdset_0002.c avr32-git/drivers/mtd/chips/cfi_cmdset_0002.c
+--- linux-2.6.21.3/drivers/mtd/chips/cfi_cmdset_0002.c 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/mtd/chips/cfi_cmdset_0002.c      2007-06-06 11:33:56.000000000 +0200
+@@ -185,6 +185,10 @@
+               extp->TopBottom = 2;
+       else
+               extp->TopBottom = 3;
++
++      /* burst write mode not supported */
++      cfi->cfiq->BufWriteTimeoutTyp = 0;
++      cfi->cfiq->BufWriteTimeoutMax = 0;
+ }
+ static void fixup_use_secsi(struct mtd_info *mtd, void *param)
+@@ -217,6 +221,7 @@
+ }
+ static struct cfi_fixup cfi_fixup_table[] = {
++      { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri, NULL },
+ #ifdef AMD_BOOTLOC_BUG
+       { CFI_MFR_AMD, CFI_ID_ANY, fixup_amd_bootblock, NULL },
+ #endif
+@@ -229,7 +234,6 @@
+ #if !FORCE_WORD_WRITE
+       { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers, NULL, },
+ #endif
+-      { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri, NULL },
+       { 0, 0, NULL, NULL }
+ };
+ static struct cfi_fixup jedec_fixup_table[] = {
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/serial/atmel_serial.c avr32-git/drivers/serial/atmel_serial.c
+--- linux-2.6.21.3/drivers/serial/atmel_serial.c       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/serial/atmel_serial.c    2007-06-06 11:33:59.000000000 +0200
+@@ -114,6 +114,7 @@
+       struct uart_port        uart;           /* uart */
+       struct clk              *clk;           /* uart clock */
+       unsigned short          suspended;      /* is port suspended? */
++      int                     break_active;   /* break being received */
+ };
+ static struct atmel_uart_port atmel_ports[ATMEL_MAX_UART];
+@@ -252,6 +253,7 @@
+  */
+ static void atmel_rx_chars(struct uart_port *port)
+ {
++      struct atmel_uart_port *atmel_port = (struct atmel_uart_port *) port;
+       struct tty_struct *tty = port->info->tty;
+       unsigned int status, ch, flg;
+@@ -267,13 +269,29 @@
+                * note that the error handling code is
+                * out of the main execution path
+                */
+-              if (unlikely(status & (ATMEL_US_PARE | ATMEL_US_FRAME | ATMEL_US_OVRE | ATMEL_US_RXBRK))) {
++              if (unlikely(status & (ATMEL_US_PARE | ATMEL_US_FRAME
++                                     | ATMEL_US_OVRE | ATMEL_US_RXBRK)
++                           || atmel_port->break_active)) {
+                       UART_PUT_CR(port, ATMEL_US_RSTSTA);     /* clear error */
+-                      if (status & ATMEL_US_RXBRK) {
++                      if (status & ATMEL_US_RXBRK
++                          && !atmel_port->break_active) {
+                               status &= ~(ATMEL_US_PARE | ATMEL_US_FRAME);    /* ignore side-effect */
+                               port->icount.brk++;
++                              atmel_port->break_active = 1;
++                              UART_PUT_IER(port, ATMEL_US_RXBRK);
+                               if (uart_handle_break(port))
+                                       goto ignore_char;
++                      } else {
++                              /*
++                               * This is either the end-of-break
++                               * condition or we've received at
++                               * least one character without RXBRK
++                               * being set. In both cases, the next
++                               * RXBRK will indicate start-of-break.
++                               */
++                              UART_PUT_IDR(port, ATMEL_US_RXBRK);
++                              status &= ~ATMEL_US_RXBRK;
++                              atmel_port->break_active = 0;
+                       }
+                       if (status & ATMEL_US_PARE)
+                               port->icount.parity++;
+@@ -352,6 +370,16 @@
+               /* Interrupt receive */
+               if (pending & ATMEL_US_RXRDY)
+                       atmel_rx_chars(port);
++              else if (pending & ATMEL_US_RXBRK) {
++                      /*
++                       * End of break detected. If it came along
++                       * with a character, atmel_rx_chars will
++                       * handle it.
++                       */
++                      UART_PUT_CR(port, ATMEL_US_RSTSTA);
++                      UART_PUT_IDR(port, ATMEL_US_RXBRK);
++                      atmel_port->break_active = 0;
++              }
+               // TODO: All reads to CSR will clear these interrupts!
+               if (pending & ATMEL_US_RIIC) port->icount.rng++;
+@@ -484,11 +512,16 @@
+       unsigned long flags;
+       unsigned int mode, imr, quot, baud;
++      /* Get current mode register */
++      mode = UART_GET_MR(port) & ~(ATMEL_US_USCLKS | ATMEL_US_CHRL | ATMEL_US_NBSTOP | ATMEL_US_PAR);
++
+       baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
+       quot = uart_get_divisor(port, baud);
+-      /* Get current mode register */
+-      mode = UART_GET_MR(port) & ~(ATMEL_US_CHRL | ATMEL_US_NBSTOP | ATMEL_US_PAR);
++      if (quot > 65535) {             /* BRGR is 16-bit, so switch to slower clock */
++              quot /= 8;
++              mode |= ATMEL_US_USCLKS_MCK_DIV8;
++      }
+       /* byte size */
+       switch (termios->c_cflag & CSIZE) {
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/serial/atmel_serial.h avr32-git/drivers/serial/atmel_serial.h
+--- linux-2.6.21.3/drivers/serial/atmel_serial.h       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/serial/atmel_serial.h    2007-06-06 11:33:59.000000000 +0200
+@@ -46,6 +46,9 @@
+ #define                       ATMEL_US_USMODE_ISO7816_T1      6
+ #define                       ATMEL_US_USMODE_IRDA            8
+ #define               ATMEL_US_USCLKS         (3   <<  4)             /* Clock Selection */
++#define                       ATMEL_US_USCLKS_MCK             (0 <<  4)
++#define                       ATMEL_US_USCLKS_MCK_DIV8        (1 <<  4)
++#define                       ATMEL_US_USCLKS_SCK             (3 <<  4)
+ #define               ATMEL_US_CHRL           (3   <<  6)             /* Character Length */
+ #define                       ATMEL_US_CHRL_5                 (0 <<  6)
+ #define                       ATMEL_US_CHRL_6                 (1 <<  6)
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/spi/atmel_spi.c avr32-git/drivers/spi/atmel_spi.c
+--- linux-2.6.21.3/drivers/spi/atmel_spi.c     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/spi/atmel_spi.c  2007-06-06 11:33:59.000000000 +0200
+@@ -22,10 +22,7 @@
+ #include <asm/io.h>
+ #include <asm/arch/board.h>
+ #include <asm/arch/gpio.h>
+-
+-#ifdef CONFIG_ARCH_AT91
+ #include <asm/arch/cpu.h>
+-#endif
+ #include "atmel_spi.h"
+@@ -116,16 +113,16 @@
+       len = as->remaining_bytes;
+-      tx_dma = xfer->tx_dma;
+-      rx_dma = xfer->rx_dma;
++      tx_dma = xfer->tx_dma + xfer->len - len;
++      rx_dma = xfer->rx_dma + xfer->len - len;
+       /* use scratch buffer only when rx or tx data is unspecified */
+-      if (rx_dma == INVALID_DMA_ADDRESS) {
++      if (!xfer->rx_buf) {
+               rx_dma = as->buffer_dma;
+               if (len > BUFFER_SIZE)
+                       len = BUFFER_SIZE;
+       }
+-      if (tx_dma == INVALID_DMA_ADDRESS) {
++      if (!xfer->tx_buf) {
+               tx_dma = as->buffer_dma;
+               if (len > BUFFER_SIZE)
+                       len = BUFFER_SIZE;
+@@ -415,8 +412,8 @@
+               csr |= SPI_BIT(NCPHA);
+       /* TODO: DLYBS and DLYBCT */
+-      csr |= SPI_BF(DLYBS, 10);
+-      csr |= SPI_BF(DLYBCT, 10);
++      csr |= SPI_BF(DLYBS, 0);
++      csr |= SPI_BF(DLYBCT, 0);
+       /* chipselect must have been muxed as GPIO (e.g. in board setup) */
+       npcs_pin = (unsigned int)spi->controller_data;
+@@ -552,10 +549,8 @@
+               goto out_free_buffer;
+       as->irq = irq;
+       as->clk = clk;
+-#ifdef CONFIG_ARCH_AT91
+       if (!cpu_is_at91rm9200())
+               as->new_1 = 1;
+-#endif
+       ret = request_irq(irq, atmel_spi_interrupt, 0,
+                       pdev->dev.bus_id, master);
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/video/atmel_lcdfb.c avr32-git/drivers/video/atmel_lcdfb.c
+--- linux-2.6.21.3/drivers/video/atmel_lcdfb.c 1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/drivers/video/atmel_lcdfb.c      2007-06-06 11:34:00.000000000 +0200
+@@ -0,0 +1,752 @@
++/*
++ *  Driver for AT91/AT32 LCD Controller
++ *
++ *  Copyright (C) 2007 Atmel Corporation
++ *
++ * This file is subject to the terms and conditions of the GNU General Public
++ * License.  See the file COPYING in the main directory of this archive for
++ * more details.
++ */
++
++#include <linux/kernel.h>
++#include <linux/platform_device.h>
++#include <linux/dma-mapping.h>
++#include <linux/interrupt.h>
++#include <linux/clk.h>
++#include <linux/fb.h>
++#include <linux/init.h>
++#include <linux/delay.h>
++
++#include <asm/arch/board.h>
++#include <asm/arch/cpu.h>
++#include <asm/arch/gpio.h>
++
++#include <video/atmel_lcdc.h>
++
++#define lcdc_readl(sinfo, reg)                __raw_readl((sinfo)->mmio+(reg))
++#define lcdc_writel(sinfo, reg, val)  __raw_writel((val), (sinfo)->mmio+(reg))
++
++/* configurable parameters */
++#define ATMEL_LCDC_CVAL_DEFAULT               0xc8
++#define ATMEL_LCDC_DMA_BURST_LEN      8
++
++#if defined(CONFIG_ARCH_AT91SAM9263)
++#define ATMEL_LCDC_FIFO_SIZE          2048
++#else
++#define ATMEL_LCDC_FIFO_SIZE          512
++#endif
++
++#if defined(CONFIG_ARCH_AT91)
++#define       ATMEL_LCDFB_FBINFO_DEFAULT      FBINFO_DEFAULT
++
++static inline void atmel_lcdfb_update_dma2d(struct atmel_lcdfb_info *sinfo,
++                                      struct fb_var_screeninfo *var)
++{
++
++}
++#elif defined(CONFIG_AVR32)
++#define       ATMEL_LCDFB_FBINFO_DEFAULT      (FBINFO_DEFAULT \
++                                      | FBINFO_PARTIAL_PAN_OK \
++                                      | FBINFO_HWACCEL_XPAN \
++                                      | FBINFO_HWACCEL_YPAN)
++
++static void atmel_lcdfb_update_dma2d(struct atmel_lcdfb_info *sinfo,
++                                   struct fb_var_screeninfo *var)
++{
++      u32 dma2dcfg;
++      u32 pixeloff;
++
++      pixeloff = (var->xoffset * var->bits_per_pixel) & 0x1f;
++
++      dma2dcfg = ((var->xres_virtual - var->xres) * var->bits_per_pixel) / 8;
++      dma2dcfg |= pixeloff << ATMEL_LCDC_PIXELOFF_OFFSET;
++      lcdc_writel(sinfo, ATMEL_LCDC_DMA2DCFG, dma2dcfg);
++
++      /* Update configuration */
++      lcdc_writel(sinfo, ATMEL_LCDC_DMACON,
++                  lcdc_readl(sinfo, ATMEL_LCDC_DMACON)
++                  | ATMEL_LCDC_DMAUPDT);
++}
++#endif
++
++
++static struct fb_fix_screeninfo atmel_lcdfb_fix __initdata = {
++      .type           = FB_TYPE_PACKED_PIXELS,
++      .visual         = FB_VISUAL_TRUECOLOR,
++      .xpanstep       = 0,
++      .ypanstep       = 0,
++      .ywrapstep      = 0,
++      .accel          = FB_ACCEL_NONE,
++};
++
++
++static void atmel_lcdfb_update_dma(struct fb_info *info,
++                             struct fb_var_screeninfo *var)
++{
++      struct atmel_lcdfb_info *sinfo = info->par;
++      struct fb_fix_screeninfo *fix = &info->fix;
++      unsigned long dma_addr;
++
++      dma_addr = (fix->smem_start + var->yoffset * fix->line_length
++                  + var->xoffset * var->bits_per_pixel / 8);
++
++      dma_addr &= ~3UL;
++
++      /* Set framebuffer DMA base address and pixel offset */
++      lcdc_writel(sinfo, ATMEL_LCDC_DMABADDR1, dma_addr);
++
++      atmel_lcdfb_update_dma2d(sinfo, var);
++}
++
++static inline void atmel_lcdfb_free_video_memory(struct atmel_lcdfb_info *sinfo)
++{
++      struct fb_info *info = sinfo->info;
++
++      dma_free_writecombine(info->device, info->fix.smem_len,
++                              info->screen_base, info->fix.smem_start);
++}
++
++/**
++ *    atmel_lcdfb_alloc_video_memory - Allocate framebuffer memory
++ *    @sinfo: the frame buffer to allocate memory for
++ */
++static int atmel_lcdfb_alloc_video_memory(struct atmel_lcdfb_info *sinfo)
++{
++      struct fb_info *info = sinfo->info;
++      struct fb_var_screeninfo *var = &info->var;
++
++      info->fix.smem_len = (var->xres_virtual * var->yres_virtual
++                          * ((var->bits_per_pixel + 7) / 8));
++
++      info->screen_base = dma_alloc_writecombine(info->device, info->fix.smem_len,
++                                      (dma_addr_t *)&info->fix.smem_start, GFP_KERNEL);
++
++      if (!info->screen_base) {
++              return -ENOMEM;
++      }
++
++      return 0;
++}
++
++/**
++ *      atmel_lcdfb_check_var - Validates a var passed in.
++ *      @var: frame buffer variable screen structure
++ *      @info: frame buffer structure that represents a single frame buffer
++ *
++ *    Checks to see if the hardware supports the state requested by
++ *    var passed in. This function does not alter the hardware
++ *    state!!!  This means the data stored in struct fb_info and
++ *    struct atmel_lcdfb_info do not change. This includes the var
++ *    inside of struct fb_info.  Do NOT change these. This function
++ *    can be called on its own if we intent to only test a mode and
++ *    not actually set it. The stuff in modedb.c is a example of
++ *    this. If the var passed in is slightly off by what the
++ *    hardware can support then we alter the var PASSED in to what
++ *    we can do. If the hardware doesn't support mode change a
++ *    -EINVAL will be returned by the upper layers. You don't need
++ *    to implement this function then. If you hardware doesn't
++ *    support changing the resolution then this function is not
++ *    needed. In this case the driver would just provide a var that
++ *    represents the static state the screen is in.
++ *
++ *    Returns negative errno on error, or zero on success.
++ */
++static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
++                           struct fb_info *info)
++{
++      struct device *dev = info->device;
++      struct atmel_lcdfb_info *sinfo = info->par;
++      unsigned long clk_value_khz;
++
++      clk_value_khz = clk_get_rate(sinfo->lcdc_clk) / 1000;
++
++      dev_dbg(dev, "%s:\n", __func__);
++      dev_dbg(dev, "  resolution: %ux%u\n", var->xres, var->yres);
++      dev_dbg(dev, "  pixclk:     %lu KHz\n", PICOS2KHZ(var->pixclock));
++      dev_dbg(dev, "  bpp:        %u\n", var->bits_per_pixel);
++      dev_dbg(dev, "  clk:        %lu KHz\n", clk_value_khz);
++
++      if ((PICOS2KHZ(var->pixclock) * var->bits_per_pixel / 8) > clk_value_khz) {
++              dev_err(dev, "%lu KHz pixel clock is too fast\n", PICOS2KHZ(var->pixclock));
++              return -EINVAL;
++      }
++
++      /* Force same alignment for each line */
++      var->xres = (var->xres + 3) & ~3UL;
++      var->xres_virtual = (var->xres_virtual + 3) & ~3UL;
++
++      var->red.msb_right = var->green.msb_right = var->blue.msb_right = 0;
++      var->transp.msb_right = 0;
++      var->transp.offset = var->transp.length = 0;
++      var->xoffset = var->yoffset = 0;
++
++      switch (var->bits_per_pixel) {
++      case 2:
++      case 4:
++      case 8:
++              var->red.offset = var->green.offset = var->blue.offset = 0;
++              var->red.length = var->green.length = var->blue.length
++                      = var->bits_per_pixel;
++              break;
++      case 15:
++      case 16:
++              var->red.offset = 0;
++              var->green.offset = 5;
++              var->blue.offset = 10;
++              var->red.length = var->green.length = var->blue.length = 5;
++              break;
++      case 24:
++      case 32:
++              var->red.offset = 0;
++              var->green.offset = 8;
++              var->blue.offset = 16;
++              var->red.length = var->green.length = var->blue.length = 8;
++              break;
++      default:
++              dev_err(dev, "color depth %d not supported\n",
++                                      var->bits_per_pixel);
++              return -EINVAL;
++      }
++
++      return 0;
++}
++
++/**
++ *      atmel_lcdfb_set_par - Alters the hardware state.
++ *      @info: frame buffer structure that represents a single frame buffer
++ *
++ *    Using the fb_var_screeninfo in fb_info we set the resolution
++ *    of the this particular framebuffer. This function alters the
++ *    par AND the fb_fix_screeninfo stored in fb_info. It doesn't
++ *    not alter var in fb_info since we are using that data. This
++ *    means we depend on the data in var inside fb_info to be
++ *    supported by the hardware.  atmel_lcdfb_check_var is always called
++ *    before atmel_lcdfb_set_par to ensure this.  Again if you can't
++ *    change the resolution you don't need this function.
++ *
++ */
++static int atmel_lcdfb_set_par(struct fb_info *info)
++{
++      struct atmel_lcdfb_info *sinfo = info->par;
++      unsigned long value;
++      unsigned long clk_value_khz;
++
++      dev_dbg(info->device, "%s:\n", __func__);
++      dev_dbg(info->device, "  * resolution: %ux%u (%ux%u virtual)\n",
++               info->var.xres, info->var.yres,
++               info->var.xres_virtual, info->var.yres_virtual);
++
++      /* Turn off the LCD controller and the DMA controller */
++      lcdc_writel(sinfo, ATMEL_LCDC_PWRCON, sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET);
++
++      lcdc_writel(sinfo, ATMEL_LCDC_DMACON, 0);
++
++      if (info->var.bits_per_pixel <= 8)
++              info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
++      else
++              info->fix.visual = FB_VISUAL_TRUECOLOR;
++
++      info->fix.line_length = info->var.xres_virtual * (info->var.bits_per_pixel / 8);
++
++      /* Re-initialize the DMA engine... */
++      dev_dbg(info->device, "  * update DMA engine\n");
++      atmel_lcdfb_update_dma(info, &info->var);
++
++      /* ...set frame size and burst length = 8 words (?) */
++      value = (info->var.yres * info->var.xres * info->var.bits_per_pixel) / 32;
++      value |= ((ATMEL_LCDC_DMA_BURST_LEN - 1) << ATMEL_LCDC_BLENGTH_OFFSET);
++      lcdc_writel(sinfo, ATMEL_LCDC_DMAFRMCFG, value);
++
++      /* Now, the LCDC core... */
++
++      /* Set pixel clock */
++      clk_value_khz = clk_get_rate(sinfo->lcdc_clk) / 1000;
++
++      value = clk_value_khz / PICOS2KHZ(info->var.pixclock);
++
++      if (clk_value_khz % PICOS2KHZ(info->var.pixclock))
++              value++;
++
++      value = (value / 2) - 1;
++
++      if (value <= 0) {
++              dev_notice(info->device, "Bypassing pixel clock divider\n");
++              lcdc_writel(sinfo, ATMEL_LCDC_LCDCON1, ATMEL_LCDC_BYPASS);
++      } else
++              lcdc_writel(sinfo, ATMEL_LCDC_LCDCON1, value << ATMEL_LCDC_CLKVAL_OFFSET);
++
++      /* Initialize control register 2 */
++      value = sinfo->default_lcdcon2;
++
++      if (!(info->var.sync & FB_SYNC_HOR_HIGH_ACT))
++              value |= ATMEL_LCDC_INVLINE_INVERTED;
++      if (!(info->var.sync & FB_SYNC_VERT_HIGH_ACT))
++              value |= ATMEL_LCDC_INVFRAME_INVERTED;
++
++      switch (info->var.bits_per_pixel) {
++              case 1: value |= ATMEL_LCDC_PIXELSIZE_1; break;
++              case 2: value |= ATMEL_LCDC_PIXELSIZE_2; break;
++              case 4: value |= ATMEL_LCDC_PIXELSIZE_4; break;
++              case 8: value |= ATMEL_LCDC_PIXELSIZE_8; break;
++              case 15: /* fall through */
++              case 16: value |= ATMEL_LCDC_PIXELSIZE_16; break;
++              case 24: value |= ATMEL_LCDC_PIXELSIZE_24; break;
++              case 32: value |= ATMEL_LCDC_PIXELSIZE_32; break;
++              default: BUG(); break;
++      }
++      dev_dbg(info->device, "  * LCDCON2 = %08lx\n", value);
++      lcdc_writel(sinfo, ATMEL_LCDC_LCDCON2, value);
++
++      /* Vertical timing */
++      value = (info->var.vsync_len - 1) << ATMEL_LCDC_VPW_OFFSET;
++      value |= info->var.upper_margin << ATMEL_LCDC_VBP_OFFSET;
++      value |= info->var.lower_margin;
++      dev_dbg(info->device, "  * LCDTIM1 = %08lx\n", value);
++      lcdc_writel(sinfo, ATMEL_LCDC_TIM1, value);
++
++      /* Horizontal timing */
++      value = (info->var.right_margin - 1) << ATMEL_LCDC_HFP_OFFSET;
++      value |= (info->var.hsync_len - 1) << ATMEL_LCDC_HPW_OFFSET;
++      value |= (info->var.left_margin - 1);
++      dev_dbg(info->device, "  * LCDTIM2 = %08lx\n", value);
++      lcdc_writel(sinfo, ATMEL_LCDC_TIM2, value);
++
++      /* Display size */
++      value = (info->var.xres - 1) << ATMEL_LCDC_HOZVAL_OFFSET;
++      value |= info->var.yres - 1;
++      lcdc_writel(sinfo, ATMEL_LCDC_LCDFRMCFG, value);
++
++      /* FIFO Threshold: Use formula from data sheet */
++      value = ATMEL_LCDC_FIFO_SIZE - (2 * ATMEL_LCDC_DMA_BURST_LEN + 3);
++      lcdc_writel(sinfo, ATMEL_LCDC_FIFO, value);
++
++      /* Toggle LCD_MODE every frame */
++      lcdc_writel(sinfo, ATMEL_LCDC_MVAL, 0);
++
++      /* Disable all interrupts */
++      lcdc_writel(sinfo, ATMEL_LCDC_IDR, ~0UL);
++
++      /* Set contrast */
++      value = ATMEL_LCDC_PS_DIV8 | ATMEL_LCDC_POL_POSITIVE | ATMEL_LCDC_ENA_PWMENABLE;
++      lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_CTR, value);
++      lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_VAL, ATMEL_LCDC_CVAL_DEFAULT);
++      /* ...wait for DMA engine to become idle... */
++      while (lcdc_readl(sinfo, ATMEL_LCDC_DMACON) & ATMEL_LCDC_DMABUSY)
++              msleep(10);
++
++      dev_dbg(info->device, "  * re-enable DMA engine\n");
++      /* ...and enable it with updated configuration */
++      lcdc_writel(sinfo, ATMEL_LCDC_DMACON, sinfo->default_dmacon);
++
++      dev_dbg(info->device, "  * re-enable LCDC core\n");
++      lcdc_writel(sinfo, ATMEL_LCDC_PWRCON,
++              (sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET) | ATMEL_LCDC_PWR);
++
++      dev_dbg(info->device, "  * DONE\n");
++
++      return 0;
++}
++
++static inline unsigned int chan_to_field(unsigned int chan, const struct fb_bitfield *bf)
++{
++      chan &= 0xffff;
++      chan >>= 16 - bf->length;
++      return chan << bf->offset;
++}
++
++/**
++ *    atmel_lcdfb_setcolreg - Optional function. Sets a color register.
++ *      @regno: Which register in the CLUT we are programming
++ *      @red: The red value which can be up to 16 bits wide
++ *    @green: The green value which can be up to 16 bits wide
++ *    @blue:  The blue value which can be up to 16 bits wide.
++ *    @transp: If supported the alpha value which can be up to 16 bits wide.
++ *      @info: frame buffer info structure
++ *
++ *    Set a single color register. The values supplied have a 16 bit
++ *    magnitude which needs to be scaled in this function for the hardware.
++ *    Things to take into consideration are how many color registers, if
++ *    any, are supported with the current color visual. With truecolor mode
++ *    no color palettes are supported. Here a psuedo palette is created
++ *    which we store the value in pseudo_palette in struct fb_info. For
++ *    pseudocolor mode we have a limited color palette. To deal with this
++ *    we can program what color is displayed for a particular pixel value.
++ *    DirectColor is similar in that we can program each color field. If
++ *    we have a static colormap we don't need to implement this function.
++ *
++ *    Returns negative errno on error, or zero on success. In an
++ *    ideal world, this would have been the case, but as it turns
++ *    out, the other drivers return 1 on failure, so that's what
++ *    we're going to do.
++ */
++static int atmel_lcdfb_setcolreg(unsigned int regno, unsigned int red,
++                           unsigned int green, unsigned int blue,
++                           unsigned int transp, struct fb_info *info)
++{
++      struct atmel_lcdfb_info *sinfo = info->par;
++      unsigned int val;
++      u32 *pal;
++      int ret = 1;
++
++      if (info->var.grayscale)
++              red = green = blue = (19595 * red + 38470 * green
++                                    + 7471 * blue) >> 16;
++
++      switch (info->fix.visual) {
++      case FB_VISUAL_TRUECOLOR:
++              if (regno < 16) {
++                      pal = info->pseudo_palette;
++
++                      val  = chan_to_field(red, &info->var.red);
++                      val |= chan_to_field(green, &info->var.green);
++                      val |= chan_to_field(blue, &info->var.blue);
++
++                      pal[regno] = val;
++                      ret = 0;
++              }
++              break;
++
++      case FB_VISUAL_PSEUDOCOLOR:
++              if (regno < 256) {
++                      val  = ((red   >> 11) & 0x001f);
++                      val |= ((green >>  6) & 0x03e0);
++                      val |= ((blue  >>  1) & 0x7c00);
++
++                      /*
++                       * TODO: intensity bit. Maybe something like
++                       *   ~(red[10] ^ green[10] ^ blue[10]) & 1
++                       */
++
++                      lcdc_writel(sinfo, ATMEL_LCDC_LUT(regno), val);
++                      ret = 0;
++              }
++              break;
++      }
++
++      return ret;
++}
++
++static int atmel_lcdfb_pan_display(struct fb_var_screeninfo *var,
++                             struct fb_info *info)
++{
++      dev_dbg(info->device, "%s\n", __func__);
++
++      atmel_lcdfb_update_dma(info, var);
++
++      return 0;
++}
++
++static struct fb_ops atmel_lcdfb_ops = {
++      .owner          = THIS_MODULE,
++      .fb_check_var   = atmel_lcdfb_check_var,
++      .fb_set_par     = atmel_lcdfb_set_par,
++      .fb_setcolreg   = atmel_lcdfb_setcolreg,
++      .fb_pan_display = atmel_lcdfb_pan_display,
++      .fb_fillrect    = cfb_fillrect,
++      .fb_copyarea    = cfb_copyarea,
++      .fb_imageblit   = cfb_imageblit,
++};
++
++static irqreturn_t atmel_lcdfb_interrupt(int irq, void *dev_id)
++{
++      struct fb_info *info = dev_id;
++      struct atmel_lcdfb_info *sinfo = info->par;
++      u32 status;
++
++      status = lcdc_readl(sinfo, ATMEL_LCDC_ISR);
++      lcdc_writel(sinfo, ATMEL_LCDC_IDR, status);
++      return IRQ_HANDLED;
++}
++
++static int __init atmel_lcdfb_init_fbinfo(struct atmel_lcdfb_info *sinfo)
++{
++      struct fb_info *info = sinfo->info;
++      int ret = 0;
++
++      memset_io(info->screen_base, 0, info->fix.smem_len);
++      info->var.activate |= FB_ACTIVATE_FORCE | FB_ACTIVATE_NOW;
++
++      dev_info(info->device,
++             "%luKiB frame buffer at %08lx (mapped at %p)\n",
++             (unsigned long)info->fix.smem_len / 1024,
++             (unsigned long)info->fix.smem_start,
++             info->screen_base);
++
++      /* Allocate colormap */
++      ret = fb_alloc_cmap(&info->cmap, 256, 0);
++      if (ret < 0)
++              dev_err(info->device, "Alloc color map failed\n");
++
++      return ret;
++}
++
++static void atmel_lcdfb_start_clock(struct atmel_lcdfb_info *sinfo)
++{
++      if (sinfo->bus_clk)
++              clk_enable(sinfo->bus_clk);
++      clk_enable(sinfo->lcdc_clk);
++}
++
++static void atmel_lcdfb_stop_clock(struct atmel_lcdfb_info *sinfo)
++{
++      if (sinfo->bus_clk)
++              clk_disable(sinfo->bus_clk);
++      clk_disable(sinfo->lcdc_clk);
++}
++
++
++static int __init atmel_lcdfb_probe(struct platform_device *pdev)
++{
++      struct device *dev = &pdev->dev;
++      struct fb_info *info;
++      struct atmel_lcdfb_info *sinfo;
++      struct atmel_lcdfb_info *pdata_sinfo;
++      struct resource *regs = NULL;
++      struct resource *map = NULL;
++      int ret;
++
++      dev_dbg(dev, "%s BEGIN\n", __func__);
++
++      ret = -ENOMEM;
++      info = framebuffer_alloc(sizeof(struct atmel_lcdfb_info), dev);
++      if (!info) {
++              dev_err(dev, "cannot allocate memory\n");
++              goto out;
++      }
++
++      sinfo = info->par;
++
++      if (dev->platform_data) {
++              pdata_sinfo = (struct atmel_lcdfb_info *)dev->platform_data;
++              sinfo->default_bpp = pdata_sinfo->default_bpp;
++              sinfo->default_dmacon = pdata_sinfo->default_dmacon;
++              sinfo->default_lcdcon2 = pdata_sinfo->default_lcdcon2;
++              sinfo->default_monspecs = pdata_sinfo->default_monspecs;
++              sinfo->atmel_lcdfb_power_control = pdata_sinfo->atmel_lcdfb_power_control;
++              sinfo->guard_time = pdata_sinfo->guard_time;
++      } else {
++              dev_err(dev, "cannot get default configuration\n");
++              goto free_info;
++      }
++      sinfo->info = info;
++      sinfo->pdev = pdev;
++
++      strcpy(info->fix.id, sinfo->pdev->name);
++      info->flags = ATMEL_LCDFB_FBINFO_DEFAULT;
++      info->pseudo_palette = sinfo->pseudo_palette;
++      info->fbops = &atmel_lcdfb_ops;
++
++      memcpy(&info->monspecs, sinfo->default_monspecs, sizeof(info->monspecs));
++      info->fix = atmel_lcdfb_fix;
++
++      /* Enable LCDC Clocks */
++      if (cpu_is_at91sam9261() || cpu_is_at32ap7000()) {
++              sinfo->bus_clk = clk_get(dev, "hck1");
++              if (IS_ERR(sinfo->bus_clk)) {
++                      ret = PTR_ERR(sinfo->bus_clk);
++                      goto free_info;
++              }
++      }
++      sinfo->lcdc_clk = clk_get(dev, "lcdc_clk");
++      if (IS_ERR(sinfo->lcdc_clk)) {
++              ret = PTR_ERR(sinfo->lcdc_clk);
++              goto put_bus_clk;
++      }
++      atmel_lcdfb_start_clock(sinfo);
++
++      ret = fb_find_mode(&info->var, info, NULL, info->monspecs.modedb,
++                      info->monspecs.modedb_len, info->monspecs.modedb,
++                      sinfo->default_bpp);
++      if (!ret) {
++              dev_err(dev, "no suitable video mode found\n");
++              goto stop_clk;
++      }
++
++
++      regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++      if (!regs) {
++              dev_err(dev, "resources unusable\n");
++              ret = -ENXIO;
++              goto stop_clk;
++      }
++
++      sinfo->irq_base = platform_get_irq(pdev, 0);
++      if (sinfo->irq_base < 0) {
++              dev_err(dev, "unable to get irq\n");
++              ret = sinfo->irq_base;
++              goto stop_clk;
++      }
++
++      /* Initialize video memory */
++      map = platform_get_resource(pdev, IORESOURCE_MEM, 1);
++      if (map) {
++              /* use a pre-allocated memory buffer */
++              info->fix.smem_start = map->start;
++              info->fix.smem_len = map->end - map->start + 1;
++              if (!request_mem_region(info->fix.smem_start,
++                                      info->fix.smem_len, pdev->name)) {
++                      ret = -EBUSY;
++                      goto stop_clk;
++              }
++
++              info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
++              if (!info->screen_base)
++                      goto release_intmem;
++      } else {
++              /* alocate memory buffer */
++              ret = atmel_lcdfb_alloc_video_memory(sinfo);
++              if (ret < 0) {
++                      dev_err(dev, "cannot allocate framebuffer: %d\n", ret);
++                      goto stop_clk;
++              }
++      }
++
++      /* LCDC registers */
++      info->fix.mmio_start = regs->start;
++      info->fix.mmio_len = regs->end - regs->start + 1;
++
++      if (!request_mem_region(info->fix.mmio_start,
++                              info->fix.mmio_len, pdev->name)) {
++              ret = -EBUSY;
++              goto free_fb;
++      }
++
++      sinfo->mmio = ioremap(info->fix.mmio_start, info->fix.mmio_len);
++      if (!sinfo->mmio) {
++              dev_err(dev, "cannot map LCDC registers\n");
++              goto release_mem;
++      }
++
++      /* interrupt */
++      ret = request_irq(sinfo->irq_base, atmel_lcdfb_interrupt, 0, pdev->name, info);
++      if (ret) {
++              dev_err(dev, "request_irq failed: %d\n", ret);
++              goto unmap_mmio;
++      }
++
++      ret = atmel_lcdfb_init_fbinfo(sinfo);
++      if (ret < 0) {
++              dev_err(dev, "init fbinfo failed: %d\n", ret);
++              goto unregister_irqs;
++      }
++
++      /*
++       * This makes sure that our colour bitfield
++       * descriptors are correctly initialised.
++       */
++      atmel_lcdfb_check_var(&info->var, info);
++
++      ret = fb_set_var(info, &info->var);
++      if (ret) {
++              dev_warn(dev, "unable to set display parameters\n");
++              goto free_cmap;
++      }
++
++      dev_set_drvdata(dev, info);
++
++      /*
++       * Tell the world that we're ready to go
++       */
++      ret = register_framebuffer(info);
++      if (ret < 0) {
++              dev_err(dev, "failed to register framebuffer device: %d\n", ret);
++              goto free_cmap;
++      }
++
++      /* Power up the LCDC screen */
++      if (sinfo->atmel_lcdfb_power_control)
++              sinfo->atmel_lcdfb_power_control(1);
++
++      dev_info(dev, "fb%d: Atmel LCDC at 0x%08lx (mapped at %p), irq %lu\n",
++                     info->node, info->fix.mmio_start, sinfo->mmio, sinfo->irq_base);
++
++      return 0;
++
++
++free_cmap:
++      fb_dealloc_cmap(&info->cmap);
++unregister_irqs:
++      free_irq(sinfo->irq_base, info);
++unmap_mmio:
++      iounmap(sinfo->mmio);
++release_mem:
++      release_mem_region(info->fix.mmio_start, info->fix.mmio_len);
++free_fb:
++      if (map)
++              iounmap(info->screen_base);
++      else
++              atmel_lcdfb_free_video_memory(sinfo);
++
++release_intmem:
++      if (map)
++              release_mem_region(info->fix.smem_start, info->fix.smem_len);
++stop_clk:
++      atmel_lcdfb_stop_clock(sinfo);
++      clk_put(sinfo->lcdc_clk);
++put_bus_clk:
++      if (sinfo->bus_clk)
++              clk_put(sinfo->bus_clk);
++free_info:
++      framebuffer_release(info);
++out:
++      dev_dbg(dev, "%s FAILED\n", __func__);
++      return ret;
++}
++
++static int __exit atmel_lcdfb_remove(struct platform_device *pdev)
++{
++      struct device *dev = &pdev->dev;
++      struct fb_info *info = dev_get_drvdata(dev);
++      struct atmel_lcdfb_info *sinfo = info->par;
++
++      if (!sinfo)
++              return 0;
++
++      if (sinfo->atmel_lcdfb_power_control)
++              sinfo->atmel_lcdfb_power_control(0);
++      unregister_framebuffer(info);
++      atmel_lcdfb_stop_clock(sinfo);
++      clk_put(sinfo->lcdc_clk);
++      if (sinfo->bus_clk)
++              clk_put(sinfo->bus_clk);
++      fb_dealloc_cmap(&info->cmap);
++      free_irq(sinfo->irq_base, info);
++      iounmap(sinfo->mmio);
++      release_mem_region(info->fix.mmio_start, info->fix.mmio_len);
++      if (platform_get_resource(pdev, IORESOURCE_MEM, 1)) {
++              iounmap(info->screen_base);
++              release_mem_region(info->fix.smem_start, info->fix.smem_len);
++      } else {
++              atmel_lcdfb_free_video_memory(sinfo);
++      }
++
++      dev_set_drvdata(dev, NULL);
++      framebuffer_release(info);
++
++      return 0;
++}
++
++static struct platform_driver atmel_lcdfb_driver = {
++      .remove         = __exit_p(atmel_lcdfb_remove),
++      .driver         = {
++              .name   = "atmel_lcdfb",
++              .owner  = THIS_MODULE,
++      },
++};
++
++static int __init atmel_lcdfb_init(void)
++{
++      return platform_driver_probe(&atmel_lcdfb_driver, atmel_lcdfb_probe);
++}
++
++static void __exit atmel_lcdfb_exit(void)
++{
++      platform_driver_unregister(&atmel_lcdfb_driver);
++}
++
++module_init(atmel_lcdfb_init);
++module_exit(atmel_lcdfb_exit);
++
++MODULE_DESCRIPTION("AT91/AT32 LCD Controller framebuffer driver");
++MODULE_AUTHOR("Nicolas Ferre <nicolas.ferre@rfo.atmel.com>");
++MODULE_LICENSE("GPL");
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/video/backlight/Kconfig avr32-git/drivers/video/backlight/Kconfig
+--- linux-2.6.21.3/drivers/video/backlight/Kconfig     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/video/backlight/Kconfig  2007-06-06 11:34:00.000000000 +0200
+@@ -8,26 +8,44 @@
+         Enable this to be able to choose the drivers for controlling the
+         backlight and the LCD panel on some platforms, for example on PDAs.
+-config BACKLIGHT_CLASS_DEVICE
+-        tristate "Lowlevel Backlight controls"
++#
++# LCD
++#
++config LCD_CLASS_DEVICE
++        tristate "Lowlevel LCD controls"
+       depends on BACKLIGHT_LCD_SUPPORT
+       default m
+       help
+-        This framework adds support for low-level control of the LCD
+-          backlight. This includes support for brightness and power.
++        This framework adds support for low-level control of LCD.
++        Some framebuffer devices connect to platform-specific LCD modules
++        in order to have a platform-specific way to control the flat panel
++        (contrast and applying power to the LCD (not to the backlight!)).
+         To have support for your specific LCD panel you will have to
+         select the proper drivers which depend on this option.
+-config LCD_CLASS_DEVICE
+-        tristate "Lowlevel LCD controls"
++config LCD_LTV350QV
++      tristate "Samsung LTV350QV LCD Panel"
++      depends on LCD_CLASS_DEVICE && SPI_MASTER
++      default n
++      help
++        If you have a Samsung LTV350QV LCD panel, say y to include a
++        power control driver for it.  The panel starts up in power
++        off state, so you need this driver in order to see any
++        output.
++
++        The LTV350QV panel is present on all ATSTK1000 boards.
++
++#
++# Backlight
++#
++config BACKLIGHT_CLASS_DEVICE
++        tristate "Lowlevel Backlight controls"
+       depends on BACKLIGHT_LCD_SUPPORT
+       default m
+       help
+-        This framework adds support for low-level control of LCD.
+-        Some framebuffer devices connect to platform-specific LCD modules
+-        in order to have a platform-specific way to control the flat panel
+-        (contrast and applying power to the LCD (not to the backlight!)).
++        This framework adds support for low-level control of the LCD
++          backlight. This includes support for brightness and power.
+         To have support for your specific LCD panel you will have to
+         select the proper drivers which depend on this option.
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/video/backlight/ltv350qv.c avr32-git/drivers/video/backlight/ltv350qv.c
+--- linux-2.6.21.3/drivers/video/backlight/ltv350qv.c  1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/drivers/video/backlight/ltv350qv.c       2007-06-06 11:34:00.000000000 +0200
+@@ -0,0 +1,340 @@
++/*
++ * Power control for Samsung LTV350QV Quarter VGA LCD Panel
++ *
++ * Copyright (C) 2006, 2007 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#include <linux/delay.h>
++#include <linux/err.h>
++#include <linux/fb.h>
++#include <linux/init.h>
++#include <linux/lcd.h>
++#include <linux/module.h>
++#include <linux/spi/spi.h>
++
++#include "ltv350qv.h"
++
++#define POWER_IS_ON(pwr)      ((pwr) <= FB_BLANK_NORMAL)
++
++struct ltv350qv {
++      struct spi_device       *spi;
++      u8                      *buffer;
++      int                     power;
++      struct lcd_device       *ld;
++};
++
++/*
++ * The power-on and power-off sequences are taken from the
++ * LTV350QV-F04 data sheet from Samsung. The register definitions are
++ * taken from the S6F2002 command list also from Samsung. Both
++ * documents are distributed with the AVR32 Linux BSP CD from Atmel.
++ *
++ * There's still some voodoo going on here, but it's a lot better than
++ * in the first incarnation of the driver where all we had was the raw
++ * numbers from the initialization sequence.
++ */
++static int ltv350qv_write_reg(struct ltv350qv *lcd, u8 reg, u16 val)
++{
++      struct spi_message msg;
++      struct spi_transfer index_xfer = {
++              .len            = 3,
++              .cs_change      = 1,
++      };
++      struct spi_transfer value_xfer = {
++              .len            = 3,
++              .cs_change      = 1,
++      };
++
++      spi_message_init(&msg);
++
++      /* register index */
++      lcd->buffer[0] = LTV_OPC_INDEX;
++      lcd->buffer[1] = 0x00;
++      lcd->buffer[2] = reg & 0x7f;
++      index_xfer.tx_buf = lcd->buffer;
++      spi_message_add_tail(&index_xfer, &msg);
++
++      /* register value */
++      lcd->buffer[4] = LTV_OPC_DATA;
++      lcd->buffer[5] = val >> 8;
++      lcd->buffer[6] = val;
++      value_xfer.tx_buf = lcd->buffer + 4;
++      spi_message_add_tail(&value_xfer, &msg);
++
++      return spi_sync(lcd->spi, &msg);
++}
++
++/* The comments are taken straight from the data sheet */
++static int ltv350qv_power_on(struct ltv350qv *lcd)
++{
++      int ret;
++
++      /* Power On Reset Display off State */
++      if (ltv350qv_write_reg(lcd, LTV_PWRCTL1, 0x0000))
++              goto err;
++      msleep(15);
++
++      /* Power Setting Function 1 */
++      if (ltv350qv_write_reg(lcd, LTV_PWRCTL1, LTV_VCOM_DISABLE))
++              goto err;
++      if (ltv350qv_write_reg(lcd, LTV_PWRCTL2, LTV_VCOML_ENABLE))
++              goto err_power1;
++
++      /* Power Setting Function 2 */
++      if (ltv350qv_write_reg(lcd, LTV_PWRCTL1,
++                             LTV_VCOM_DISABLE | LTV_DRIVE_CURRENT(5)
++                             | LTV_SUPPLY_CURRENT(5)))
++              goto err_power2;
++
++      msleep(55);
++
++      /* Instruction Setting */
++      ret = ltv350qv_write_reg(lcd, LTV_IFCTL,
++                               LTV_NMD | LTV_REV | LTV_NL(0x1d));
++      ret |= ltv350qv_write_reg(lcd, LTV_DATACTL,
++                                LTV_DS_SAME | LTV_CHS_480
++                                | LTV_DF_RGB | LTV_RGB_BGR);
++      ret |= ltv350qv_write_reg(lcd, LTV_ENTRY_MODE,
++                                LTV_VSPL_ACTIVE_LOW
++                                | LTV_HSPL_ACTIVE_LOW
++                                | LTV_DPL_SAMPLE_RISING
++                                | LTV_EPL_ACTIVE_LOW
++                                | LTV_SS_RIGHT_TO_LEFT);
++      ret |= ltv350qv_write_reg(lcd, LTV_GATECTL1, LTV_CLW(3));
++      ret |= ltv350qv_write_reg(lcd, LTV_GATECTL2,
++                                LTV_NW_INV_1LINE | LTV_FWI(3));
++      ret |= ltv350qv_write_reg(lcd, LTV_VBP, 0x000a);
++      ret |= ltv350qv_write_reg(lcd, LTV_HBP, 0x0021);
++      ret |= ltv350qv_write_reg(lcd, LTV_SOTCTL, LTV_SDT(3) | LTV_EQ(0));
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(0), 0x0103);
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(1), 0x0301);
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(2), 0x1f0f);
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(3), 0x1f0f);
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(4), 0x0707);
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(5), 0x0307);
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(6), 0x0707);
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(7), 0x0000);
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(8), 0x0004);
++      ret |= ltv350qv_write_reg(lcd, LTV_GAMMA(9), 0x0000);
++      if (ret)
++              goto err_settings;
++
++      /* Wait more than 2 frames */
++      msleep(20);
++
++      /* Display On Sequence */
++      ret = ltv350qv_write_reg(lcd, LTV_PWRCTL1,
++                               LTV_VCOM_DISABLE | LTV_VCOMOUT_ENABLE
++                               | LTV_POWER_ON | LTV_DRIVE_CURRENT(5)
++                               | LTV_SUPPLY_CURRENT(5));
++      ret |= ltv350qv_write_reg(lcd, LTV_GATECTL2,
++                                LTV_NW_INV_1LINE | LTV_DSC | LTV_FWI(3));
++      if (ret)
++              goto err_disp_on;
++
++      /* Display should now be ON. Phew. */
++      return 0;
++
++err_disp_on:
++      /*
++       * Try to recover. Error handling probably isn't very useful
++       * at this point, just make a best effort to switch the panel
++       * off.
++       */
++      ltv350qv_write_reg(lcd, LTV_PWRCTL1,
++                         LTV_VCOM_DISABLE | LTV_DRIVE_CURRENT(5)
++                         | LTV_SUPPLY_CURRENT(5));
++      ltv350qv_write_reg(lcd, LTV_GATECTL2,
++                         LTV_NW_INV_1LINE | LTV_FWI(3));
++err_settings:
++err_power2:
++err_power1:
++      ltv350qv_write_reg(lcd, LTV_PWRCTL2, 0x0000);
++      msleep(1);
++err:
++      ltv350qv_write_reg(lcd, LTV_PWRCTL1, LTV_VCOM_DISABLE);
++      return -EIO;
++}
++
++static int ltv350qv_power_off(struct ltv350qv *lcd)
++{
++      int ret;
++
++      /* Display Off Sequence */
++      ret = ltv350qv_write_reg(lcd, LTV_PWRCTL1,
++                               LTV_VCOM_DISABLE
++                               | LTV_DRIVE_CURRENT(5)
++                               | LTV_SUPPLY_CURRENT(5));
++      ret |= ltv350qv_write_reg(lcd, LTV_GATECTL2,
++                                LTV_NW_INV_1LINE | LTV_FWI(3));
++
++      /* Power down setting 1 */
++      ret |= ltv350qv_write_reg(lcd, LTV_PWRCTL2, 0x0000);
++
++      /* Wait at least 1 ms */
++      msleep(1);
++
++      /* Power down setting 2 */
++      ret |= ltv350qv_write_reg(lcd, LTV_PWRCTL1, LTV_VCOM_DISABLE);
++
++      /*
++       * No point in trying to recover here. If we can't switch the
++       * panel off, what are we supposed to do other than inform the
++       * user about the failure?
++       */
++      if (ret)
++              return -EIO;
++
++      /* Display power should now be OFF */
++      return 0;
++}
++
++static int ltv350qv_power(struct ltv350qv *lcd, int power)
++{
++      int ret = 0;
++
++      if (POWER_IS_ON(power) && !POWER_IS_ON(lcd->power))
++              ret = ltv350qv_power_on(lcd);
++      else if (!POWER_IS_ON(power) && POWER_IS_ON(lcd->power))
++              ret = ltv350qv_power_off(lcd);
++
++      if (!ret)
++              lcd->power = power;
++
++      return ret;
++}
++
++static int ltv350qv_set_power(struct lcd_device *ld, int power)
++{
++      struct ltv350qv *lcd;
++
++      lcd = class_get_devdata(&ld->class_dev);
++      return ltv350qv_power(lcd, power);
++}
++
++static int ltv350qv_get_power(struct lcd_device *ld)
++{
++      struct ltv350qv *lcd;
++
++      lcd = class_get_devdata(&ld->class_dev);
++      return lcd->power;
++}
++
++static struct lcd_ops ltv_ops = {
++      .get_power      = ltv350qv_get_power,
++      .set_power      = ltv350qv_set_power,
++};
++
++static int __devinit ltv350qv_probe(struct spi_device *spi)
++{
++      struct ltv350qv *lcd;
++      struct lcd_device *ld;
++      int ret;
++
++      lcd = kzalloc(sizeof(struct ltv350qv), GFP_KERNEL);
++      if (!lcd)
++              return -ENOMEM;
++
++      lcd->spi = spi;
++      lcd->power = FB_BLANK_POWERDOWN;
++      lcd->buffer = kzalloc(8, GFP_KERNEL);
++
++      ld = lcd_device_register("ltv350qv", lcd, &ltv_ops);
++      if (IS_ERR(ld)) {
++              ret = PTR_ERR(ld);
++              goto out_free_lcd;
++      }
++      lcd->ld = ld;
++
++      ret = ltv350qv_power(lcd, FB_BLANK_UNBLANK);
++      if (ret)
++              goto out_unregister;
++
++      dev_set_drvdata(&spi->dev, lcd);
++
++      return 0;
++
++out_unregister:
++      lcd_device_unregister(ld);
++out_free_lcd:
++      kfree(lcd);
++      return ret;
++}
++
++static int __devexit ltv350qv_remove(struct spi_device *spi)
++{
++      struct ltv350qv *lcd = dev_get_drvdata(&spi->dev);
++
++      ltv350qv_power(lcd, FB_BLANK_POWERDOWN);
++      lcd_device_unregister(lcd->ld);
++      kfree(lcd);
++
++      return 0;
++}
++
++#ifdef CONFIG_PM
++static int ltv350qv_suspend(struct spi_device *spi,
++                          pm_message_t state, u32 level)
++{
++      struct ltv350qv *lcd = dev_get_drvdata(&spi->dev);
++
++      if (level == SUSPEND_POWER_DOWN)
++              return ltv350qv_power(lcd, FB_BLANK_POWERDOWN);
++
++      return 0;
++}
++
++static int ltv350qv_resume(struct spi_device *spi, u32 level)
++{
++      struct ltv350qv *lcd = dev_get_drvdata(&spi->dev);
++
++      if (level == RESUME_POWER_ON)
++              return ltv350qv_power(lcd, FB_BLANK_UNBLANK);
++
++      return 0;
++}
++#else
++#define ltv350qv_suspend      NULL
++#define ltv350qv_resume               NULL
++#endif
++
++/* Power down all displays on reboot, poweroff or halt */
++static void ltv350qv_shutdown(struct spi_device *spi)
++{
++      struct ltv350qv *lcd = dev_get_drvdata(&spi->dev);
++
++      ltv350qv_power(lcd, FB_BLANK_POWERDOWN);
++}
++
++static struct spi_driver ltv350qv_driver = {
++      .driver = {
++              .name           = "ltv350qv",
++              .bus            = &spi_bus_type,
++              .owner          = THIS_MODULE,
++      },
++
++      .probe          = ltv350qv_probe,
++      .remove         = __devexit_p(ltv350qv_remove),
++      .shutdown       = ltv350qv_shutdown,
++      .suspend        = ltv350qv_suspend,
++      .resume         = ltv350qv_resume,
++};
++
++static int __init ltv350qv_init(void)
++{
++      return spi_register_driver(&ltv350qv_driver);
++}
++
++static void __exit ltv350qv_exit(void)
++{
++      spi_unregister_driver(&ltv350qv_driver);
++}
++module_init(ltv350qv_init);
++module_exit(ltv350qv_exit);
++
++MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>");
++MODULE_DESCRIPTION("Samsung LTV350QV LCD Driver");
++MODULE_LICENSE("GPL");
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/video/backlight/ltv350qv.h avr32-git/drivers/video/backlight/ltv350qv.h
+--- linux-2.6.21.3/drivers/video/backlight/ltv350qv.h  1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/drivers/video/backlight/ltv350qv.h       2007-06-06 11:34:00.000000000 +0200
+@@ -0,0 +1,95 @@
++/*
++ * Register definitions for Samsung LTV350QV Quarter VGA LCD Panel
++ *
++ * Copyright (C) 2006, 2007 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#ifndef __LTV350QV_H
++#define __LTV350QV_H
++
++#define LTV_OPC_INDEX 0x74
++#define LTV_OPC_DATA  0x76
++
++#define LTV_ID                0x00            /* ID Read */
++#define LTV_IFCTL     0x01            /* Display Interface Control */
++#define LTV_DATACTL   0x02            /* Display Data Control */
++#define LTV_ENTRY_MODE        0x03            /* Entry Mode */
++#define LTV_GATECTL1  0x04            /* Gate Control 1 */
++#define LTV_GATECTL2  0x05            /* Gate Control 2 */
++#define LTV_VBP               0x06            /* Vertical Back Porch */
++#define LTV_HBP               0x07            /* Horizontal Back Porch */
++#define LTV_SOTCTL    0x08            /* Source Output Timing Control */
++#define LTV_PWRCTL1   0x09            /* Power Control 1 */
++#define LTV_PWRCTL2   0x0a            /* Power Control 2 */
++#define LTV_GAMMA(x)  (0x10 + (x))    /* Gamma control */
++
++/* Bit definitions for LTV_IFCTL */
++#define LTV_IM                        (1 << 15)
++#define LTV_NMD                       (1 << 14)
++#define LTV_SSMD              (1 << 13)
++#define LTV_REV                       (1 <<  7)
++#define LTV_NL(x)             (((x) & 0x001f) << 0)
++
++/* Bit definitions for LTV_DATACTL */
++#define LTV_DS_SAME           (0 << 12)
++#define LTV_DS_D_TO_S         (1 << 12)
++#define LTV_DS_S_TO_D         (2 << 12)
++#define LTV_CHS_384           (0 <<  9)
++#define LTV_CHS_480           (1 <<  9)
++#define LTV_CHS_492           (2 <<  9)
++#define LTV_DF_RGB            (0 <<  6)
++#define LTV_DF_RGBX           (1 <<  6)
++#define LTV_DF_XRGB           (2 <<  6)
++#define LTV_RGB_RGB           (0 <<  2)
++#define LTV_RGB_BGR           (1 <<  2)
++#define LTV_RGB_GRB           (2 <<  2)
++#define LTV_RGB_RBG           (3 <<  2)
++
++/* Bit definitions for LTV_ENTRY_MODE */
++#define LTV_VSPL_ACTIVE_LOW   (0 << 15)
++#define LTV_VSPL_ACTIVE_HIGH  (1 << 15)
++#define LTV_HSPL_ACTIVE_LOW   (0 << 14)
++#define LTV_HSPL_ACTIVE_HIGH  (1 << 14)
++#define LTV_DPL_SAMPLE_RISING (0 << 13)
++#define LTV_DPL_SAMPLE_FALLING        (1 << 13)
++#define LTV_EPL_ACTIVE_LOW    (0 << 12)
++#define LTV_EPL_ACTIVE_HIGH   (1 << 12)
++#define LTV_SS_LEFT_TO_RIGHT  (0 <<  8)
++#define LTV_SS_RIGHT_TO_LEFT  (1 <<  8)
++#define LTV_STB                       (1 <<  1)
++
++/* Bit definitions for LTV_GATECTL1 */
++#define LTV_CLW(x)            (((x) & 0x0007) << 12)
++#define LTV_GAON              (1 <<  5)
++#define LTV_SDR                       (1 <<  3)
++
++/* Bit definitions for LTV_GATECTL2 */
++#define LTV_NW_INV_FRAME      (0 << 14)
++#define LTV_NW_INV_1LINE      (1 << 14)
++#define LTV_NW_INV_2LINE      (2 << 14)
++#define LTV_DSC                       (1 << 12)
++#define LTV_GIF                       (1 <<  8)
++#define LTV_FHN                       (1 <<  7)
++#define LTV_FTI(x)            (((x) & 0x0003) << 4)
++#define LTV_FWI(x)            (((x) & 0x0003) << 0)
++
++/* Bit definitions for LTV_SOTCTL */
++#define LTV_SDT(x)            (((x) & 0x0007) << 10)
++#define LTV_EQ(x)             (((x) & 0x0007) <<  2)
++
++/* Bit definitions for LTV_PWRCTL1 */
++#define LTV_VCOM_DISABLE      (1 << 14)
++#define LTV_VCOMOUT_ENABLE    (1 << 11)
++#define LTV_POWER_ON          (1 <<  9)
++#define LTV_DRIVE_CURRENT(x)  (((x) & 0x0007) << 4)   /* 0=off, 5=max */
++#define LTV_SUPPLY_CURRENT(x) (((x) & 0x0007) << 0)   /* 0=off, 5=max */
++
++/* Bit definitions for LTV_PWRCTL2 */
++#define LTV_VCOML_ENABLE      (1 << 13)
++#define LTV_VCOML_VOLTAGE(x)  (((x) & 0x001f) << 8)   /* 0=1V, 31=-1V */
++#define LTV_VCOMH_VOLTAGE(x)  (((x) & 0x001f) << 0)   /* 0=3V, 31=4.5V */
++
++#endif /* __LTV350QV_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/video/backlight/Makefile avr32-git/drivers/video/backlight/Makefile
+--- linux-2.6.21.3/drivers/video/backlight/Makefile    2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/video/backlight/Makefile 2007-06-06 11:34:00.000000000 +0200
+@@ -1,6 +1,8 @@
+ # Backlight & LCD drivers
+ obj-$(CONFIG_LCD_CLASS_DEVICE)     += lcd.o
++obj-$(CONFIG_LCD_LTV350QV)    += ltv350qv.o
++
+ obj-$(CONFIG_BACKLIGHT_CLASS_DEVICE) += backlight.o
+ obj-$(CONFIG_BACKLIGHT_CORGI) += corgi_bl.o
+ obj-$(CONFIG_BACKLIGHT_HP680) += hp680_bl.o
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/video/fbmem.c avr32-git/drivers/video/fbmem.c
+--- linux-2.6.21.3/drivers/video/fbmem.c       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/video/fbmem.c    2007-06-06 11:34:00.000000000 +0200
+@@ -1198,6 +1198,10 @@
+       pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE;
+ #elif defined(__arm__) || defined(__sh__) || defined(__m32r__)
+       vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
++#elif defined(__avr32__)
++      vma->vm_page_prot = __pgprot((pgprot_val(vma->vm_page_prot)
++                                    & ~_PAGE_CACHABLE)
++                                   | (_PAGE_BUFFER | _PAGE_DIRTY));
+ #elif defined(__ia64__)
+       if (efi_range_is_wc(vma->vm_start, vma->vm_end - vma->vm_start))
+               vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/video/Kconfig avr32-git/drivers/video/Kconfig
+--- linux-2.6.21.3/drivers/video/Kconfig       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/video/Kconfig    2007-06-06 11:34:00.000000000 +0200
+@@ -674,6 +674,22 @@
+         working with S1D13806). Product specs at
+         <http://www.erd.epson.com/vdc/html/legacy_13xxx.htm>
++config FB_ATMEL
++      tristate "AT91/AT32 LCD Controller support"
++      depends on FB && (ARCH_AT91SAM9261 || ARCH_AT91SAM9263 || AVR32)
++      select FB_CFB_FILLRECT
++      select FB_CFB_COPYAREA
++      select FB_CFB_IMAGEBLIT
++      help
++        This enables support for the AT91/AT32 LCD Controller.
++
++config FB_INTSRAM
++      bool "Frame Buffer in internal SRAM"
++      depends on FB_ATMEL && ARCH_AT91SAM9261
++      help
++        Say Y if you want to map Frame Buffer in internal SRAM. Say N if you want
++        to let frame buffer in external SDRAM.
++
+ config FB_NVIDIA
+       tristate "nVidia Framebuffer Support"
+       depends on FB && PCI
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/video/Makefile avr32-git/drivers/video/Makefile
+--- linux-2.6.21.3/drivers/video/Makefile      2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/drivers/video/Makefile   2007-06-06 11:34:00.000000000 +0200
+@@ -75,6 +75,7 @@
+ obj-$(CONFIG_FB_SA1100)           += sa1100fb.o
+ obj-$(CONFIG_FB_HIT)              += hitfb.o
+ obj-$(CONFIG_FB_EPSON1355)      += epson1355fb.o
++obj-$(CONFIG_FB_ATMEL)                  += atmel_lcdfb.o
+ obj-$(CONFIG_FB_PVR2)             += pvr2fb.o
+ obj-$(CONFIG_FB_VOODOO1)          += sstfb.o
+ obj-$(CONFIG_FB_ARMCLCD)        += amba-clcd.o
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-alpha/pgtable.h avr32-git/include/asm-alpha/pgtable.h
+--- linux-2.6.21.3/include/asm-alpha/pgtable.h 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-alpha/pgtable.h      2007-06-06 11:34:07.000000000 +0200
+@@ -345,10 +345,6 @@
+ #define io_remap_pfn_range(vma, start, pfn, size, prot)       \
+               remap_pfn_range(vma, start, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ #define pte_ERROR(e) \
+       printk("%s:%d: bad pte %016lx.\n", __FILE__, __LINE__, pte_val(e))
+ #define pmd_ERROR(e) \
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-alpha/scatterlist.h avr32-git/include/asm-alpha/scatterlist.h
+--- linux-2.6.21.3/include/asm-alpha/scatterlist.h     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-alpha/scatterlist.h  2007-06-06 11:34:07.000000000 +0200
+@@ -2,6 +2,7 @@
+ #define _ALPHA_SCATTERLIST_H
+ #include <asm/page.h>
++#include <asm/types.h>
+   
+ struct scatterlist {
+       struct page *page;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-arm/arch-at91/cpu.h avr32-git/include/asm-arm/arch-at91/cpu.h
+--- linux-2.6.21.3/include/asm-arm/arch-at91/cpu.h     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-arm/arch-at91/cpu.h  2007-06-06 11:34:07.000000000 +0200
+@@ -68,4 +68,10 @@
+ #define cpu_is_at91sam9263()  (0)
+ #endif
++/*
++ * Since this is ARM, we will never run on any AVR32 CPU. But these
++ * definitions may reduce clutter in common drivers.
++ */
++#define cpu_is_at32ap7000()   (0)
++
+ #endif
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-arm/pgtable.h avr32-git/include/asm-arm/pgtable.h
+--- linux-2.6.21.3/include/asm-arm/pgtable.h   2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-arm/pgtable.h        2007-06-06 11:34:10.000000000 +0200
+@@ -395,10 +395,6 @@
+ #define io_remap_pfn_range(vma,from,pfn,size,prot) \
+               remap_pfn_range(vma, from, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ #define pgtable_cache_init() do { } while (0)
+ #endif /* !__ASSEMBLY__ */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-arm/pgtable-nommu.h avr32-git/include/asm-arm/pgtable-nommu.h
+--- linux-2.6.21.3/include/asm-arm/pgtable-nommu.h     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-arm/pgtable-nommu.h  2007-06-06 11:34:10.000000000 +0200
+@@ -83,10 +83,6 @@
+ #define io_remap_page_range   remap_page_range
+ #define io_remap_pfn_range    remap_pfn_range
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ /*
+  * All 32bit addresses are effectively valid for vmalloc...
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-arm26/pgtable.h avr32-git/include/asm-arm26/pgtable.h
+--- linux-2.6.21.3/include/asm-arm26/pgtable.h 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-arm26/pgtable.h      2007-06-06 11:34:10.000000000 +0200
+@@ -297,10 +297,6 @@
+ #define io_remap_pfn_range(vma,from,pfn,size,prot) \
+               remap_pfn_range(vma, from, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ #endif /* !__ASSEMBLY__ */
+ #endif /* _ASMARM_PGTABLE_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/arch-at32ap/board.h avr32-git/include/asm-avr32/arch-at32ap/board.h
+--- linux-2.6.21.3/include/asm-avr32/arch-at32ap/board.h       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/arch-at32ap/board.h    2007-06-06 11:34:10.000000000 +0200
+@@ -6,6 +6,8 @@
+ #include <linux/types.h>
++#define GPIO_PIN_NONE (-1)
++
+ /* Add basic devices: system manager, interrupt controller, portmuxes, etc. */
+ void at32_add_system_devices(void);
+@@ -30,11 +32,22 @@
+ struct platform_device *
+ at32_add_device_spi(unsigned int id, struct spi_board_info *b, unsigned int n);
+-struct lcdc_platform_data {
+-      unsigned long fbmem_start;
+-      unsigned long fbmem_size;
++struct platform_device *at32_add_device_twi(unsigned int id);
++
++struct mci_platform_data {
++      int detect_pin;
++      int wp_pin;
+ };
+ struct platform_device *
+-at32_add_device_lcdc(unsigned int id, struct lcdc_platform_data *data);
++at32_add_device_mci(unsigned int id, struct mci_platform_data *data);
++struct platform_device *at32_add_device_usba(unsigned int id);
++
++struct atmel_lcdfb_info;
++struct platform_device *
++at32_add_device_lcdc(unsigned int id, struct atmel_lcdfb_info *data,
++                   unsigned long fbmem_start, unsigned long fbmem_len);
++
++struct platform_device *at32_add_device_ac97c(unsigned int id);
++struct platform_device *at32_add_device_abdac(unsigned int id);
+ #endif /* __ASM_ARCH_BOARD_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/arch-at32ap/cpu.h avr32-git/include/asm-avr32/arch-at32ap/cpu.h
+--- linux-2.6.21.3/include/asm-avr32/arch-at32ap/cpu.h 1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/include/asm-avr32/arch-at32ap/cpu.h      2007-06-06 11:34:10.000000000 +0200
+@@ -0,0 +1,33 @@
++/*
++ * AVR32 and (fake) AT91 CPU identification
++ *
++ * Copyright (C) 2007 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#ifndef __ASM_ARCH_CPU_H
++#define __ASM_ARCH_CPU_H
++
++/*
++ * Only AT32AP7000 is defined for now. We can identify the specific
++ * chip at runtime, but I'm not sure if it's really worth it.
++ */
++#ifdef CONFIG_CPU_AT32AP7000
++# define cpu_is_at32ap7000()  (1)
++#else
++# define cpu_is_at32ap7000()  (0)
++#endif
++
++/*
++ * Since this is AVR32, we will never run on any AT91 CPU. But these
++ * definitions may reduce clutter in common drivers.
++ */
++#define cpu_is_at91rm9200()   (0)
++#define cpu_is_at91sam9xe()   (0)
++#define cpu_is_at91sam9260()  (0)
++#define cpu_is_at91sam9261()  (0)
++#define cpu_is_at91sam9263()  (0)
++
++#endif /* __ASM_ARCH_CPU_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/arch-at32ap/gpio.h avr32-git/include/asm-avr32/arch-at32ap/gpio.h
+--- linux-2.6.21.3/include/asm-avr32/arch-at32ap/gpio.h        2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/arch-at32ap/gpio.h     2007-06-06 11:34:11.000000000 +0200
+@@ -14,6 +14,8 @@
+ int gpio_get_value(unsigned int gpio);
+ void gpio_set_value(unsigned int gpio, int value);
++#include <asm-generic/gpio.h>         /* cansleep wrappers */
++
+ static inline int gpio_to_irq(unsigned int gpio)
+ {
+       return gpio + GPIO_IRQ_BASE;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/arch-at32ap/io.h avr32-git/include/asm-avr32/arch-at32ap/io.h
+--- linux-2.6.21.3/include/asm-avr32/arch-at32ap/io.h  1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/include/asm-avr32/arch-at32ap/io.h       2007-06-06 11:34:11.000000000 +0200
+@@ -0,0 +1,39 @@
++#ifndef __ASM_AVR32_ARCH_AT32AP_IO_H
++#define __ASM_AVR32_ARCH_AT32AP_IO_H
++
++/* For "bizarre" halfword swapping */
++#include <linux/byteorder/swabb.h>
++
++#if defined(CONFIG_AP7000_32_BIT_SMC)
++# define __swizzle_addr_b(addr)       (addr ^ 3UL)
++# define __swizzle_addr_w(addr)       (addr ^ 2UL)
++# define __swizzle_addr_l(addr)       (addr)
++# define ioswabb(a, x)                (x)
++# define ioswabw(a, x)                (x)
++# define ioswabl(a, x)                (x)
++# define __mem_ioswabb(a, x)  (x)
++# define __mem_ioswabw(a, x)  swab16(x)
++# define __mem_ioswabl(a, x)  swab32(x)
++#elif defined(CONFIG_AP7000_16_BIT_SMC)
++# define __swizzle_addr_b(addr)       (addr ^ 1UL)
++# define __swizzle_addr_w(addr)       (addr)
++# define __swizzle_addr_l(addr)       (addr)
++# define ioswabb(a, x)                (x)
++# define ioswabw(a, x)                (x)
++# define ioswabl(a, x)                swahw32(x)
++# define __mem_ioswabb(a, x)  (x)
++# define __mem_ioswabw(a, x)  swab16(x)
++# define __mem_ioswabl(a, x)  swahb32(x)
++#else
++# define __swizzle_addr_b(addr)       (addr)
++# define __swizzle_addr_w(addr)       (addr)
++# define __swizzle_addr_l(addr)       (addr)
++# define ioswabb(a, x)                (x)
++# define ioswabw(a, x)                swab16(x)
++# define ioswabl(a, x)                swab32(x)
++# define __mem_ioswabb(a, x)  (x)
++# define __mem_ioswabw(a, x)  (x)
++# define __mem_ioswabl(a, x)  (x)
++#endif
++
++#endif /* __ASM_AVR32_ARCH_AT32AP_IO_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/arch-at32ap/smc.h avr32-git/include/asm-avr32/arch-at32ap/smc.h
+--- linux-2.6.21.3/include/asm-avr32/arch-at32ap/smc.h 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/arch-at32ap/smc.h      2007-06-06 11:34:11.000000000 +0200
+@@ -48,10 +48,32 @@
+       unsigned int    nwe_controlled:1;
+       /*
++       * 0: NWAIT is disabled
++       * 1: Reserved
++       * 2: NWAIT is frozen mode
++       * 3: NWAIT in ready mode
++       */
++      unsigned int    nwait_mode:2;
++
++      /*
+        * 0: Byte select access type
+        * 1: Byte write access type
+        */
+       unsigned int    byte_write:1;
++
++      /*
++       * Number of clock cycles before data is released after
++       * the rising edge of the read controlling signal
++       *
++       * Total cycles from SMC is tdf_cycles + 1
++       */
++      unsigned int    tdf_cycles:4;
++
++      /*
++       * 0: TDF optimization disabled
++       * 1: TDF optimization enabled
++       */
++      unsigned int    tdf_mode:1;
+ };
+ extern int smc_set_configuration(int cs, const struct smc_config *config);
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/arch-at32ap/time.h avr32-git/include/asm-avr32/arch-at32ap/time.h
+--- linux-2.6.21.3/include/asm-avr32/arch-at32ap/time.h        1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/include/asm-avr32/arch-at32ap/time.h     2007-06-06 11:34:11.000000000 +0200
+@@ -0,0 +1,112 @@
++/*
++ * Copyright (C) 2007 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++
++#ifndef _ASM_AVR32_ARCH_AT32AP_TIME_H
++#define _ASM_AVR32_ARCH_AT32AP_TIME_H
++
++#include <linux/platform_device.h>
++
++extern struct irqaction timer_irqaction;
++extern struct platform_device at32_systc0_device;
++extern void local_timer_interrupt(int irq, void *dev_id);
++
++#define TIMER_BCR                                     0x000000c0
++#define TIMER_BCR_SYNC                                                 0
++#define TIMER_BMR                                     0x000000c4
++#define TIMER_BMR_TC0XC0S                                      0
++#define TIMER_BMR_TC1XC1S                                      2
++#define TIMER_BMR_TC2XC2S                                      4
++#define TIMER_CCR                                     0x00000000
++#define TIMER_CCR_CLKDIS                                       1
++#define TIMER_CCR_CLKEN                                                0
++#define TIMER_CCR_SWTRG                                                2
++#define TIMER_CMR                                     0x00000004
++#define TIMER_CMR_ABETRG                                      10
++#define TIMER_CMR_ACPA                                                16
++#define TIMER_CMR_ACPC                                                18
++#define TIMER_CMR_AEEVT                                               20
++#define TIMER_CMR_ASWTRG                                      22
++#define TIMER_CMR_BCPB                                                24
++#define TIMER_CMR_BCPC                                                26
++#define TIMER_CMR_BEEVT                                               28
++#define TIMER_CMR_BSWTRG                                      30
++#define TIMER_CMR_BURST                                                4
++#define TIMER_CMR_CLKI                                                 3
++#define TIMER_CMR_CPCDIS                                       7
++#define TIMER_CMR_CPCSTOP                                      6
++#define TIMER_CMR_CPCTRG                                      14
++#define TIMER_CMR_EEVT                                                10
++#define TIMER_CMR_EEVTEDG                                      8
++#define TIMER_CMR_ENETRG                                      12
++#define TIMER_CMR_ETRGEDG                                      8
++#define TIMER_CMR_LDBDIS                                       7
++#define TIMER_CMR_LDBSTOP                                      6
++#define TIMER_CMR_LDRA                                                16
++#define TIMER_CMR_LDRB                                                18
++#define TIMER_CMR_TCCLKS                                       0
++#define TIMER_CMR_WAVE                                                15
++#define TIMER_CMR_WAVSEL                                      13
++#define TIMER_CV                                      0x00000010
++#define TIMER_CV_CV                                            0
++#define TIMER_IDR                                     0x00000028
++#define TIMER_IDR_COVFS                                                0
++#define TIMER_IDR_CPAS                                                 2
++#define TIMER_IDR_CPBS                                                 3
++#define TIMER_IDR_CPCS                                                 4
++#define TIMER_IDR_ETRGS                                                7
++#define TIMER_IDR_LDRAS                                                5
++#define TIMER_IDR_LDRBS                                                6
++#define TIMER_IDR_LOVRS                                                1
++#define TIMER_IER                                     0x00000024
++#define TIMER_IER_COVFS                                                0
++#define TIMER_IER_CPAS                                                 2
++#define TIMER_IER_CPBS                                                 3
++#define TIMER_IER_CPCS                                                 4
++#define TIMER_IER_ETRGS                                                7
++#define TIMER_IER_LDRAS                                                5
++#define TIMER_IER_LDRBS                                                6
++#define TIMER_IER_LOVRS                                                1
++#define TIMER_IMR                                     0x0000002c
++#define TIMER_IMR_COVFS                                                0
++#define TIMER_IMR_CPAS                                                 2
++#define TIMER_IMR_CPBS                                                 3
++#define TIMER_IMR_CPCS                                                 4
++#define TIMER_IMR_ETRGS                                                7
++#define TIMER_IMR_LDRAS                                                5
++#define TIMER_IMR_LDRBS                                                6
++#define TIMER_IMR_LOVRS                                                1
++#define TIMER_RA                                      0x00000014
++#define TIMER_RA_RA                                            0
++#define TIMER_RB                                      0x00000018
++#define TIMER_RB_RB                                            0
++#define TIMER_RC                                      0x0000001c
++#define TIMER_RC_RC                                            0
++#define TIMER_SR                                      0x00000020
++#define TIMER_SR_CLKSTA                                               16
++#define TIMER_SR_COVFS                                                 0
++#define TIMER_SR_CPAS                                          2
++#define TIMER_SR_CPBS                                          3
++#define TIMER_SR_CPCS                                          4
++#define TIMER_SR_ETRGS                                                 7
++#define TIMER_SR_LDRAS                                                 5
++#define TIMER_SR_LDRBS                                                 6
++#define TIMER_SR_LOVRS                                                 1
++#define TIMER_SR_MTIOA                                                17
++#define TIMER_SR_MTIOB                                                18
++
++/* Bit manipulation macros */
++#define TIMER_BIT(name)               (1 << TIMER_##name)
++#define TIMER_BF(name,value)  ((value) << TIMER_##name)
++
++/* Register access macros */
++#define timer_read(port,instance,reg) \
++      __raw_readl(port + (0x40 * instance) + TIMER_##reg)
++#define timer_write(port,instance,reg,value) \
++      __raw_writel((value), port + (0x40 * instance) + TIMER_##reg)
++
++#endif /* _ASM_AVR32_ARCH_AT32AP_TIME_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/atomic.h avr32-git/include/asm-avr32/atomic.h
+--- linux-2.6.21.3/include/asm-avr32/atomic.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/atomic.h       2007-06-06 11:34:11.000000000 +0200
+@@ -173,7 +173,7 @@
+ }
+ #define atomic_xchg(v, new)   (xchg(&((v)->counter), new))
+-#define atomic_cmpxchg(v, o, n)       ((int)cmpxchg(&((v)->counter), (o), (n)))
++#define atomic_cmpxchg(v, o, n)       (cmpxchg(&((v)->counter), (o), (n)))
+ #define atomic_sub(i, v)      (void)atomic_sub_return(i, v)
+ #define atomic_add(i, v)      (void)atomic_add_return(i, v)
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/bug.h avr32-git/include/asm-avr32/bug.h
+--- linux-2.6.21.3/include/asm-avr32/bug.h     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/bug.h  2007-06-06 11:34:11.000000000 +0200
+@@ -18,27 +18,53 @@
+ #ifdef CONFIG_DEBUG_BUGVERBOSE
+-#define BUG()                                                         \
+-      do {                                                            \
+-              asm volatile(".hword    %0\n\t"                         \
+-                           ".hword    %1\n\t"                         \
+-                           ".long     %2"                             \
+-                           :                                          \
+-                           : "n"(AVR32_BUG_OPCODE),                   \
+-                             "i"(__LINE__), "X"(__FILE__));           \
+-      } while (0)
++#define _BUG_OR_WARN(flags)                                           \
++      asm volatile(                                                   \
++              "1:     .hword  %0\n"                                   \
++              "       .section __bug_table,\"a\",@progbits\n"         \
++              "2:     .long   1b\n"                                   \
++              "       .long   %1\n"                                   \
++              "       .short  %2\n"                                   \
++              "       .short  %3\n"                                   \
++              "       .org    2b + %4\n"                              \
++              "       .previous"                                      \
++              :                                                       \
++              : "i"(AVR32_BUG_OPCODE), "i"(__FILE__),                 \
++                "i"(__LINE__), "i"(flags),                            \
++                "i"(sizeof(struct bug_entry)))
+ #else
++#define _BUG_OR_WARN(flags)                                           \
++      asm volatile(                                                   \
++              "1:     .hword  %0\n"                                   \
++              "       .section __bug_table,\"a\",@progbits\n"         \
++              "2:     .long   1b\n"                                   \
++              "       .short  %1\n"                                   \
++              "       .org    2b + %2\n"                              \
++              "       .previous"                                      \
++              :                                                       \
++              : "i"(AVR32_BUG_OPCODE), "i"(flags),                    \
++                "i"(sizeof(struct bug_entry)))
++
++#endif /* CONFIG_DEBUG_BUGVERBOSE */
++
+ #define BUG()                                                         \
+       do {                                                            \
+-              asm volatile(".hword    %0\n\t"                         \
+-                           : : "n"(AVR32_BUG_OPCODE));                \
++              _BUG_OR_WARN(0);                                        \
++              for (;;);                                               \
+       } while (0)
+-#endif /* CONFIG_DEBUG_BUGVERBOSE */
++#define WARN_ON(condition)                                                    \
++      ({                                                              \
++              typeof(condition) __ret_warn_on = (condition);          \
++              if (unlikely(__ret_warn_on))                            \
++                      _BUG_OR_WARN(BUGFLAG_WARNING);                  \
++              unlikely(__ret_warn_on);                                \
++      })
+ #define HAVE_ARCH_BUG
++#define HAVE_ARCH_WARN_ON
+ #endif /* CONFIG_BUG */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/dma-controller.h avr32-git/include/asm-avr32/dma-controller.h
+--- linux-2.6.21.3/include/asm-avr32/dma-controller.h  1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/include/asm-avr32/dma-controller.h       2007-06-06 11:34:11.000000000 +0200
+@@ -0,0 +1,166 @@
++/*
++ * Copyright (C) 2005-2006 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#ifndef __ASM_AVR32_DMA_CONTROLLER_H
++#define __ASM_AVR32_DMA_CONTROLLER_H
++
++#include <linux/device.h>
++
++#define DMA_DIR_MEM_TO_MEM            0x0000
++#define DMA_DIR_MEM_TO_PERIPH         0x0001
++#define DMA_DIR_PERIPH_TO_MEM         0x0002
++#define DMA_DIR_PERIPH_TO_PERIPH      0x0003
++
++#define DMA_WIDTH_8BIT                        0
++#define DMA_WIDTH_16BIT                       1
++#define DMA_WIDTH_32BIT                       2
++
++struct dma_request {
++      struct dma_controller *dmac;
++      struct list_head list;
++
++      unsigned short channel;
++
++      void (*xfer_complete)(struct dma_request *req);
++      void (*block_complete)(struct dma_request *req);
++      void (*error)(struct dma_request *req);
++};
++
++struct dma_request_sg {
++      struct dma_request req;
++
++      int nr_sg;
++      struct scatterlist *sg;
++      unsigned long block_size;
++      unsigned int nr_blocks;
++
++      dma_addr_t data_reg;
++      unsigned short periph_id;
++
++      unsigned char direction;
++      unsigned char width;
++};
++#define to_dma_request_sg(_req)                               \
++      container_of(_req, struct dma_request_sg, req)
++
++struct dma_request_cyclic {
++      struct dma_request req;
++
++        int periods;
++      unsigned long buffer_size;
++
++        dma_addr_t buffer_start;
++      dma_addr_t data_reg;
++
++      unsigned short periph_id;
++      unsigned char direction;
++      unsigned char width;
++
++        void *dev_id;
++};
++#define to_dma_request_cyclic(_req)                           \
++      container_of(_req, struct dma_request_cyclic, req)
++
++struct dma_request_memcpy {
++      struct dma_request req;
++
++      dma_addr_t src_addr;
++      unsigned int src_width;
++      unsigned int src_stride;
++
++      dma_addr_t dst_addr;
++      unsigned int dst_width;
++      unsigned int dst_stride;
++
++      size_t length;
++
++      unsigned short src_reverse:1;
++      unsigned short dst_reverse:1;
++};
++#define to_dma_request_memcpy(_req)                           \
++      container_of(_req, struct dma_request_memcpy, req)
++
++struct dma_controller {
++      struct list_head list;
++      int id;
++      struct device *dev;
++
++      int (*alloc_channel)(struct dma_controller *dmac);
++      void (*release_channel)(struct dma_controller *dmac,
++                              int channel);
++      int (*prepare_request_sg)(struct dma_controller *dmac,
++                                struct dma_request_sg *req);
++        int (*prepare_request_cyclic)(struct dma_controller *dmac,
++                                    struct dma_request_cyclic *req);
++      int (*prepare_request_memcpy)(struct dma_controller *dmac,
++                                    struct dma_request_memcpy *req);
++      int (*start_request)(struct dma_controller *dmac,
++                           unsigned int channel);
++      int (*stop_request)(struct dma_controller *dmac,
++                            unsigned int channel);
++        dma_addr_t (*get_current_pos)(struct dma_controller *dmac,
++                                      unsigned int channel);
++};
++
++static inline int
++dma_alloc_channel(struct dma_controller *dmac)
++{
++      return dmac->alloc_channel(dmac);
++}
++
++static inline void
++dma_release_channel(struct dma_controller *dmac, int chan)
++{
++      dmac->release_channel(dmac, chan);
++}
++
++static inline int
++dma_prepare_request_sg(struct dma_controller *dmac,
++                     struct dma_request_sg *req)
++{
++      return dmac->prepare_request_sg(dmac, req);
++}
++
++static inline int
++dma_prepare_request_cyclic(struct dma_controller *dmac,
++                         struct dma_request_cyclic *req)
++{
++      return dmac->prepare_request_cyclic(dmac, req);
++}
++
++static inline int
++dma_prepare_request_memcpy(struct dma_controller *dmac,
++                         struct dma_request_memcpy *req)
++{
++      return dmac->prepare_request_memcpy(dmac, req);
++}
++
++static inline int
++dma_start_request(struct dma_controller *dmac,
++                unsigned int channel)
++{
++      return dmac->start_request(dmac, channel);
++}
++
++static inline int
++dma_stop_request(struct dma_controller *dmac,
++                 unsigned int channel)
++{
++      return dmac->stop_request(dmac, channel);
++}
++
++static inline dma_addr_t
++dma_get_current_pos(struct dma_controller *dmac,
++                    unsigned int channel)
++{
++      return dmac->get_current_pos(dmac, channel);
++}
++
++extern int register_dma_controller(struct dma_controller *dmac);
++extern struct dma_controller *find_dma_controller(int id);
++
++#endif /* __ASM_AVR32_DMA_CONTROLLER_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/io.h avr32-git/include/asm-avr32/io.h
+--- linux-2.6.21.3/include/asm-avr32/io.h      2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/io.h   2007-06-06 11:34:11.000000000 +0200
+@@ -1,13 +1,15 @@
+ #ifndef __ASM_AVR32_IO_H
+ #define __ASM_AVR32_IO_H
++#include <linux/kernel.h>
+ #include <linux/string.h>
+-
+-#ifdef __KERNEL__
++#include <linux/types.h>
+ #include <asm/addrspace.h>
+ #include <asm/byteorder.h>
++#include <asm/arch/io.h>
++
+ /* virt_to_phys will only work when address is in P1 or P2 */
+ static __inline__ unsigned long virt_to_phys(volatile void *address)
+ {
+@@ -36,104 +38,215 @@
+ extern void __raw_readsw(const void __iomem *addr, void *data, int wordlen);
+ extern void __raw_readsl(const void __iomem *addr, void *data, int longlen);
+-static inline void writeb(unsigned char b, volatile void __iomem *addr)
++static inline void __raw_writeb(u8 v, volatile void __iomem *addr)
+ {
+-      *(volatile unsigned char __force *)addr = b;
++      *(volatile u8 __force *)addr = v;
+ }
+-static inline void writew(unsigned short b, volatile void __iomem *addr)
++static inline void __raw_writew(u16 v, volatile void __iomem *addr)
+ {
+-      *(volatile unsigned short __force *)addr = b;
++      *(volatile u16 __force *)addr = v;
+ }
+-static inline void writel(unsigned int b, volatile void __iomem *addr)
++static inline void __raw_writel(u32 v, volatile void __iomem *addr)
+ {
+-      *(volatile unsigned int __force *)addr = b;
++      *(volatile u32 __force *)addr = v;
+ }
+-#define __raw_writeb writeb
+-#define __raw_writew writew
+-#define __raw_writel writel
+-static inline unsigned char readb(const volatile void __iomem *addr)
++static inline u8 __raw_readb(const volatile void __iomem *addr)
+ {
+-      return *(const volatile unsigned char __force *)addr;
++      return *(const volatile u8 __force *)addr;
+ }
+-static inline unsigned short readw(const volatile void __iomem *addr)
++static inline u16 __raw_readw(const volatile void __iomem *addr)
+ {
+-      return *(const volatile unsigned short __force *)addr;
++      return *(const volatile u16 __force *)addr;
+ }
+-static inline unsigned int readl(const volatile void __iomem *addr)
++static inline u32 __raw_readl(const volatile void __iomem *addr)
+ {
+-      return *(const volatile unsigned int __force *)addr;
++      return *(const volatile u32 __force *)addr;
+ }
+-#define __raw_readb readb
+-#define __raw_readw readw
+-#define __raw_readl readl
+-#define writesb(p, d, l)      __raw_writesb((unsigned int)p, d, l)
+-#define writesw(p, d, l)      __raw_writesw((unsigned int)p, d, l)
+-#define writesl(p, d, l)      __raw_writesl((unsigned int)p, d, l)
++/* Convert I/O port address to virtual address */
++#ifndef __io
++# define __io(p)      ((void *)phys_to_uncached(p))
++#endif
+-#define readsb(p, d, l)               __raw_readsb((unsigned int)p, d, l)
+-#define readsw(p, d, l)               __raw_readsw((unsigned int)p, d, l)
+-#define readsl(p, d, l)               __raw_readsl((unsigned int)p, d, l)
++/*
++ * Not really sure about the best way to slow down I/O on
++ * AVR32. Defining it as a no-op until we have an actual test case.
++ */
++#define SLOW_DOWN_IO  do { } while (0)
++#define __BUILD_MEMORY_SINGLE(pfx, bwl, type)                         \
++static inline void                                                    \
++pfx##write##bwl(type val, volatile void __iomem *addr)                        \
++{                                                                     \
++      volatile type *__addr;                                          \
++      type __val;                                                     \
++                                                                      \
++      __addr = (void *)__swizzle_addr_##bwl((unsigned long)(addr));   \
++      __val = pfx##ioswab##bwl(__addr, val);                          \
++                                                                      \
++      BUILD_BUG_ON(sizeof(type) > sizeof(unsigned long));             \
++                                                                      \
++      *__addr = __val;                                                \
++}                                                                     \
++                                                                      \
++static inline type pfx##read##bwl(const volatile void __iomem *addr)  \
++{                                                                     \
++      volatile type *__addr;                                          \
++      type __val;                                                     \
++                                                                      \
++      __addr = (void *)__swizzle_addr_##bwl((unsigned long)(addr));   \
++                                                                      \
++      BUILD_BUG_ON(sizeof(type) > sizeof(unsigned long));             \
++                                                                      \
++      __val = *__addr;                                                \
++      return pfx##ioswab##bwl(__addr, __val);                         \
++}
++
++#define __BUILD_IOPORT_SINGLE(pfx, bwl, type, p, slow)                        \
++static inline void pfx##out##bwl##p(type val, unsigned long port)     \
++{                                                                     \
++      volatile type *__addr;                                          \
++      type __val;                                                     \
++                                                                      \
++      __addr = __io(__swizzle_addr_##bwl(port));                      \
++      __val = pfx##ioswab##bwl(__addr, val);                          \
++                                                                      \
++      BUILD_BUG_ON(sizeof(type) > sizeof(unsigned long));             \
++                                                                      \
++      *__addr = __val;                                                \
++      slow;                                                           \
++}                                                                     \
++                                                                      \
++static inline type pfx##in##bwl##p(unsigned long port)                        \
++{                                                                     \
++      volatile type *__addr;                                          \
++      type __val;                                                     \
++                                                                      \
++      __addr = __io(__swizzle_addr_##bwl(port));                      \
++                                                                      \
++      BUILD_BUG_ON(sizeof(type) > sizeof(unsigned long));             \
++                                                                      \
++      __val = *__addr;                                                \
++      slow;                                                           \
++                                                                      \
++      return pfx##ioswab##bwl(__addr, __val);                         \
++}
++
++#define __BUILD_MEMORY_PFX(bus, bwl, type)                            \
++      __BUILD_MEMORY_SINGLE(bus, bwl, type)
++
++#define BUILDIO_MEM(bwl, type)                                                \
++      __BUILD_MEMORY_PFX(, bwl, type)                                 \
++      __BUILD_MEMORY_PFX(__mem_, bwl, type)
++
++#define __BUILD_IOPORT_PFX(bus, bwl, type)                            \
++      __BUILD_IOPORT_SINGLE(bus, bwl, type, ,)                        \
++      __BUILD_IOPORT_SINGLE(bus, bwl, type, _p, SLOW_DOWN_IO)
++
++#define BUILDIO_IOPORT(bwl, type)                                     \
++      __BUILD_IOPORT_PFX(, bwl, type)                                 \
++      __BUILD_IOPORT_PFX(__mem_, bwl, type)
++
++BUILDIO_MEM(b, u8)
++BUILDIO_MEM(w, u16)
++BUILDIO_MEM(l, u32)
++
++BUILDIO_IOPORT(b, u8)
++BUILDIO_IOPORT(w, u16)
++BUILDIO_IOPORT(l, u32)
++
++#define readb_relaxed                 readb
++#define readw_relaxed                 readw
++#define readl_relaxed                 readl
++
++#define __BUILD_MEMORY_STRING(bwl, type)                              \
++static inline void writes##bwl(volatile void __iomem *addr,           \
++                             const void *data, unsigned int count)    \
++{                                                                     \
++      const type *__data = data;                                      \
++                                                                      \
++      while (count--)                                                 \
++              __mem_write##bwl(*__data++, addr);                      \
++}                                                                     \
++                                                                      \
++static inline void reads##bwl(const volatile void __iomem *addr,      \
++                            void *data, unsigned int count)           \
++{                                                                     \
++      type *__data = data;                                            \
++                                                                      \
++      while (count--)                                                 \
++              *__data++ = __mem_read##bwl(addr);                      \
++}
++
++#define __BUILD_IOPORT_STRING(bwl, type)                              \
++static inline void outs##bwl(unsigned long port, const void *data,    \
++                           unsigned int count)                        \
++{                                                                     \
++      const type *__data = data;                                      \
++                                                                      \
++      while (count--)                                                 \
++              __mem_out##bwl(*__data++, port);                        \
++}                                                                     \
++                                                                      \
++static inline void ins##bwl(unsigned long port, void *data,           \
++                         unsigned int count)                          \
++{                                                                     \
++      type *__data = data;                                            \
++                                                                      \
++      while (count--)                                                 \
++              *__data++ = __mem_in##bwl(port);                        \
++}
++
++#define BUILDSTRING(bwl, type)                                                \
++      __BUILD_MEMORY_STRING(bwl, type)                                \
++      __BUILD_IOPORT_STRING(bwl, type)
++
++BUILDSTRING(b, u8)
++BUILDSTRING(w, u16)
++BUILDSTRING(l, u32)
+ /*
+  * io{read,write}{8,16,32} macros in both le (for PCI style consumers) and native be
+  */
+ #ifndef ioread8
+-#define ioread8(p)    ({ unsigned int __v = __raw_readb(p); __v; })
++#define ioread8(p)            ((unsigned int)readb(p))
+-#define ioread16(p)   ({ unsigned int __v = le16_to_cpu(__raw_readw(p)); __v; })
+-#define ioread16be(p) ({ unsigned int __v = be16_to_cpu(__raw_readw(p)); __v; })
++#define ioread16(p)           ((unsigned int)readw(p))
++#define ioread16be(p)         ((unsigned int)__raw_readw(p))
+-#define ioread32(p)   ({ unsigned int __v = le32_to_cpu(__raw_readl(p)); __v; })
+-#define ioread32be(p) ({ unsigned int __v = be32_to_cpu(__raw_readl(p)); __v; })
++#define ioread32(p)           ((unsigned int)readl(p))
++#define ioread32be(p)         ((unsigned int)__raw_readl(p))
+-#define iowrite8(v,p) __raw_writeb(v, p)
++#define iowrite8(v,p)         writeb(v, p)
+-#define iowrite16(v,p)        __raw_writew(cpu_to_le16(v), p)
+-#define iowrite16be(v,p)      __raw_writew(cpu_to_be16(v), p)
++#define iowrite16(v,p)                writew(v, p)
++#define iowrite16be(v,p)      __raw_writew(v, p)
+-#define iowrite32(v,p)        __raw_writel(cpu_to_le32(v), p)
+-#define iowrite32be(v,p)      __raw_writel(cpu_to_be32(v), p)
++#define iowrite32(v,p)                writel(v, p)
++#define iowrite32be(v,p)      __raw_writel(v, p)
+-#define ioread8_rep(p,d,c)    __raw_readsb(p,d,c)
+-#define ioread16_rep(p,d,c)   __raw_readsw(p,d,c)
+-#define ioread32_rep(p,d,c)   __raw_readsl(p,d,c)
++#define ioread8_rep(p,d,c)    readsb(p,d,c)
++#define ioread16_rep(p,d,c)   readsw(p,d,c)
++#define ioread32_rep(p,d,c)   readsl(p,d,c)
+-#define iowrite8_rep(p,s,c)   __raw_writesb(p,s,c)
+-#define iowrite16_rep(p,s,c)  __raw_writesw(p,s,c)
+-#define iowrite32_rep(p,s,c)  __raw_writesl(p,s,c)
++#define iowrite8_rep(p,s,c)   writesb(p,s,c)
++#define iowrite16_rep(p,s,c)  writesw(p,s,c)
++#define iowrite32_rep(p,s,c)  writesl(p,s,c)
+ #endif
+-
+-/*
+- * These two are only here because ALSA _thinks_ it needs them...
+- */
+ static inline void memcpy_fromio(void * to, const volatile void __iomem *from,
+                                unsigned long count)
+ {
+-      char *p = to;
+-      while (count) {
+-              count--;
+-              *p = readb(from);
+-              p++;
+-              from++;
+-      }
++      memcpy(to, (const void __force *)from, count);
+ }
+ static inline void  memcpy_toio(volatile void __iomem *to, const void * from,
+                               unsigned long count)
+ {
+-      const char *p = from;
+-      while (count) {
+-              count--;
+-              writeb(*p, to);
+-              p++;
+-              to++;
+-      }
++      memcpy((void __force *)to, from, count);
+ }
+ static inline void memset_io(volatile void __iomem *addr, unsigned char val,
+@@ -142,99 +255,8 @@
+       memset((void __force *)addr, val, count);
+ }
+-/*
+- * Bad read/write accesses...
+- */
+-extern void __readwrite_bug(const char *fn);
+-
+ #define IO_SPACE_LIMIT        0xffffffff
+-/* Convert I/O port address to virtual address */
+-#define __io(p)               ((void __iomem *)phys_to_uncached(p))
+-
+-/*
+- *  IO port access primitives
+- *  -------------------------
+- *
+- * The AVR32 doesn't have special IO access instructions; all IO is memory
+- * mapped. Note that these are defined to perform little endian accesses
+- * only. Their primary purpose is to access PCI and ISA peripherals.
+- *
+- * Note that for a big endian machine, this implies that the following
+- * big endian mode connectivity is in place.
+- *
+- * The machine specific io.h include defines __io to translate an "IO"
+- * address to a memory address.
+- *
+- * Note that we prevent GCC re-ordering or caching values in expressions
+- * by introducing sequence points into the in*() definitions.  Note that
+- * __raw_* do not guarantee this behaviour.
+- *
+- * The {in,out}[bwl] macros are for emulating x86-style PCI/ISA IO space.
+- */
+-#define outb(v, p)            __raw_writeb(v, __io(p))
+-#define outw(v, p)            __raw_writew(cpu_to_le16(v), __io(p))
+-#define outl(v, p)            __raw_writel(cpu_to_le32(v), __io(p))
+-
+-#define inb(p)                        __raw_readb(__io(p))
+-#define inw(p)                        le16_to_cpu(__raw_readw(__io(p)))
+-#define inl(p)                        le32_to_cpu(__raw_readl(__io(p)))
+-
+-static inline void __outsb(unsigned long port, void *addr, unsigned int count)
+-{
+-      while (count--) {
+-              outb(*(u8 *)addr, port);
+-              addr++;
+-      }
+-}
+-
+-static inline void __insb(unsigned long port, void *addr, unsigned int count)
+-{
+-      while (count--) {
+-              *(u8 *)addr = inb(port);
+-              addr++;
+-      }
+-}
+-
+-static inline void __outsw(unsigned long port, void *addr, unsigned int count)
+-{
+-      while (count--) {
+-              outw(*(u16 *)addr, port);
+-              addr += 2;
+-      }
+-}
+-
+-static inline void __insw(unsigned long port, void *addr, unsigned int count)
+-{
+-      while (count--) {
+-              *(u16 *)addr = inw(port);
+-              addr += 2;
+-      }
+-}
+-
+-static inline void __outsl(unsigned long port, void *addr, unsigned int count)
+-{
+-      while (count--) {
+-              outl(*(u32 *)addr, port);
+-              addr += 4;
+-      }
+-}
+-
+-static inline void __insl(unsigned long port, void *addr, unsigned int count)
+-{
+-      while (count--) {
+-              *(u32 *)addr = inl(port);
+-              addr += 4;
+-      }
+-}
+-
+-#define outsb(port, addr, count)      __outsb(port, addr, count)
+-#define insb(port, addr, count)               __insb(port, addr, count)
+-#define outsw(port, addr, count)      __outsw(port, addr, count)
+-#define insw(port, addr, count)               __insw(port, addr, count)
+-#define outsl(port, addr, count)      __outsl(port, addr, count)
+-#define insl(port, addr, count)               __insl(port, addr, count)
+-
+ extern void __iomem *__ioremap(unsigned long offset, size_t size,
+                              unsigned long flags);
+ extern void __iounmap(void __iomem *addr);
+@@ -292,6 +314,4 @@
+  */
+ #define xlate_dev_kmem_ptr(p)   p
+-#endif /* __KERNEL__ */
+-
+ #endif /* __ASM_AVR32_IO_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/kdebug.h avr32-git/include/asm-avr32/kdebug.h
+--- linux-2.6.21.3/include/asm-avr32/kdebug.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/kdebug.h       2007-06-06 11:34:11.000000000 +0200
+@@ -12,16 +12,12 @@
+ int register_die_notifier(struct notifier_block *nb);
+ int unregister_die_notifier(struct notifier_block *nb);
+-int register_page_fault_notifier(struct notifier_block *nb);
+-int unregister_page_fault_notifier(struct notifier_block *nb);
+ extern struct atomic_notifier_head avr32_die_chain;
+ /* Grossly misnamed. */
+ enum die_val {
+-      DIE_FAULT,
+       DIE_BREAKPOINT,
+       DIE_SSTEP,
+-      DIE_PAGE_FAULT,
+ };
+ static inline int notify_die(enum die_val val, struct pt_regs *regs,
+@@ -35,4 +31,18 @@
+       return atomic_notifier_call_chain(&avr32_die_chain, val, &args);
+ }
++/*
++ * These are only here because kprobes.c wants them to implement a
++ * blatant layering violation.  Will hopefully go away soon once all
++ * architectures are updated.
++ */
++static inline int register_page_fault_notifier(struct notifier_block *nb)
++{
++      return 0;
++}
++static inline int unregister_page_fault_notifier(struct notifier_block *nb)
++{
++      return 0;
++}
++
+ #endif /* __ASM_AVR32_KDEBUG_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/kprobes.h avr32-git/include/asm-avr32/kprobes.h
+--- linux-2.6.21.3/include/asm-avr32/kprobes.h 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/kprobes.h      2007-06-06 11:34:11.000000000 +0200
+@@ -26,6 +26,7 @@
+       kprobe_opcode_t insn[MAX_INSN_SIZE];
+ };
++extern int kprobe_fault_handler(struct pt_regs *regs, int trapnr);
+ extern int kprobe_exceptions_notify(struct notifier_block *self,
+                                   unsigned long val, void *data);
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/pgtable.h avr32-git/include/asm-avr32/pgtable.h
+--- linux-2.6.21.3/include/asm-avr32/pgtable.h 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/pgtable.h      2007-06-06 11:34:11.000000000 +0200
+@@ -394,10 +394,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)       \
+       remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ /* No page table caches to initialize (?) */
+ #define pgtable_cache_init()  do { } while(0)
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/processor.h avr32-git/include/asm-avr32/processor.h
+--- linux-2.6.21.3/include/asm-avr32/processor.h       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/processor.h    2007-06-06 11:34:11.000000000 +0200
+@@ -40,6 +40,14 @@
+       TLB_INVALID
+ };
++#define AVR32_FEATURE_RMW     (1 << 0)
++#define AVR32_FEATURE_DSP     (1 << 1)
++#define AVR32_FEATURE_SIMD    (1 << 2)
++#define AVR32_FEATURE_OCD     (1 << 3)
++#define AVR32_FEATURE_PCTR    (1 << 4)
++#define AVR32_FEATURE_JAVA    (1 << 5)
++#define AVR32_FEATURE_FPU     (1 << 6)
++
+ struct avr32_cpuinfo {
+       struct clk *clk;
+       unsigned long loops_per_jiffy;
+@@ -48,6 +56,7 @@
+       unsigned short arch_revision;
+       unsigned short cpu_revision;
+       enum tlb_config tlb_config;
++      unsigned long features;
+       struct cache_info icache;
+       struct cache_info dcache;
+@@ -125,10 +134,10 @@
+ #define thread_saved_pc(tsk)    ((tsk)->thread.cpu_context.pc)
+ struct pt_regs;
+-void show_trace(struct task_struct *task, unsigned long *stack,
+-              struct pt_regs *regs);
+-
+ extern unsigned long get_wchan(struct task_struct *p);
++extern void show_regs_log_lvl(struct pt_regs *regs, const char *log_lvl);
++extern void show_stack_log_lvl(struct task_struct *tsk, unsigned long sp,
++                             struct pt_regs *regs, const char *log_lvl);
+ #define KSTK_EIP(tsk) ((tsk)->thread.cpu_context.pc)
+ #define KSTK_ESP(tsk) ((tsk)->thread.cpu_context.ksp)
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/scatterlist.h avr32-git/include/asm-avr32/scatterlist.h
+--- linux-2.6.21.3/include/asm-avr32/scatterlist.h     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/scatterlist.h  2007-06-06 11:34:11.000000000 +0200
+@@ -1,6 +1,8 @@
+ #ifndef __ASM_AVR32_SCATTERLIST_H
+ #define __ASM_AVR32_SCATTERLIST_H
++#include <asm/types.h>
++
+ struct scatterlist {
+     struct page               *page;
+     unsigned int      offset;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/setup.h avr32-git/include/asm-avr32/setup.h
+--- linux-2.6.21.3/include/asm-avr32/setup.h   2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/setup.h        2007-06-06 11:34:11.000000000 +0200
+@@ -110,7 +110,7 @@
+       int     (*parse)(struct tag *);
+ };
+-#define __tag __attribute_used__ __attribute__((__section__(".taglist")))
++#define __tag __attribute_used__ __attribute__((__section__(".taglist.init")))
+ #define __tagtable(tag, fn)                                           \
+       static struct tagtable __tagtable_##fn __tag = { tag, fn }
+@@ -124,19 +124,12 @@
+ #define for_each_tag(t,base)                                          \
+       for (t = base; t->hdr.size; t = tag_next(t))
+-extern struct tag_mem_range *mem_phys;
+-extern struct tag_mem_range *mem_reserved;
+-extern struct tag_mem_range *mem_ramdisk;
+-
+ extern struct tag *bootloader_tags;
+-extern void setup_bootmem(void);
+-extern void setup_processor(void);
+-extern void board_setup_fbmem(unsigned long fbmem_start,
+-                            unsigned long fbmem_size);
++extern resource_size_t fbmem_start;
++extern resource_size_t fbmem_size;
+-/* Chip-specific hook to enable the use of SDRAM */
+-void chip_enable_sdram(void);
++void setup_processor(void);
+ #endif /* !__ASSEMBLY__ */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/sysreg.h avr32-git/include/asm-avr32/sysreg.h
+--- linux-2.6.21.3/include/asm-avr32/sysreg.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/sysreg.h       2007-06-06 11:34:11.000000000 +0200
+@@ -7,326 +7,281 @@
+  * it under the terms of the GNU General Public License version 2 as
+  * published by the Free Software Foundation.
+  */
+-#ifndef __ASM_AVR32_SYSREG_H__
+-#define __ASM_AVR32_SYSREG_H__
++#ifndef __ASM_AVR32_SYSREG_H
++#define __ASM_AVR32_SYSREG_H
+ /* sysreg register offsets */
+-#define SYSREG_SR                               0x0000
+-#define SYSREG_EVBA                             0x0004
+-#define SYSREG_ACBA                             0x0008
+-#define SYSREG_CPUCR                            0x000c
+-#define SYSREG_ECR                              0x0010
+-#define SYSREG_RSR_SUP                          0x0014
+-#define SYSREG_RSR_INT0                         0x0018
+-#define SYSREG_RSR_INT1                         0x001c
+-#define SYSREG_RSR_INT2                         0x0020
+-#define SYSREG_RSR_INT3                         0x0024
+-#define SYSREG_RSR_EX                           0x0028
+-#define SYSREG_RSR_NMI                          0x002c
+-#define SYSREG_RSR_DBG                          0x0030
+-#define SYSREG_RAR_SUP                          0x0034
+-#define SYSREG_RAR_INT0                         0x0038
+-#define SYSREG_RAR_INT1                         0x003c
+-#define SYSREG_RAR_INT2                         0x0040
+-#define SYSREG_RAR_INT3                         0x0044
+-#define SYSREG_RAR_EX                           0x0048
+-#define SYSREG_RAR_NMI                          0x004c
+-#define SYSREG_RAR_DBG                          0x0050
+-#define SYSREG_JECR                             0x0054
+-#define SYSREG_JOSP                             0x0058
+-#define SYSREG_JAVA_LV0                         0x005c
+-#define SYSREG_JAVA_LV1                         0x0060
+-#define SYSREG_JAVA_LV2                         0x0064
+-#define SYSREG_JAVA_LV3                         0x0068
+-#define SYSREG_JAVA_LV4                         0x006c
+-#define SYSREG_JAVA_LV5                         0x0070
+-#define SYSREG_JAVA_LV6                         0x0074
+-#define SYSREG_JAVA_LV7                         0x0078
+-#define SYSREG_JTBA                             0x007c
+-#define SYSREG_JBCR                             0x0080
+-#define SYSREG_CONFIG0                          0x0100
+-#define SYSREG_CONFIG1                          0x0104
+-#define SYSREG_COUNT                            0x0108
+-#define SYSREG_COMPARE                          0x010c
+-#define SYSREG_TLBEHI                           0x0110
+-#define SYSREG_TLBELO                           0x0114
+-#define SYSREG_PTBR                             0x0118
+-#define SYSREG_TLBEAR                           0x011c
+-#define SYSREG_MMUCR                            0x0120
+-#define SYSREG_TLBARLO                          0x0124
+-#define SYSREG_TLBARHI                          0x0128
+-#define SYSREG_PCCNT                            0x012c
+-#define SYSREG_PCNT0                            0x0130
+-#define SYSREG_PCNT1                            0x0134
+-#define SYSREG_PCCR                             0x0138
+-#define SYSREG_BEAR                             0x013c
++#define SYSREG_SR                             0x0000
++#define SYSREG_EVBA                           0x0004
++#define SYSREG_ACBA                           0x0008
++#define SYSREG_CPUCR                          0x000c
++#define SYSREG_ECR                            0x0010
++#define SYSREG_RSR_SUP                                0x0014
++#define SYSREG_RSR_INT0                               0x0018
++#define SYSREG_RSR_INT1                               0x001c
++#define SYSREG_RSR_INT2                               0x0020
++#define SYSREG_RSR_INT3                               0x0024
++#define SYSREG_RSR_EX                         0x0028
++#define SYSREG_RSR_NMI                                0x002c
++#define SYSREG_RSR_DBG                                0x0030
++#define SYSREG_RAR_SUP                                0x0034
++#define SYSREG_RAR_INT0                               0x0038
++#define SYSREG_RAR_INT1                               0x003c
++#define SYSREG_RAR_INT2                               0x0040
++#define SYSREG_RAR_INT3                               0x0044
++#define SYSREG_RAR_EX                         0x0048
++#define SYSREG_RAR_NMI                                0x004c
++#define SYSREG_RAR_DBG                                0x0050
++#define SYSREG_JECR                           0x0054
++#define SYSREG_JOSP                           0x0058
++#define SYSREG_JAVA_LV0                               0x005c
++#define SYSREG_JAVA_LV1                               0x0060
++#define SYSREG_JAVA_LV2                               0x0064
++#define SYSREG_JAVA_LV3                               0x0068
++#define SYSREG_JAVA_LV4                               0x006c
++#define SYSREG_JAVA_LV5                               0x0070
++#define SYSREG_JAVA_LV6                               0x0074
++#define SYSREG_JAVA_LV7                               0x0078
++#define SYSREG_JTBA                           0x007c
++#define SYSREG_JBCR                           0x0080
++#define SYSREG_CONFIG0                                0x0100
++#define SYSREG_CONFIG1                                0x0104
++#define SYSREG_COUNT                          0x0108
++#define SYSREG_COMPARE                                0x010c
++#define SYSREG_TLBEHI                         0x0110
++#define SYSREG_TLBELO                         0x0114
++#define SYSREG_PTBR                           0x0118
++#define SYSREG_TLBEAR                         0x011c
++#define SYSREG_MMUCR                          0x0120
++#define SYSREG_TLBARLO                                0x0124
++#define SYSREG_TLBARHI                                0x0128
++#define SYSREG_PCCNT                          0x012c
++#define SYSREG_PCNT0                          0x0130
++#define SYSREG_PCNT1                          0x0134
++#define SYSREG_PCCR                           0x0138
++#define SYSREG_BEAR                           0x013c
++#define SYSREG_SABAL                          0x0300
++#define SYSREG_SABAH                          0x0304
++#define SYSREG_SABD                           0x0308
+ /* Bitfields in SR */
+-#define SYSREG_SR_C_OFFSET                      0
+-#define SYSREG_SR_C_SIZE                        1
+-#define SYSREG_Z_OFFSET                         1
+-#define SYSREG_Z_SIZE                           1
+-#define SYSREG_SR_N_OFFSET                      2
+-#define SYSREG_SR_N_SIZE                        1
+-#define SYSREG_SR_V_OFFSET                      3
+-#define SYSREG_SR_V_SIZE                        1
+-#define SYSREG_Q_OFFSET                         4
+-#define SYSREG_Q_SIZE                           1
+-#define SYSREG_GM_OFFSET                        16
+-#define SYSREG_GM_SIZE                          1
+-#define SYSREG_I0M_OFFSET                       17
+-#define SYSREG_I0M_SIZE                         1
+-#define SYSREG_I1M_OFFSET                       18
+-#define SYSREG_I1M_SIZE                         1
+-#define SYSREG_I2M_OFFSET                       19
+-#define SYSREG_I2M_SIZE                         1
+-#define SYSREG_I3M_OFFSET                       20
+-#define SYSREG_I3M_SIZE                         1
+-#define SYSREG_EM_OFFSET                        21
+-#define SYSREG_EM_SIZE                          1
+-#define SYSREG_M0_OFFSET                        22
+-#define SYSREG_M0_SIZE                          1
+-#define SYSREG_M1_OFFSET                        23
+-#define SYSREG_M1_SIZE                          1
+-#define SYSREG_M2_OFFSET                        24
+-#define SYSREG_M2_SIZE                          1
+-#define SYSREG_SR_D_OFFSET                      26
+-#define SYSREG_SR_D_SIZE                        1
+-#define SYSREG_DM_OFFSET                        27
+-#define SYSREG_DM_SIZE                          1
+-#define SYSREG_SR_J_OFFSET                      28
+-#define SYSREG_SR_J_SIZE                        1
+-#define SYSREG_R_OFFSET                         29
+-#define SYSREG_R_SIZE                           1
+-#define SYSREG_H_OFFSET                         30
+-#define SYSREG_H_SIZE                           1
+-
+-/* Bitfields in EVBA */
+-
+-/* Bitfields in ACBA */
++#define SYSREG_SR_C_OFFSET                    0
++#define SYSREG_SR_C_SIZE                      1
++#define SYSREG_Z_OFFSET                               1
++#define SYSREG_Z_SIZE                         1
++#define SYSREG_SR_N_OFFSET                    2
++#define SYSREG_SR_N_SIZE                      1
++#define SYSREG_SR_V_OFFSET                    3
++#define SYSREG_SR_V_SIZE                      1
++#define SYSREG_Q_OFFSET                               4
++#define SYSREG_Q_SIZE                         1
++#define SYSREG_L_OFFSET                               5
++#define SYSREG_L_SIZE                         1
++#define SYSREG_T_OFFSET                               14
++#define SYSREG_T_SIZE                         1
++#define SYSREG_SR_R_OFFSET                    15
++#define SYSREG_SR_R_SIZE                      1
++#define SYSREG_GM_OFFSET                      16
++#define SYSREG_GM_SIZE                                1
++#define SYSREG_I0M_OFFSET                     17
++#define SYSREG_I0M_SIZE                               1
++#define SYSREG_I1M_OFFSET                     18
++#define SYSREG_I1M_SIZE                               1
++#define SYSREG_I2M_OFFSET                     19
++#define SYSREG_I2M_SIZE                               1
++#define SYSREG_I3M_OFFSET                     20
++#define SYSREG_I3M_SIZE                               1
++#define SYSREG_EM_OFFSET                      21
++#define SYSREG_EM_SIZE                                1
++#define SYSREG_M0_OFFSET                      22
++#define SYSREG_M0_SIZE                                1
++#define SYSREG_M1_OFFSET                      23
++#define SYSREG_M1_SIZE                                1
++#define SYSREG_M2_OFFSET                      24
++#define SYSREG_M2_SIZE                                1
++#define SYSREG_SR_D_OFFSET                    26
++#define SYSREG_SR_D_SIZE                      1
++#define SYSREG_DM_OFFSET                      27
++#define SYSREG_DM_SIZE                                1
++#define SYSREG_SR_J_OFFSET                    28
++#define SYSREG_SR_J_SIZE                      1
++#define SYSREG_H_OFFSET                               29
++#define SYSREG_H_SIZE                         1
+ /* Bitfields in CPUCR */
+-#define SYSREG_BI_OFFSET                        0
+-#define SYSREG_BI_SIZE                          1
+-#define SYSREG_BE_OFFSET                        1
+-#define SYSREG_BE_SIZE                          1
+-#define SYSREG_FE_OFFSET                        2
+-#define SYSREG_FE_SIZE                          1
+-#define SYSREG_RE_OFFSET                        3
+-#define SYSREG_RE_SIZE                          1
+-#define SYSREG_IBE_OFFSET                       4
+-#define SYSREG_IBE_SIZE                         1
+-#define SYSREG_IEE_OFFSET                       5
+-#define SYSREG_IEE_SIZE                         1
+-
+-/* Bitfields in ECR */
+-#define SYSREG_ECR_OFFSET                       0
+-#define SYSREG_ECR_SIZE                         32
+-
+-/* Bitfields in RSR_SUP */
+-
+-/* Bitfields in RSR_INT0 */
+-
+-/* Bitfields in RSR_INT1 */
+-
+-/* Bitfields in RSR_INT2 */
+-
+-/* Bitfields in RSR_INT3 */
+-
+-/* Bitfields in RSR_EX */
+-
+-/* Bitfields in RSR_NMI */
+-
+-/* Bitfields in RSR_DBG */
+-
+-/* Bitfields in RAR_SUP */
+-
+-/* Bitfields in RAR_INT0 */
+-
+-/* Bitfields in RAR_INT1 */
+-
+-/* Bitfields in RAR_INT2 */
+-
+-/* Bitfields in RAR_INT3 */
+-
+-/* Bitfields in RAR_EX */
+-
+-/* Bitfields in RAR_NMI */
+-
+-/* Bitfields in RAR_DBG */
+-
+-/* Bitfields in JECR */
+-
+-/* Bitfields in JOSP */
+-
+-/* Bitfields in JAVA_LV0 */
+-
+-/* Bitfields in JAVA_LV1 */
+-
+-/* Bitfields in JAVA_LV2 */
+-
+-/* Bitfields in JAVA_LV3 */
+-
+-/* Bitfields in JAVA_LV4 */
+-
+-/* Bitfields in JAVA_LV5 */
+-
+-/* Bitfields in JAVA_LV6 */
+-
+-/* Bitfields in JAVA_LV7 */
+-
+-/* Bitfields in JTBA */
+-
+-/* Bitfields in JBCR */
++#define SYSREG_BI_OFFSET                      0
++#define SYSREG_BI_SIZE                                1
++#define SYSREG_BE_OFFSET                      1
++#define SYSREG_BE_SIZE                                1
++#define SYSREG_FE_OFFSET                      2
++#define SYSREG_FE_SIZE                                1
++#define SYSREG_RE_OFFSET                      3
++#define SYSREG_RE_SIZE                                1
++#define SYSREG_IBE_OFFSET                     4
++#define SYSREG_IBE_SIZE                               1
++#define SYSREG_IEE_OFFSET                     5
++#define SYSREG_IEE_SIZE                               1
+ /* Bitfields in CONFIG0 */
+-#define SYSREG_CONFIG0_D_OFFSET                 1
+-#define SYSREG_CONFIG0_D_SIZE                   1
+-#define SYSREG_CONFIG0_S_OFFSET                 2
+-#define SYSREG_CONFIG0_S_SIZE                   1
+-#define SYSREG_O_OFFSET                         3
+-#define SYSREG_O_SIZE                           1
+-#define SYSREG_P_OFFSET                         4
+-#define SYSREG_P_SIZE                           1
+-#define SYSREG_CONFIG0_J_OFFSET                 5
+-#define SYSREG_CONFIG0_J_SIZE                   1
+-#define SYSREG_F_OFFSET                         6
+-#define SYSREG_F_SIZE                           1
+-#define SYSREG_MMUT_OFFSET                      7
+-#define SYSREG_MMUT_SIZE                        3
+-#define SYSREG_AR_OFFSET                        10
+-#define SYSREG_AR_SIZE                          3
+-#define SYSREG_AT_OFFSET                        13
+-#define SYSREG_AT_SIZE                          3
+-#define SYSREG_PROCESSORREVISION_OFFSET         16
+-#define SYSREG_PROCESSORREVISION_SIZE           8
+-#define SYSREG_PROCESSORID_OFFSET               24
+-#define SYSREG_PROCESSORID_SIZE                 8
++#define SYSREG_CONFIG0_R_OFFSET                       0
++#define SYSREG_CONFIG0_R_SIZE                 1
++#define SYSREG_CONFIG0_D_OFFSET                       1
++#define SYSREG_CONFIG0_D_SIZE                 1
++#define SYSREG_CONFIG0_S_OFFSET                       2
++#define SYSREG_CONFIG0_S_SIZE                 1
++#define SYSREG_CONFIG0_O_OFFSET                       3
++#define SYSREG_CONFIG0_O_SIZE                 1
++#define SYSREG_CONFIG0_P_OFFSET                       4
++#define SYSREG_CONFIG0_P_SIZE                 1
++#define SYSREG_CONFIG0_J_OFFSET                       5
++#define SYSREG_CONFIG0_J_SIZE                 1
++#define SYSREG_CONFIG0_F_OFFSET                       6
++#define SYSREG_CONFIG0_F_SIZE                 1
++#define SYSREG_MMUT_OFFSET                    7
++#define SYSREG_MMUT_SIZE                      3
++#define SYSREG_AR_OFFSET                      10
++#define SYSREG_AR_SIZE                                3
++#define SYSREG_AT_OFFSET                      13
++#define SYSREG_AT_SIZE                                3
++#define SYSREG_PROCESSORREVISION_OFFSET               16
++#define SYSREG_PROCESSORREVISION_SIZE         8
++#define SYSREG_PROCESSORID_OFFSET             24
++#define SYSREG_PROCESSORID_SIZE                       8
+ /* Bitfields in CONFIG1 */
+-#define SYSREG_DASS_OFFSET                      0
+-#define SYSREG_DASS_SIZE                        3
+-#define SYSREG_DLSZ_OFFSET                      3
+-#define SYSREG_DLSZ_SIZE                        3
+-#define SYSREG_DSET_OFFSET                      6
+-#define SYSREG_DSET_SIZE                        4
+-#define SYSREG_IASS_OFFSET                      10
+-#define SYSREG_IASS_SIZE                        2
+-#define SYSREG_ILSZ_OFFSET                      13
+-#define SYSREG_ILSZ_SIZE                        3
+-#define SYSREG_ISET_OFFSET                      16
+-#define SYSREG_ISET_SIZE                        4
+-#define SYSREG_DMMUSZ_OFFSET                    20
+-#define SYSREG_DMMUSZ_SIZE                      6
+-#define SYSREG_IMMUSZ_OFFSET                    26
+-#define SYSREG_IMMUSZ_SIZE                      6
+-
+-/* Bitfields in COUNT */
+-
+-/* Bitfields in COMPARE */
++#define SYSREG_DASS_OFFSET                    0
++#define SYSREG_DASS_SIZE                      3
++#define SYSREG_DLSZ_OFFSET                    3
++#define SYSREG_DLSZ_SIZE                      3
++#define SYSREG_DSET_OFFSET                    6
++#define SYSREG_DSET_SIZE                      4
++#define SYSREG_IASS_OFFSET                    10
++#define SYSREG_IASS_SIZE                      3
++#define SYSREG_ILSZ_OFFSET                    13
++#define SYSREG_ILSZ_SIZE                      3
++#define SYSREG_ISET_OFFSET                    16
++#define SYSREG_ISET_SIZE                      4
++#define SYSREG_DMMUSZ_OFFSET                  20
++#define SYSREG_DMMUSZ_SIZE                    6
++#define SYSREG_IMMUSZ_OFFSET                  26
++#define SYSREG_IMMUSZ_SIZE                    6
+ /* Bitfields in TLBEHI */
+-#define SYSREG_ASID_OFFSET                      0
+-#define SYSREG_ASID_SIZE                        8
+-#define SYSREG_TLBEHI_I_OFFSET                  8
+-#define SYSREG_TLBEHI_I_SIZE                    1
+-#define SYSREG_TLBEHI_V_OFFSET                  9
+-#define SYSREG_TLBEHI_V_SIZE                    1
+-#define SYSREG_VPN_OFFSET                       10
+-#define SYSREG_VPN_SIZE                         22
++#define SYSREG_ASID_OFFSET                    0
++#define SYSREG_ASID_SIZE                      8
++#define SYSREG_TLBEHI_I_OFFSET                        8
++#define SYSREG_TLBEHI_I_SIZE                  1
++#define SYSREG_TLBEHI_V_OFFSET                        9
++#define SYSREG_TLBEHI_V_SIZE                  1
++#define SYSREG_VPN_OFFSET                     10
++#define SYSREG_VPN_SIZE                               22
+ /* Bitfields in TLBELO */
+-#define SYSREG_W_OFFSET                         0
+-#define SYSREG_W_SIZE                           1
+-#define SYSREG_TLBELO_D_OFFSET                  1
+-#define SYSREG_TLBELO_D_SIZE                    1
+-#define SYSREG_SZ_OFFSET                        2
+-#define SYSREG_SZ_SIZE                          2
+-#define SYSREG_AP_OFFSET                        4
+-#define SYSREG_AP_SIZE                          3
+-#define SYSREG_B_OFFSET                         7
+-#define SYSREG_B_SIZE                           1
+-#define SYSREG_G_OFFSET                         8
+-#define SYSREG_G_SIZE                           1
+-#define SYSREG_TLBELO_C_OFFSET                  9
+-#define SYSREG_TLBELO_C_SIZE                    1
+-#define SYSREG_PFN_OFFSET                       10
+-#define SYSREG_PFN_SIZE                         22
+-
+-/* Bitfields in PTBR */
+-
+-/* Bitfields in TLBEAR */
++#define SYSREG_W_OFFSET                               0
++#define SYSREG_W_SIZE                         1
++#define SYSREG_TLBELO_D_OFFSET                        1
++#define SYSREG_TLBELO_D_SIZE                  1
++#define SYSREG_SZ_OFFSET                      2
++#define SYSREG_SZ_SIZE                                2
++#define SYSREG_AP_OFFSET                      4
++#define SYSREG_AP_SIZE                                3
++#define SYSREG_B_OFFSET                               7
++#define SYSREG_B_SIZE                         1
++#define SYSREG_G_OFFSET                               8
++#define SYSREG_G_SIZE                         1
++#define SYSREG_TLBELO_C_OFFSET                        9
++#define SYSREG_TLBELO_C_SIZE                  1
++#define SYSREG_PFN_OFFSET                     10
++#define SYSREG_PFN_SIZE                               22
+ /* Bitfields in MMUCR */
+-#define SYSREG_E_OFFSET                         0
+-#define SYSREG_E_SIZE                           1
+-#define SYSREG_M_OFFSET                         1
+-#define SYSREG_M_SIZE                           1
+-#define SYSREG_MMUCR_I_OFFSET                   2
+-#define SYSREG_MMUCR_I_SIZE                     1
+-#define SYSREG_MMUCR_N_OFFSET                   3
+-#define SYSREG_MMUCR_N_SIZE                     1
+-#define SYSREG_MMUCR_S_OFFSET                   4
+-#define SYSREG_MMUCR_S_SIZE                     1
+-#define SYSREG_DLA_OFFSET                       8
+-#define SYSREG_DLA_SIZE                         6
+-#define SYSREG_DRP_OFFSET                       14
+-#define SYSREG_DRP_SIZE                         6
+-#define SYSREG_ILA_OFFSET                       20
+-#define SYSREG_ILA_SIZE                         6
+-#define SYSREG_IRP_OFFSET                       26
+-#define SYSREG_IRP_SIZE                         6
+-
+-/* Bitfields in TLBARLO */
+-
+-/* Bitfields in TLBARHI */
+-
+-/* Bitfields in PCCNT */
+-
+-/* Bitfields in PCNT0 */
+-
+-/* Bitfields in PCNT1 */
++#define SYSREG_E_OFFSET                               0
++#define SYSREG_E_SIZE                         1
++#define SYSREG_M_OFFSET                               1
++#define SYSREG_M_SIZE                         1
++#define SYSREG_MMUCR_I_OFFSET                 2
++#define SYSREG_MMUCR_I_SIZE                   1
++#define SYSREG_MMUCR_N_OFFSET                 3
++#define SYSREG_MMUCR_N_SIZE                   1
++#define SYSREG_MMUCR_S_OFFSET                 4
++#define SYSREG_MMUCR_S_SIZE                   1
++#define SYSREG_DLA_OFFSET                     8
++#define SYSREG_DLA_SIZE                               6
++#define SYSREG_DRP_OFFSET                     14
++#define SYSREG_DRP_SIZE                               6
++#define SYSREG_ILA_OFFSET                     20
++#define SYSREG_ILA_SIZE                               6
++#define SYSREG_IRP_OFFSET                     26
++#define SYSREG_IRP_SIZE                               6
+ /* Bitfields in PCCR */
+-
+-/* Bitfields in BEAR */
++#define SYSREG_PCCR_R_OFFSET                  1
++#define SYSREG_PCCR_R_SIZE                    1
++#define SYSREG_PCCR_C_OFFSET                  2
++#define SYSREG_PCCR_C_SIZE                    1
++#define SYSREG_PCCR_S_OFFSET                  3
++#define SYSREG_PCCR_S_SIZE                    1
++#define SYSREG_IEC_OFFSET                     4
++#define SYSREG_IEC_SIZE                               1
++#define SYSREG_IE0_OFFSET                     5
++#define SYSREG_IE0_SIZE                               1
++#define SYSREG_IE1_OFFSET                     6
++#define SYSREG_IE1_SIZE                               1
++#define SYSREG_FC_OFFSET                      8
++#define SYSREG_FC_SIZE                                1
++#define SYSREG_F0_OFFSET                      9
++#define SYSREG_F0_SIZE                                1
++#define SYSREG_F1_OFFSET                      10
++#define SYSREG_F1_SIZE                                1
++#define SYSREG_CONF0_OFFSET                   12
++#define SYSREG_CONF0_SIZE                     6
++#define SYSREG_CONF1_OFFSET                   18
++#define SYSREG_CONF1_SIZE                     6
+ /* Constants for ECR */
+-#define ECR_UNRECOVERABLE                       0
+-#define ECR_TLB_MULTIPLE                        1
+-#define ECR_BUS_ERROR_WRITE                     2
+-#define ECR_BUS_ERROR_READ                      3
+-#define ECR_NMI                                 4
+-#define ECR_ADDR_ALIGN_X                        5
+-#define ECR_PROTECTION_X                        6
+-#define ECR_DEBUG                               7
+-#define ECR_ILLEGAL_OPCODE                      8
+-#define ECR_UNIMPL_INSTRUCTION                  9
+-#define ECR_PRIVILEGE_VIOLATION                 10
+-#define ECR_FPE                                 11
+-#define ECR_COPROC_ABSENT                       12
+-#define ECR_ADDR_ALIGN_R                        13
+-#define ECR_ADDR_ALIGN_W                        14
+-#define ECR_PROTECTION_R                        15
+-#define ECR_PROTECTION_W                        16
+-#define ECR_DTLB_MODIFIED                       17
+-#define ECR_TLB_MISS_X                          20
+-#define ECR_TLB_MISS_R                          24
+-#define ECR_TLB_MISS_W                          28
++#define ECR_UNRECOVERABLE                     0
++#define ECR_TLB_MULTIPLE                      1
++#define ECR_BUS_ERROR_WRITE                   2
++#define ECR_BUS_ERROR_READ                    3
++#define ECR_NMI                                       4
++#define ECR_ADDR_ALIGN_X                      5
++#define ECR_PROTECTION_X                      6
++#define ECR_DEBUG                             7
++#define ECR_ILLEGAL_OPCODE                    8
++#define ECR_UNIMPL_INSTRUCTION                        9
++#define ECR_PRIVILEGE_VIOLATION                       10
++#define ECR_FPE                                       11
++#define ECR_COPROC_ABSENT                     12
++#define ECR_ADDR_ALIGN_R                      13
++#define ECR_ADDR_ALIGN_W                      14
++#define ECR_PROTECTION_R                      15
++#define ECR_PROTECTION_W                      16
++#define ECR_DTLB_MODIFIED                     17
++#define ECR_TLB_MISS_X                                20
++#define ECR_TLB_MISS_R                                24
++#define ECR_TLB_MISS_W                                28
+ /* Bit manipulation macros */
+-#define SYSREG_BIT(name)                        (1 << SYSREG_##name##_OFFSET)
+-#define SYSREG_BF(name,value)                   (((value) & ((1 << SYSREG_##name##_SIZE) - 1)) << SYSREG_##name##_OFFSET)
+-#define SYSREG_BFEXT(name,value)                (((value) >> SYSREG_##name##_OFFSET) & ((1 << SYSREG_##name##_SIZE) - 1))
+-#define SYSREG_BFINS(name,value,old)            (((old) & ~(((1 << SYSREG_##name##_SIZE) - 1) << SYSREG_##name##_OFFSET)) | SYSREG_BF(name,value))
++#define SYSREG_BIT(name)                              \
++      (1 << SYSREG_##name##_OFFSET)
++#define SYSREG_BF(name,value)                         \
++      (((value) & ((1 << SYSREG_##name##_SIZE) - 1))  \
++       << SYSREG_##name##_OFFSET)
++#define SYSREG_BFEXT(name,value)\
++      (((value) >> SYSREG_##name##_OFFSET)            \
++       & ((1 << SYSREG_##name##_SIZE) - 1))
++#define SYSREG_BFINS(name,value,old)                  \
++      (((old) & ~(((1 << SYSREG_##name##_SIZE) - 1)   \
++                  << SYSREG_##name##_OFFSET))         \
++       | SYSREG_BF(name,value))
++/* Register access macros */
+ #ifdef __CHECKER__
+ extern unsigned long __builtin_mfsr(unsigned long reg);
+ extern void __builtin_mtsr(unsigned long reg, unsigned long value);
+ #endif
+-/* Register access macros */
+-#define sysreg_read(reg)                        __builtin_mfsr(SYSREG_##reg)
+-#define sysreg_write(reg, value)                __builtin_mtsr(SYSREG_##reg, value)
++#define sysreg_read(reg)              __builtin_mfsr(SYSREG_##reg)
++#define sysreg_write(reg, value)      __builtin_mtsr(SYSREG_##reg, value)
+-#endif /* __ASM_AVR32_SYSREG_H__ */
++#endif /* __ASM_AVR32_SYSREG_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/system.h avr32-git/include/asm-avr32/system.h
+--- linux-2.6.21.3/include/asm-avr32/system.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/system.h       2007-06-06 11:34:11.000000000 +0200
+@@ -9,6 +9,7 @@
+ #define __ASM_AVR32_SYSTEM_H
+ #include <linux/compiler.h>
++#include <linux/linkage.h>
+ #include <linux/types.h>
+ #include <asm/ptrace.h>
+@@ -140,15 +141,9 @@
+                                  sizeof(*(ptr))))
+ struct pt_regs;
+-extern void __die(const char *, struct pt_regs *, unsigned long,
+-                const char *, const char *, unsigned long);
+-extern void __die_if_kernel(const char *, struct pt_regs *, unsigned long,
+-                          const char *, const char *, unsigned long);
+-
+-#define die(msg, regs, err)                                   \
+-      __die(msg, regs, err, __FILE__ ":", __FUNCTION__, __LINE__)
+-#define die_if_kernel(msg, regs, err)                                 \
+-      __die_if_kernel(msg, regs, err, __FILE__ ":", __FUNCTION__, __LINE__)
++void NORET_TYPE die(const char *str, struct pt_regs *regs, long err);
++void _exception(long signr, struct pt_regs *regs, int code,
++              unsigned long addr);
+ #define arch_align_stack(x)   (x)
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/thread_info.h avr32-git/include/asm-avr32/thread_info.h
+--- linux-2.6.21.3/include/asm-avr32/thread_info.h     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/thread_info.h  2007-06-06 11:34:11.000000000 +0200
+@@ -83,6 +83,7 @@
+ #define TIF_SINGLE_STEP               6       /* single step after next break */
+ #define TIF_MEMDIE            7
+ #define TIF_RESTORE_SIGMASK   8       /* restore signal mask in do_signal */
++#define TIF_CPU_GOING_TO_SLEEP        9       /* CPU is entering sleep 0 mode */
+ #define TIF_USERSPACE         31      /* true if FS sets userspace */
+ #define _TIF_SYSCALL_TRACE    (1 << TIF_SYSCALL_TRACE)
+@@ -94,6 +95,7 @@
+ #define _TIF_SINGLE_STEP      (1 << TIF_SINGLE_STEP)
+ #define _TIF_MEMDIE           (1 << TIF_MEMDIE)
+ #define _TIF_RESTORE_SIGMASK  (1 << TIF_RESTORE_SIGMASK)
++#define _TIF_CPU_GOING_TO_SLEEP (1 << TIF_CPU_GOING_TO_SLEEP)
+ /* XXX: These two masks must never span more than 16 bits! */
+ /* work to do on interrupt/exception return */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/uaccess.h avr32-git/include/asm-avr32/uaccess.h
+--- linux-2.6.21.3/include/asm-avr32/uaccess.h 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/uaccess.h      2007-06-06 11:34:11.000000000 +0200
+@@ -181,24 +181,23 @@
+ #define __get_user_nocheck(x, ptr, size)                              \
+ ({                                                                    \
+-      typeof(*(ptr)) __gu_val = (typeof(*(ptr)) __force)0;            \
++      unsigned long __gu_val = 0;                                     \
+       int __gu_err = 0;                                               \
+                                                                       \
+       switch (size) {                                                 \
+       case 1: __get_user_asm("ub", __gu_val, ptr, __gu_err); break;   \
+       case 2: __get_user_asm("uh", __gu_val, ptr, __gu_err); break;   \
+       case 4: __get_user_asm("w", __gu_val, ptr, __gu_err); break;    \
+-      case 8: __get_user_asm("d", __gu_val, ptr, __gu_err); break;    \
+       default: __gu_err = __get_user_bad(); break;                    \
+       }                                                               \
+                                                                       \
+-      x = __gu_val;                                                   \
++      x = (typeof(*(ptr)))__gu_val;                                   \
+       __gu_err;                                                       \
+ })
+ #define __get_user_check(x, ptr, size)                                        \
+ ({                                                                    \
+-      typeof(*(ptr)) __gu_val = (typeof(*(ptr)) __force)0;            \
++      unsigned long __gu_val = 0;                                     \
+       const typeof(*(ptr)) __user * __gu_addr = (ptr);                \
+       int __gu_err = 0;                                               \
+                                                                       \
+@@ -216,10 +215,6 @@
+                       __get_user_asm("w", __gu_val, __gu_addr,        \
+                                      __gu_err);                       \
+                       break;                                          \
+-              case 8:                                                 \
+-                      __get_user_asm("d", __gu_val, __gu_addr,        \
+-                                     __gu_err);                       \
+-                      break;                                          \
+               default:                                                \
+                       __gu_err = __get_user_bad();                    \
+                       break;                                          \
+@@ -227,7 +222,7 @@
+       } else {                                                        \
+               __gu_err = -EFAULT;                                     \
+       }                                                               \
+-      x = __gu_val;                                                   \
++      x = (typeof(*(ptr)))__gu_val;                                   \
+       __gu_err;                                                       \
+ })
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-avr32/unaligned.h avr32-git/include/asm-avr32/unaligned.h
+--- linux-2.6.21.3/include/asm-avr32/unaligned.h       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-avr32/unaligned.h    2007-06-06 11:34:11.000000000 +0200
+@@ -6,20 +6,31 @@
+  * implementation.  The AVR32 AP implementation can handle unaligned
+  * words, but halfwords must be halfword-aligned, and doublewords must
+  * be word-aligned.
+- *
+- * TODO: Make all this CPU-specific and optimize.
+  */
+-#include <linux/string.h>
++#include <asm-generic/unaligned.h>
+-/* Use memmove here, so gcc does not insert a __builtin_memcpy. */
++#ifdef CONFIG_CPU_AT32AP7000
++/* REVISIT calling memmove() may be smaller for 64-bit values ... */
++
++#undef get_unaligned
+ #define get_unaligned(ptr) \
+-  ({ __typeof__(*(ptr)) __tmp; memmove(&__tmp, (ptr), sizeof(*(ptr))); __tmp; })
++      ___get_unaligned(ptr, sizeof((*ptr)))
++#define ___get_unaligned(ptr, size) \
++      ((size == 4) ? *(ptr) : __get_unaligned(ptr, size))
++
++#undef put_unaligned
++#define put_unaligned(val, ptr) \
++      ___put_unaligned((__u64)(val), ptr, sizeof((*ptr)))
++#define ___put_unaligned(val, ptr, size)              \
++do {                                                  \
++      if (size == 4)                                  \
++              *(ptr) = (val);                         \
++      else                                            \
++              __put_unaligned(val, ptr, size);        \
++} while (0)
+-#define put_unaligned(val, ptr)                               \
+-  ({ __typeof__(*(ptr)) __tmp = (val);                        \
+-     memmove((ptr), &__tmp, sizeof(*(ptr)));          \
+-     (void)0; })
++#endif
+ #endif /* __ASM_AVR32_UNALIGNED_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-frv/pgtable.h avr32-git/include/asm-frv/pgtable.h
+--- linux-2.6.21.3/include/asm-frv/pgtable.h   2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-frv/pgtable.h        2007-06-06 11:34:11.000000000 +0200
+@@ -509,10 +509,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)               \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
+ #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY
+ #define __HAVE_ARCH_PTEP_GET_AND_CLEAR
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-frv/scatterlist.h avr32-git/include/asm-frv/scatterlist.h
+--- linux-2.6.21.3/include/asm-frv/scatterlist.h       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-frv/scatterlist.h    2007-06-06 11:34:11.000000000 +0200
+@@ -1,6 +1,8 @@
+ #ifndef _ASM_SCATTERLIST_H
+ #define _ASM_SCATTERLIST_H
++#include <asm/types.h>
++
+ /*
+  * Drivers must set either ->address or (preferred) ->page and ->offset
+  * to indicate where data must be transferred to/from.
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-h8300/pgtable.h avr32-git/include/asm-h8300/pgtable.h
+--- linux-2.6.21.3/include/asm-h8300/pgtable.h 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-h8300/pgtable.h      2007-06-06 11:34:12.000000000 +0200
+@@ -55,10 +55,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)               \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ /*
+  * All 32bit addresses are effectively valid for vmalloc...
+  * Sort of meaningless for non-VM targets.
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-h8300/scatterlist.h avr32-git/include/asm-h8300/scatterlist.h
+--- linux-2.6.21.3/include/asm-h8300/scatterlist.h     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-h8300/scatterlist.h  2007-06-06 11:34:12.000000000 +0200
+@@ -1,6 +1,8 @@
+ #ifndef _H8300_SCATTERLIST_H
+ #define _H8300_SCATTERLIST_H
++#include <asm/types.h>
++
+ struct scatterlist {
+       struct page     *page;
+       unsigned int    offset;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-i386/pgtable.h avr32-git/include/asm-i386/pgtable.h
+--- linux-2.6.21.3/include/asm-i386/pgtable.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-i386/pgtable.h       2007-06-06 11:34:12.000000000 +0200
+@@ -519,10 +519,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)               \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ #include <asm-generic/pgtable.h>
+ #endif /* _I386_PGTABLE_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-i386/scatterlist.h avr32-git/include/asm-i386/scatterlist.h
+--- linux-2.6.21.3/include/asm-i386/scatterlist.h      2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-i386/scatterlist.h   2007-06-06 11:34:12.000000000 +0200
+@@ -1,6 +1,8 @@
+ #ifndef _I386_SCATTERLIST_H
+ #define _I386_SCATTERLIST_H
++#include <asm/types.h>
++
+ struct scatterlist {
+     struct page               *page;
+     unsigned int      offset;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-ia64/pgtable.h avr32-git/include/asm-ia64/pgtable.h
+--- linux-2.6.21.3/include/asm-ia64/pgtable.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-ia64/pgtable.h       2007-06-06 11:34:12.000000000 +0200
+@@ -485,10 +485,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)               \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ /*
+  * ZERO_PAGE is a global shared page that is always zero: used
+  * for zero-mapped memory areas etc..
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-ia64/scatterlist.h avr32-git/include/asm-ia64/scatterlist.h
+--- linux-2.6.21.3/include/asm-ia64/scatterlist.h      2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-ia64/scatterlist.h   2007-06-06 11:34:12.000000000 +0200
+@@ -6,6 +6,8 @@
+  *    David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
+  */
++#include <asm/types.h>
++
+ struct scatterlist {
+       struct page *page;
+       unsigned int offset;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-m32r/pgtable.h avr32-git/include/asm-m32r/pgtable.h
+--- linux-2.6.21.3/include/asm-m32r/pgtable.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-m32r/pgtable.h       2007-06-06 11:34:12.000000000 +0200
+@@ -381,10 +381,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)       \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
+ #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY
+ #define __HAVE_ARCH_PTEP_GET_AND_CLEAR
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-m32r/scatterlist.h avr32-git/include/asm-m32r/scatterlist.h
+--- linux-2.6.21.3/include/asm-m32r/scatterlist.h      2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-m32r/scatterlist.h   2007-06-06 11:34:12.000000000 +0200
+@@ -1,6 +1,8 @@
+ #ifndef _ASM_M32R_SCATTERLIST_H
+ #define _ASM_M32R_SCATTERLIST_H
++#include <asm/types.h>
++
+ struct scatterlist {
+     char *  address;    /* Location data is to be transferred to, NULL for
+                          * highmem page */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-m68k/pgtable.h avr32-git/include/asm-m68k/pgtable.h
+--- linux-2.6.21.3/include/asm-m68k/pgtable.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-m68k/pgtable.h       2007-06-06 11:34:12.000000000 +0200
+@@ -143,10 +143,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)               \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ /* MMU-specific headers */
+ #ifdef CONFIG_SUN3
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-m68knommu/pgtable.h avr32-git/include/asm-m68knommu/pgtable.h
+--- linux-2.6.21.3/include/asm-m68knommu/pgtable.h     2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-m68knommu/pgtable.h  2007-06-06 11:34:12.000000000 +0200
+@@ -59,10 +59,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)               \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ /*
+  * All 32bit addresses are effectively valid for vmalloc...
+  * Sort of meaningless for non-VM targets.
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-m68knommu/scatterlist.h avr32-git/include/asm-m68knommu/scatterlist.h
+--- linux-2.6.21.3/include/asm-m68knommu/scatterlist.h 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-m68knommu/scatterlist.h      2007-06-06 11:34:12.000000000 +0200
+@@ -2,6 +2,7 @@
+ #define _M68KNOMMU_SCATTERLIST_H
+ #include <linux/mm.h>
++#include <asm/types.h>
+ struct scatterlist {
+       struct page     *page;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-mips/pgtable.h avr32-git/include/asm-mips/pgtable.h
+--- linux-2.6.21.3/include/asm-mips/pgtable.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-mips/pgtable.h       2007-06-06 11:34:12.000000000 +0200
+@@ -387,10 +387,6 @@
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+ #endif
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ #include <asm-generic/pgtable.h>
+ /*
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-mips/scatterlist.h avr32-git/include/asm-mips/scatterlist.h
+--- linux-2.6.21.3/include/asm-mips/scatterlist.h      2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-mips/scatterlist.h   2007-06-06 11:34:12.000000000 +0200
+@@ -1,6 +1,8 @@
+ #ifndef __ASM_SCATTERLIST_H
+ #define __ASM_SCATTERLIST_H
++#include <asm/types.h>
++
+ struct scatterlist {
+       struct page *   page;
+       unsigned int    offset;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-parisc/pgtable.h avr32-git/include/asm-parisc/pgtable.h
+--- linux-2.6.21.3/include/asm-parisc/pgtable.h        2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-parisc/pgtable.h     2007-06-06 11:34:12.000000000 +0200
+@@ -528,10 +528,6 @@
+ #define pgprot_noncached(prot) __pgprot(pgprot_val(prot) | _PAGE_NO_CACHE)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ /* We provide our own get_unmapped_area to provide cache coherency */
+ #define HAVE_ARCH_UNMAPPED_AREA
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-parisc/scatterlist.h avr32-git/include/asm-parisc/scatterlist.h
+--- linux-2.6.21.3/include/asm-parisc/scatterlist.h    2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-parisc/scatterlist.h 2007-06-06 11:34:12.000000000 +0200
+@@ -2,6 +2,7 @@
+ #define _ASM_PARISC_SCATTERLIST_H
+ #include <asm/page.h>
++#include <asm/types.h>
+ struct scatterlist {
+       struct page *page;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-ppc/pgtable.h avr32-git/include/asm-ppc/pgtable.h
+--- linux-2.6.21.3/include/asm-ppc/pgtable.h   2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-ppc/pgtable.h        2007-06-06 11:34:13.000000000 +0200
+@@ -827,10 +827,6 @@
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+ #endif
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ /*
+  * No page table caches to initialise
+  */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-sh/pgtable.h avr32-git/include/asm-sh/pgtable.h
+--- linux-2.6.21.3/include/asm-sh/pgtable.h    2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-sh/pgtable.h 2007-06-06 11:34:13.000000000 +0200
+@@ -568,10 +568,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)               \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ struct mm_struct;
+ /*
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-sh/scatterlist.h avr32-git/include/asm-sh/scatterlist.h
+--- linux-2.6.21.3/include/asm-sh/scatterlist.h        2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-sh/scatterlist.h     2007-06-06 11:34:13.000000000 +0200
+@@ -1,6 +1,8 @@
+ #ifndef __ASM_SH_SCATTERLIST_H
+ #define __ASM_SH_SCATTERLIST_H
++#include <asm/types.h>
++
+ struct scatterlist {
+     struct page * page; /* Location for highmem page, if any */
+     unsigned int offset;/* for highmem, page offset */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-sh64/pgtable.h avr32-git/include/asm-sh64/pgtable.h
+--- linux-2.6.21.3/include/asm-sh64/pgtable.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-sh64/pgtable.h       2007-06-06 11:34:13.000000000 +0200
+@@ -485,10 +485,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)               \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ #endif /* !__ASSEMBLY__ */
+ /*
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-sh64/scatterlist.h avr32-git/include/asm-sh64/scatterlist.h
+--- linux-2.6.21.3/include/asm-sh64/scatterlist.h      2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-sh64/scatterlist.h   2007-06-06 11:34:13.000000000 +0200
+@@ -11,6 +11,8 @@
+ #ifndef __ASM_SH64_SCATTERLIST_H
+ #define __ASM_SH64_SCATTERLIST_H
++#include <asm/types.h>
++
+ struct scatterlist {
+     struct page * page; /* Location for highmem page, if any */
+     unsigned int offset;/* for highmem, page offset */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-sparc64/scatterlist.h avr32-git/include/asm-sparc64/scatterlist.h
+--- linux-2.6.21.3/include/asm-sparc64/scatterlist.h   2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-sparc64/scatterlist.h        2007-06-06 11:34:13.000000000 +0200
+@@ -3,6 +3,7 @@
+ #define _SPARC64_SCATTERLIST_H
+ #include <asm/page.h>
++#include <asm/types.h>
+ struct scatterlist {
+       struct page     *page;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-v850/scatterlist.h avr32-git/include/asm-v850/scatterlist.h
+--- linux-2.6.21.3/include/asm-v850/scatterlist.h      2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-v850/scatterlist.h   2007-06-06 11:34:13.000000000 +0200
+@@ -14,6 +14,8 @@
+ #ifndef __V850_SCATTERLIST_H__
+ #define __V850_SCATTERLIST_H__
++#include <asm/types.h>
++
+ struct scatterlist {
+       struct page     *page;
+       unsigned        offset;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-x86_64/pgtable.h avr32-git/include/asm-x86_64/pgtable.h
+--- linux-2.6.21.3/include/asm-x86_64/pgtable.h        2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-x86_64/pgtable.h     2007-06-06 11:34:13.000000000 +0200
+@@ -413,10 +413,6 @@
+ #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)               \
+               remap_pfn_range(vma, vaddr, pfn, size, prot)
+-#define MK_IOSPACE_PFN(space, pfn)    (pfn)
+-#define GET_IOSPACE(pfn)              0
+-#define GET_PFN(pfn)                  (pfn)
+-
+ #define HAVE_ARCH_UNMAPPED_AREA
+ #define pgtable_cache_init()   do { } while (0)
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-x86_64/scatterlist.h avr32-git/include/asm-x86_64/scatterlist.h
+--- linux-2.6.21.3/include/asm-x86_64/scatterlist.h    2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-x86_64/scatterlist.h 2007-06-06 11:34:13.000000000 +0200
+@@ -1,6 +1,8 @@
+ #ifndef _X8664_SCATTERLIST_H
+ #define _X8664_SCATTERLIST_H
++#include <asm/types.h>
++
+ struct scatterlist {
+     struct page               *page;
+     unsigned int      offset;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/asm-xtensa/scatterlist.h avr32-git/include/asm-xtensa/scatterlist.h
+--- linux-2.6.21.3/include/asm-xtensa/scatterlist.h    2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/asm-xtensa/scatterlist.h 2007-06-06 11:34:13.000000000 +0200
+@@ -11,6 +11,8 @@
+ #ifndef _XTENSA_SCATTERLIST_H
+ #define _XTENSA_SCATTERLIST_H
++#include <asm/types.h>
++
+ struct scatterlist {
+       struct page     *page;
+       unsigned int    offset;
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/linux/fb.h avr32-git/include/linux/fb.h
+--- linux-2.6.21.3/include/linux/fb.h  2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/include/linux/fb.h       2007-06-06 11:34:13.000000000 +0200
+@@ -833,7 +833,7 @@
+ #define fb_writeq sbus_writeq
+ #define fb_memset sbus_memset_io
+-#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || (defined(__sh__) && !defined(__SH5__)) || defined(__powerpc__)
++#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || (defined(__sh__) && !defined(__SH5__)) || defined(__powerpc__) || defined(__avr32__)
+ #define fb_readb __raw_readb
+ #define fb_readw __raw_readw
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/linux/i2c-gpio.h avr32-git/include/linux/i2c-gpio.h
+--- linux-2.6.21.3/include/linux/i2c-gpio.h    1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/include/linux/i2c-gpio.h 2007-06-06 11:34:13.000000000 +0200
+@@ -0,0 +1,38 @@
++/*
++ * i2c-gpio interface to platform code
++ *
++ * Copyright (C) 2007 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#ifndef _LINUX_I2C_GPIO_H
++#define _LINUX_I2C_GPIO_H
++
++/**
++ * struct i2c_gpio_platform_data - Platform-dependent data for i2c-gpio
++ * @sda_pin: GPIO pin ID to use for SDA
++ * @scl_pin: GPIO pin ID to use for SCL
++ * @udelay: signal toggle delay. SCL frequency is (500 / udelay) kHz
++ * @timeout: clock stretching timeout in jiffies. If the slave keeps
++ *    SCL low for longer than this, the transfer will time out.
++ * @sda_is_open_drain: SDA is configured as open drain, i.e. the pin
++ *    isn't actively driven high when setting the output value high.
++ *    gpio_get_value() must return the actual pin state even if the
++ *    pin is configured as an output.
++ * @scl_is_open_drain: SCL is set up as open drain. Same requirements
++ *    as for sda_is_open_drain apply.
++ * @scl_is_output_only: SCL output drivers cannot be turned off.
++ */
++struct i2c_gpio_platform_data {
++      unsigned int    sda_pin;
++      unsigned int    scl_pin;
++      int             udelay;
++      int             timeout;
++      unsigned int    sda_is_open_drain:1;
++      unsigned int    scl_is_open_drain:1;
++      unsigned int    scl_is_output_only:1;
++};
++
++#endif /* _LINUX_I2C_GPIO_H */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/include/video/atmel_lcdc.h avr32-git/include/video/atmel_lcdc.h
+--- linux-2.6.21.3/include/video/atmel_lcdc.h  1970-01-01 01:00:00.000000000 +0100
++++ avr32-git/include/video/atmel_lcdc.h       2007-06-06 11:34:13.000000000 +0200
+@@ -0,0 +1,196 @@
++/*
++ *  Header file for AT91/AT32 LCD Controller
++ *
++ *  Data structure and register user interface
++ *
++ *  Copyright (C) 2007 Atmel Corporation
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
++ */
++#ifndef __ATMEL_LCDC_H__
++#define __ATMEL_LCDC_H__
++
++ /* LCD Controller info data structure */
++struct atmel_lcdfb_info {
++      spinlock_t              lock;
++      struct fb_info          *info;
++      void __iomem            *mmio;
++      unsigned long           irq_base;
++
++      unsigned int            guard_time;
++      struct platform_device  *pdev;
++      struct clk              *bus_clk;
++      struct clk              *lcdc_clk;
++      unsigned int            default_bpp;
++      unsigned int            default_lcdcon2;
++      unsigned int            default_dmacon;
++      void (*atmel_lcdfb_power_control)(int on);
++      struct fb_monspecs      *default_monspecs;
++      u32                     pseudo_palette[16];
++};
++
++#define ATMEL_LCDC_DMABADDR1  0x00
++#define ATMEL_LCDC_DMABADDR2  0x04
++#define ATMEL_LCDC_DMAFRMPT1  0x08
++#define ATMEL_LCDC_DMAFRMPT2  0x0c
++#define ATMEL_LCDC_DMAFRMADD1 0x10
++#define ATMEL_LCDC_DMAFRMADD2 0x14
++
++#define ATMEL_LCDC_DMAFRMCFG  0x18
++#define       ATMEL_LCDC_FRSIZE       (0x7fffff <<  0)
++#define       ATMEL_LCDC_BLENGTH_OFFSET       24
++#define       ATMEL_LCDC_BLENGTH      (0x7f     << ATMEL_LCDC_BLENGTH_OFFSET)
++
++#define ATMEL_LCDC_DMACON     0x1c
++#define       ATMEL_LCDC_DMAEN        (0x1 << 0)
++#define       ATMEL_LCDC_DMARST       (0x1 << 1)
++#define       ATMEL_LCDC_DMABUSY      (0x1 << 2)
++#define               ATMEL_LCDC_DMAUPDT      (0x1 << 3)
++#define               ATMEL_LCDC_DMA2DEN      (0x1 << 4)
++
++#define ATMEL_LCDC_DMA2DCFG   0x20
++#define               ATMEL_LCDC_ADDRINC_OFFSET       0
++#define               ATMEL_LCDC_ADDRINC              (0xffff)
++#define               ATMEL_LCDC_PIXELOFF_OFFSET      24
++#define               ATMEL_LCDC_PIXELOFF             (0x1f << 24)
++
++#define ATMEL_LCDC_LCDCON1    0x0800
++#define       ATMEL_LCDC_BYPASS       (1     <<  0)
++#define       ATMEL_LCDC_CLKVAL_OFFSET        12
++#define       ATMEL_LCDC_CLKVAL       (0x1ff << ATMEL_LCDC_CLKVAL_OFFSET)
++#define       ATMEL_LCDC_LINCNT       (0x7ff << 21)
++
++#define ATMEL_LCDC_LCDCON2    0x0804
++#define       ATMEL_LCDC_DISTYPE      (3 << 0)
++#define               ATMEL_LCDC_DISTYPE_STNMONO      (0 << 0)
++#define               ATMEL_LCDC_DISTYPE_STNCOLOR     (1 << 0)
++#define               ATMEL_LCDC_DISTYPE_TFT          (2 << 0)
++#define       ATMEL_LCDC_SCANMOD      (1 << 2)
++#define               ATMEL_LCDC_SCANMOD_SINGLE       (0 << 2)
++#define               ATMEL_LCDC_SCANMOD_DUAL         (1 << 2)
++#define       ATMEL_LCDC_IFWIDTH      (3 << 3)
++#define               ATMEL_LCDC_IFWIDTH_4            (0 << 3)
++#define               ATMEL_LCDC_IFWIDTH_8            (1 << 3)
++#define               ATMEL_LCDC_IFWIDTH_16           (2 << 3)
++#define       ATMEL_LCDC_PIXELSIZE    (7 << 5)
++#define               ATMEL_LCDC_PIXELSIZE_1          (0 << 5)
++#define               ATMEL_LCDC_PIXELSIZE_2          (1 << 5)
++#define               ATMEL_LCDC_PIXELSIZE_4          (2 << 5)
++#define               ATMEL_LCDC_PIXELSIZE_8          (3 << 5)
++#define               ATMEL_LCDC_PIXELSIZE_16         (4 << 5)
++#define               ATMEL_LCDC_PIXELSIZE_24         (5 << 5)
++#define               ATMEL_LCDC_PIXELSIZE_32         (6 << 5)
++#define       ATMEL_LCDC_INVVD        (1 << 8)
++#define               ATMEL_LCDC_INVVD_NORMAL         (0 << 8)
++#define               ATMEL_LCDC_INVVD_INVERTED       (1 << 8)
++#define       ATMEL_LCDC_INVFRAME     (1 << 9 )
++#define               ATMEL_LCDC_INVFRAME_NORMAL      (0 << 9)
++#define               ATMEL_LCDC_INVFRAME_INVERTED    (1 << 9)
++#define       ATMEL_LCDC_INVLINE      (1 << 10)
++#define               ATMEL_LCDC_INVLINE_NORMAL       (0 << 10)
++#define               ATMEL_LCDC_INVLINE_INVERTED     (1 << 10)
++#define       ATMEL_LCDC_INVCLK       (1 << 11)
++#define               ATMEL_LCDC_INVCLK_NORMAL        (0 << 11)
++#define               ATMEL_LCDC_INVCLK_INVERTED      (1 << 11)
++#define       ATMEL_LCDC_INVDVAL      (1 << 12)
++#define               ATMEL_LCDC_INVDVAL_NORMAL       (0 << 12)
++#define               ATMEL_LCDC_INVDVAL_INVERTED     (1 << 12)
++#define       ATMEL_LCDC_CLKMOD       (1 << 15)
++#define               ATMEL_LCDC_CLKMOD_ACTIVEDISPLAY (0 << 15)
++#define               ATMEL_LCDC_CLKMOD_ALWAYSACTIVE  (1 << 15)
++#define       ATMEL_LCDC_MEMOR        (1 << 31)
++#define               ATMEL_LCDC_MEMOR_BIG            (0 << 31)
++#define               ATMEL_LCDC_MEMOR_LITTLE         (1 << 31)
++
++#define ATMEL_LCDC_TIM1               0x0808
++#define       ATMEL_LCDC_VFP          (0xff <<  0)
++#define       ATMEL_LCDC_VBP_OFFSET           8
++#define       ATMEL_LCDC_VBP          (0xff <<  ATMEL_LCDC_VBP_OFFSET)
++#define       ATMEL_LCDC_VPW_OFFSET           16
++#define       ATMEL_LCDC_VPW          (0x3f << ATMEL_LCDC_VPW_OFFSET)
++#define       ATMEL_LCDC_VHDLY_OFFSET         24
++#define       ATMEL_LCDC_VHDLY        (0xf  << ATMEL_LCDC_VHDLY_OFFSET)
++
++#define ATMEL_LCDC_TIM2               0x080c
++#define       ATMEL_LCDC_HBP          (0xff  <<  0)
++#define       ATMEL_LCDC_HPW_OFFSET           8
++#define       ATMEL_LCDC_HPW          (0x3f  <<  ATMEL_LCDC_HPW_OFFSET)
++#define       ATMEL_LCDC_HFP_OFFSET           21
++#define       ATMEL_LCDC_HFP          (0x7ff << ATMEL_LCDC_HFP_OFFSET)
++
++#define ATMEL_LCDC_LCDFRMCFG  0x0810
++#define       ATMEL_LCDC_LINEVAL      (0x7ff <<  0)
++#define       ATMEL_LCDC_HOZVAL_OFFSET        21
++#define       ATMEL_LCDC_HOZVAL       (0x7ff << ATMEL_LCDC_HOZVAL_OFFSET)
++
++#define ATMEL_LCDC_FIFO               0x0814
++#define       ATMEL_LCDC_FIFOTH       (0xffff)
++
++#define ATMEL_LCDC_MVAL               0x0818
++
++#define ATMEL_LCDC_DP1_2      0x081c
++#define ATMEL_LCDC_DP4_7      0x0820
++#define ATMEL_LCDC_DP3_5      0x0824
++#define ATMEL_LCDC_DP2_3      0x0828
++#define ATMEL_LCDC_DP5_7      0x082c
++#define ATMEL_LCDC_DP3_4      0x0830
++#define ATMEL_LCDC_DP4_5      0x0834
++#define ATMEL_LCDC_DP6_7      0x0838
++#define       ATMEL_LCDC_DP1_2_VAL    (0xff)
++#define       ATMEL_LCDC_DP4_7_VAL    (0xfffffff)
++#define       ATMEL_LCDC_DP3_5_VAL    (0xfffff)
++#define       ATMEL_LCDC_DP2_3_VAL    (0xfff)
++#define       ATMEL_LCDC_DP5_7_VAL    (0xfffffff)
++#define       ATMEL_LCDC_DP3_4_VAL    (0xffff)
++#define       ATMEL_LCDC_DP4_5_VAL    (0xfffff)
++#define       ATMEL_LCDC_DP6_7_VAL    (0xfffffff)
++
++#define ATMEL_LCDC_PWRCON     0x083c
++#define       ATMEL_LCDC_PWR          (1    <<  0)
++#define       ATMEL_LCDC_GUARDT_OFFSET        1
++#define       ATMEL_LCDC_GUARDT       (0x7f <<  ATMEL_LCDC_GUARDT_OFFSET)
++#define       ATMEL_LCDC_BUSY         (1    << 31)
++
++#define ATMEL_LCDC_CONTRAST_CTR       0x0840
++#define       ATMEL_LCDC_PS           (3 << 0)
++#define               ATMEL_LCDC_PS_DIV1              (0 << 0)
++#define               ATMEL_LCDC_PS_DIV2              (1 << 0)
++#define               ATMEL_LCDC_PS_DIV4              (2 << 0)
++#define               ATMEL_LCDC_PS_DIV8              (3 << 0)
++#define       ATMEL_LCDC_POL          (1 << 2)
++#define               ATMEL_LCDC_POL_NEGATIVE         (0 << 2)
++#define               ATMEL_LCDC_POL_POSITIVE         (1 << 2)
++#define       ATMEL_LCDC_ENA          (1 << 3)
++#define               ATMEL_LCDC_ENA_PWMDISABLE       (0 << 3)
++#define               ATMEL_LCDC_ENA_PWMENABLE        (1 << 3)
++
++#define ATMEL_LCDC_CONTRAST_VAL       0x0844
++#define       ATMEL_LCDC_CVAL (0xff)
++
++#define ATMEL_LCDC_IER                0x0848
++#define ATMEL_LCDC_IDR                0x084c
++#define ATMEL_LCDC_IMR                0x0850
++#define ATMEL_LCDC_ISR                0x0854
++#define ATMEL_LCDC_ICR                0x0858
++#define       ATMEL_LCDC_LNI          (1 << 0)
++#define       ATMEL_LCDC_LSTLNI       (1 << 1)
++#define       ATMEL_LCDC_EOFI         (1 << 2)
++#define       ATMEL_LCDC_UFLWI        (1 << 4)
++#define       ATMEL_LCDC_OWRI         (1 << 5)
++#define       ATMEL_LCDC_MERI         (1 << 6)
++
++#define ATMEL_LCDC_LUT(n)     (0x0c00 + ((n)*4))
++
++#endif /* __ATMEL_LCDC_H__ */
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/MAINTAINERS avr32-git/MAINTAINERS
+--- linux-2.6.21.3/MAINTAINERS 2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/MAINTAINERS      2007-06-06 11:33:46.000000000 +0200
+@@ -1434,6 +1434,11 @@
+ W:    http://www.icp-vortex.com/
+ S:    Supported
++GENERIC GPIO I2C DRIVER
++P:    Haavard Skinnemoen
++M:    hskinnemoen@atmel.com
++S:    Supported
++
+ GENERIC HDLC DRIVER, N2, C101, PCI200SYN and WANXL DRIVERS
+ P:    Krzysztof Halasa
+ M:    khc@pm.waw.pl
+diff -Nur -x .gitignore -x .git linux-2.6.21.3/scripts/checkstack.pl avr32-git/scripts/checkstack.pl
+--- linux-2.6.21.3/scripts/checkstack.pl       2007-05-24 23:22:47.000000000 +0200
++++ avr32-git/scripts/checkstack.pl    2007-06-06 11:34:14.000000000 +0200
+@@ -12,6 +12,7 @@
+ #     sh64 port by Paul Mundt
+ #     Random bits by Matt Mackall <mpm@selenic.com>
+ #     M68k port by Geert Uytterhoeven and Andreas Schwab
++#     AVR32 port by Haavard Skinnemoen <hskinnemoen@atmel.com>
+ #
+ #     Usage:
+ #     objdump -d vmlinux | stackcheck.pl [arch]
+@@ -37,6 +38,10 @@
+       if ($arch eq 'arm') {
+               #c0008ffc:      e24dd064        sub     sp, sp, #100    ; 0x64
+               $re = qr/.*sub.*sp, sp, #(([0-9]{2}|[3-9])[0-9]{2})/o;
++      } elsif ($arch eq 'avr32') {
++              #8000008a:       20 1d           sub sp,4
++              #80000ca8:       fa cd 05 b0     sub sp,sp,1456
++              $re = qr/^.*sub.*sp.*,([0-9]{1,8})/o;
+       } elsif ($arch =~ /^i[3456]86$/) {
+               #c0105234:       81 ec ac 05 00 00       sub    $0x5ac,%esp
+               $re = qr/^.*[as][du][db]    \$(0x$x{1,8}),\%esp$/o;
diff --git a/target/linux/avr32-2.6/patches/110-openwrt_flashmap.patch b/target/linux/avr32-2.6/patches/110-openwrt_flashmap.patch
new file mode 100644 (file)
index 0000000..610a59e
--- /dev/null
@@ -0,0 +1,20 @@
+diff -Nur linux-2.6.21.3/arch/avr32/boards/atngw100/flash.c linux-2.6.21.3-owrt/arch/avr32/boards/atngw100/flash.c
+--- linux-2.6.21.3/arch/avr32/boards/atngw100/flash.c  2007-06-07 18:34:04.000000000 +0200
++++ linux-2.6.21.3-owrt/arch/avr32/boards/atngw100/flash.c     2007-06-07 18:36:02.000000000 +0200
+@@ -43,9 +43,14 @@
+               .mask_flags     = MTD_WRITEABLE,
+       },
+       {
+-              .name           = "root",
++              .name           = "kernel",
+               .offset         = 0x00020000,
+-              .size           = 0x007d0000,
++              .size           = 0x00100000,
++      },
++      {
++              .name           = "rootfs",
++              .offset         = 0x00120000,
++              .size           = 0x006d0000,
+       },
+       {
+               .name           = "env",
index cf70f9f229e4df6ad9c206e6656acc091f29e4d0..5f354c55bc8c7c073db8b9346cbbac7c7f719ea6 100644 (file)
@@ -1943,7 +1943,7 @@ diff -urN linux-2.6.21.1.old/fs/mini_fo/fist.h linux-2.6.21.1.dev/fs/mini_fo/fis
 +#include <linux/swap.h>
 +
 +#include <asm/system.h>
-+#include <asm/segment.h>
++/* #include <asm/segment.h> */
 +#include <asm/mman.h>
 +#include <linux/seq_file.h>
 +
diff --git a/toolchain/binutils/patches/2.17/500-avr32.patch b/toolchain/binutils/patches/2.17/500-avr32.patch
new file mode 100644 (file)
index 0000000..eec6edf
--- /dev/null
@@ -0,0 +1,100602 @@
+diff -Nrup binutils-2.17/bfd/aclocal.m4 binutils-2.17-atmel/bfd/aclocal.m4
+--- binutils-2.17/bfd/aclocal.m4       2005-09-30 20:38:50.000000000 +0200
++++ binutils-2.17-atmel/bfd/aclocal.m4 2007-02-20 16:07:03.000000000 +0100
+@@ -1,4 +1,4 @@
+-# generated automatically by aclocal 1.9.5 -*- Autoconf -*-
++# generated automatically by aclocal 1.9.6 -*- Autoconf -*-
+ # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ # 2005  Free Software Foundation, Inc.
+@@ -28,7 +28,7 @@ AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api
+ # Call AM_AUTOMAKE_VERSION so it can be traced.
+ # This function is AC_REQUIREd by AC_INIT_AUTOMAKE.
+ AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
+-       [AM_AUTOMAKE_VERSION([1.9.5])])
++       [AM_AUTOMAKE_VERSION([1.9.6])])
+ # AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
+diff -Nrup binutils-2.17/bfd/archures.c binutils-2.17-atmel/bfd/archures.c
+--- binutils-2.17/bfd/archures.c       2006-03-06 14:42:03.000000000 +0100
++++ binutils-2.17-atmel/bfd/archures.c 2007-02-12 15:37:09.000000000 +0100
+@@ -334,6 +334,9 @@ DESCRIPTION
+ .#define bfd_mach_avr3                3
+ .#define bfd_mach_avr4                4
+ .#define bfd_mach_avr5                5
++.  bfd_arch_avr32,     {* Atmel AVR32 *}
++.#define bfd_mach_avr32_ap    7000
++.#define bfd_mach_avr32_uc    3000
+ .  bfd_arch_bfin,        {* ADI Blackfin *}
+ .#define bfd_mach_bfin          1
+ .  bfd_arch_cr16c,       {* National Semiconductor CompactRISC. *}
+@@ -423,6 +426,7 @@ extern const bfd_arch_info_type bfd_alph
+ extern const bfd_arch_info_type bfd_arc_arch;
+ extern const bfd_arch_info_type bfd_arm_arch;
+ extern const bfd_arch_info_type bfd_avr_arch;
++extern const bfd_arch_info_type bfd_avr32_arch;
+ extern const bfd_arch_info_type bfd_bfin_arch;
+ extern const bfd_arch_info_type bfd_cr16c_arch;
+ extern const bfd_arch_info_type bfd_cris_arch;
+@@ -490,6 +494,7 @@ static const bfd_arch_info_type * const 
+     &bfd_arc_arch,
+     &bfd_arm_arch,
+     &bfd_avr_arch,
++    &bfd_avr32_arch,
+     &bfd_bfin_arch,
+     &bfd_cr16c_arch,
+     &bfd_cris_arch,
+diff -Nrup binutils-2.17/bfd/bfd-in2.h binutils-2.17-atmel/bfd/bfd-in2.h
+--- binutils-2.17/bfd/bfd-in2.h        2006-03-26 01:38:42.000000000 +0100
++++ binutils-2.17-atmel/bfd/bfd-in2.h  2007-02-20 16:08:43.000000000 +0100
+@@ -1931,6 +1931,9 @@ enum bfd_architecture
+ #define bfd_mach_avr3          3
+ #define bfd_mach_avr4          4
+ #define bfd_mach_avr5          5
++  bfd_arch_avr32,     /* Atmel AVR32 */
++#define bfd_mach_avr32_ap      7000
++#define bfd_mach_avr32_uc      3000
+   bfd_arch_bfin,        /* ADI Blackfin */
+ #define bfd_mach_bfin          1
+   bfd_arch_cr16c,       /* National Semiconductor CompactRISC. */
+@@ -3577,6 +3580,87 @@ instructions  */
+ instructions  */
+   BFD_RELOC_AVR_6_ADIW,
++/* Difference between two labels: L2 - L1. The value of L1 is encoded
++as sym + addend, while the initial difference after assembly is
++inserted into the object file by the assembler.  */
++  BFD_RELOC_AVR32_DIFF32,
++  BFD_RELOC_AVR32_DIFF16,
++  BFD_RELOC_AVR32_DIFF8,
++
++/* Reference to a symbol through the Global Offset Table. The linker
++will allocate an entry for symbol in the GOT and insert the offset
++of this entry as the relocation value.  */
++  BFD_RELOC_AVR32_GOT32,
++  BFD_RELOC_AVR32_GOT16,
++  BFD_RELOC_AVR32_GOT8,
++
++/* Normal (non-pc-relative) code relocations. Alignment and signedness
++is indicated by the suffixes. S means signed, U means unsigned. W
++means word-aligned, H means halfword-aligned, neither means
++byte-aligned (no alignment.) SUB5 is the same relocation as 16S.  */
++  BFD_RELOC_AVR32_21S,
++  BFD_RELOC_AVR32_16U,
++  BFD_RELOC_AVR32_16S,
++  BFD_RELOC_AVR32_SUB5,
++  BFD_RELOC_AVR32_8S_EXT,
++  BFD_RELOC_AVR32_8S,
++
++/* PC-relative relocations are signed if neither 'U' nor 'S' is
++specified. However, we explicitly tack on a 'B' to indicate no
++alignment, to avoid confusion with data relocs. All of these resolve
++to sym + addend - offset, except the one with 'N' (negated) suffix.
++This particular one resolves to offset - sym - addend.  */
++  BFD_RELOC_AVR32_22H_PCREL,
++  BFD_RELOC_AVR32_18W_PCREL,
++  BFD_RELOC_AVR32_16B_PCREL,
++  BFD_RELOC_AVR32_16N_PCREL,
++  BFD_RELOC_AVR32_14UW_PCREL,
++  BFD_RELOC_AVR32_11H_PCREL,
++  BFD_RELOC_AVR32_10UW_PCREL,
++  BFD_RELOC_AVR32_9H_PCREL,
++  BFD_RELOC_AVR32_9UW_PCREL,
++
++/* Subtract the link-time address of the GOT from (symbol + addend)
++and insert the result.  */
++  BFD_RELOC_AVR32_GOTPC,
++
++/* Reference to a symbol through the GOT. The linker will allocate an
++entry for symbol in the GOT and insert the offset of this entry as
++the relocation value. addend must be zero. As usual, 'S' means
++signed, 'W' means word-aligned, etc.  */
++  BFD_RELOC_AVR32_GOTCALL,
++  BFD_RELOC_AVR32_LDA_GOT,
++  BFD_RELOC_AVR32_GOT21S,
++  BFD_RELOC_AVR32_GOT18SW,
++  BFD_RELOC_AVR32_GOT16S,
++
++/* 32-bit constant pool entry. I don't think 8- and 16-bit entries make
++a whole lot of sense.  */
++  BFD_RELOC_AVR32_32_CPENT,
++
++/* Constant pool references. Some of these relocations are signed,
++others are unsigned. It doesn't really matter, since the constant
++pool always comes after the code that references it.  */
++  BFD_RELOC_AVR32_CPCALL,
++  BFD_RELOC_AVR32_16_CP,
++  BFD_RELOC_AVR32_9W_CP,
++
++/* sym must be the absolute symbol. The addend specifies the alignment
++order, e.g. if addend is 2, the linker must add padding so that the
++next address is aligned to a 4-byte boundary.  */
++  BFD_RELOC_AVR32_ALIGN,
++
++/* Code relocations that will never make it to the output file.  */
++  BFD_RELOC_AVR32_14UW,
++  BFD_RELOC_AVR32_10UW,
++  BFD_RELOC_AVR32_10SW,
++  BFD_RELOC_AVR32_STHH_W,
++  BFD_RELOC_AVR32_7UW,
++  BFD_RELOC_AVR32_6S,
++  BFD_RELOC_AVR32_6UW,
++  BFD_RELOC_AVR32_4UH,
++  BFD_RELOC_AVR32_3U,
++
+ /* Direct 12 bit.  */
+   BFD_RELOC_390_12,
+diff -Nrup binutils-2.17/bfd/config.bfd binutils-2.17-atmel/bfd/config.bfd
+--- binutils-2.17/bfd/config.bfd       2006-04-05 14:41:57.000000000 +0200
++++ binutils-2.17-atmel/bfd/config.bfd 2007-02-12 15:37:09.000000000 +0100
+@@ -317,6 +317,10 @@ case "${targ}" in
+     targ_underscore=yes
+     ;;
++  avr32-*-*)
++    targ_defvec=bfd_elf32_avr32_vec
++    ;;
++
+   c30-*-*aout* | tic30-*-*aout*)
+     targ_defvec=tic30_aout_vec
+     ;;
+diff -Nrup binutils-2.17/bfd/config.in binutils-2.17-atmel/bfd/config.in
+--- binutils-2.17/bfd/config.in        2005-11-03 17:06:10.000000000 +0100
++++ binutils-2.17-atmel/bfd/config.in  2007-02-20 16:07:07.000000000 +0100
+@@ -313,18 +313,18 @@
+ /* Define to the version of this package. */
+ #undef PACKAGE_VERSION
+-/* The size of a `long', as computed by sizeof. */
++/* The size of `long', as computed by sizeof. */
+ #undef SIZEOF_LONG
+-/* The size of a `long long', as computed by sizeof. */
++/* The size of `long long', as computed by sizeof. */
+ #undef SIZEOF_LONG_LONG
+-/* The size of a `off_t', as computed by sizeof. */
++/* The size of `off_t', as computed by sizeof. */
+ #undef SIZEOF_OFF_T
+ /* If using the C implementation of alloca, define if you know the
+    direction of stack growth for your system; otherwise it will be
+-   automatically deduced at run-time.
++   automatically deduced at runtime.
+       STACK_DIRECTION > 0 => grows toward higher addresses
+       STACK_DIRECTION < 0 => grows toward lower addresses
+       STACK_DIRECTION = 0 => direction of growth unknown */
+@@ -368,8 +368,8 @@
+ #undef inline
+ #endif
+-/* Define to `long' if <sys/types.h> does not define. */
++/* Define to `long int' if <sys/types.h> does not define. */
+ #undef off_t
+-/* Define to `unsigned' if <sys/types.h> does not define. */
++/* Define to `unsigned int' if <sys/types.h> does not define. */
+ #undef size_t
+diff -Nrup binutils-2.17/bfd/configure binutils-2.17-atmel/bfd/configure
+--- binutils-2.17/bfd/configure        2006-06-23 20:17:03.000000000 +0200
++++ binutils-2.17-atmel/bfd/configure  2007-02-20 16:07:06.000000000 +0100
+@@ -1,25 +1,54 @@
+ #! /bin/sh
+ # Guess values for system-dependent variables and create Makefiles.
+-# Generated by GNU Autoconf 2.59.
++# Generated by GNU Autoconf 2.61.
+ #
+-# Copyright (C) 2003 Free Software Foundation, Inc.
++# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ # This configure script is free software; the Free Software Foundation
+ # gives unlimited permission to copy, distribute and modify it.
+ ## --------------------- ##
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -29,8 +58,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -44,18 +108,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -63,157 +128,388 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++# CDPATH.
++$as_unset CDPATH
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
++if test "x$CONFIG_SHELL" = x; then
++  if (eval ":") 2>/dev/null; then
++  as_have_required=yes
++else
++  as_have_required=no
++fi
++
++  if test $as_have_required = yes &&   (eval ":
++(as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
+ fi
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0) || { (exit 1); exit 1; }
++
++(
++  as_lineno_1=\$LINENO
++  as_lineno_2=\$LINENO
++  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
++  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
++") 2> /dev/null; then
++  :
++else
++  as_candidate_shells=
+     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
++  case $as_dir in
+        /*)
+-         if ("$as_dir/$as_base" -c '
++         for as_base in sh bash ksh sh5; do
++           as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
++         done;;
++       esac
++done
++IFS=$as_save_IFS
++
++
++      for as_shell in $as_candidate_shells $SHELL; do
++       # Try only shells that exist, to save several forks.
++       if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
++              { ("$as_shell") 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++_ASEOF
++}; then
++  CONFIG_SHELL=$as_shell
++             as_have_required=yes
++             if { "$as_shell" 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++(as_func_return () {
++  (exit $1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = "$1" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test $exitcode = 0) || { (exit 1); exit 1; }
++
++(
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
++
++_ASEOF
++}; then
++  break
++fi
++
++fi
++
++      done
++
++      if test "x$CONFIG_SHELL" != x; then
++  for as_var in BASH_ENV ENV
++        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++        done
++        export CONFIG_SHELL
++        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
++fi
++
++
++    if test $as_have_required = no; then
++  echo This script requires a shell more modern than all the
++      echo shells that I found on your system.  Please install a
++      echo modern shell, or manually run the script under such a
++      echo shell if you do have one.
++      { (exit 1); exit 1; }
++fi
++
++
++fi
++
++fi
++
++
++
++(eval "as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0") || {
++  echo No shell found that supports shell functions.
++  echo Please tell autoconf@gnu.org about your system,
++  echo including any error possibly output before this
++  echo message
++}
++
++
++
++  as_lineno_1=$LINENO
++  as_lineno_2=$LINENO
++  test "x$as_lineno_1" != "x$as_lineno_2" &&
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
++  chmod +x "$as_me.lineno" ||
+     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -222,7 +518,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -231,39 +548,27 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
++exec 7<&0 </dev/null 6>&1
+ # Name of the host.
+ # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+ # so uname gets run too.
+ ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+-exec 6>&1
+-
+ #
+ # Initializations.
+ #
+ ac_default_prefix=/usr/local
++ac_clean_files=
+ ac_config_libobj_dir=.
++LIBOBJS=
+ cross_compiling=no
+ subdirs=
+ MFLAGS=
+ MAKEFLAGS=
+ SHELL=${CONFIG_SHELL-/bin/sh}
+-# Maximum number of lines to put in a shell here document.
+-# This variable seems obsolete.  It should probably be removed, and
+-# only ac_max_sed_lines should be used.
+-: ${ac_max_here_lines=38}
+-
+ # Identity of this package.
+ PACKAGE_NAME=
+ PACKAGE_TARNAME=
+@@ -275,42 +580,199 @@ ac_unique_file="libbfd.c"
+ # Factoring default headers for most tests.
+ ac_includes_default="\
+ #include <stdio.h>
+-#if HAVE_SYS_TYPES_H
++#ifdef HAVE_SYS_TYPES_H
+ # include <sys/types.h>
+ #endif
+-#if HAVE_SYS_STAT_H
++#ifdef HAVE_SYS_STAT_H
+ # include <sys/stat.h>
+ #endif
+-#if STDC_HEADERS
++#ifdef STDC_HEADERS
+ # include <stdlib.h>
+ # include <stddef.h>
+ #else
+-# if HAVE_STDLIB_H
++# ifdef HAVE_STDLIB_H
+ #  include <stdlib.h>
+ # endif
+ #endif
+-#if HAVE_STRING_H
+-# if !STDC_HEADERS && HAVE_MEMORY_H
++#ifdef HAVE_STRING_H
++# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+ #  include <memory.h>
+ # endif
+ # include <string.h>
+ #endif
+-#if HAVE_STRINGS_H
++#ifdef HAVE_STRINGS_H
+ # include <strings.h>
+ #endif
+-#if HAVE_INTTYPES_H
++#ifdef HAVE_INTTYPES_H
+ # include <inttypes.h>
+-#else
+-# if HAVE_STDINT_H
+-#  include <stdint.h>
+-# endif
+ #endif
+-#if HAVE_UNISTD_H
++#ifdef HAVE_STDINT_H
++# include <stdint.h>
++#endif
++#ifdef HAVE_UNISTD_H
+ # include <unistd.h>
+ #endif"
+-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE AR ac_ct_AR RANLIB ac_ct_RANLIB LN_S LIBTOOL WARN_CFLAGS NO_WERROR MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT INSTALL_LIBBFD_TRUE INSTALL_LIBBFD_FALSE host_noncanonical target_noncanonical bfdlibdir bfdincludedir CPP EGREP ALLOCA USE_NLS MSGFMT GMSGFMT XGETTEXT USE_INCLUDED_LIBINTL CATALOGS CATOBJEXT DATADIRNAME GMOFILES INSTOBJEXT INTLDEPS INTLLIBS INTLOBJS POFILES POSUB INCLUDE_LOCALE_H GT_NO GT_YES MKINSTALLDIRS l HDEFINES BFD_HOST_64BIT_LONG BFD_HOST_LONG_LONG BFD_HOST_64_BIT_DEFINED BFD_HOST_64_BIT BFD_HOST_U_64_BIT CC_FOR_BUILD EXEEXT_FOR_BUILD COREFILE COREFLAG WIN32LDFLAGS WIN32LIBADD TDEFINES wordsize bfd_libs all_backends bfd_backends bfd_machines bfd_default_target_size bfd_file_ptr bfd_ufile_ptr tdefaults datarootdir docdir htmldir LIBOBJS LTLIBOBJS'
++ac_subst_vars='SHELL
++PATH_SEPARATOR
++PACKAGE_NAME
++PACKAGE_TARNAME
++PACKAGE_VERSION
++PACKAGE_STRING
++PACKAGE_BUGREPORT
++exec_prefix
++prefix
++program_transform_name
++bindir
++sbindir
++libexecdir
++datarootdir
++datadir
++sysconfdir
++sharedstatedir
++localstatedir
++includedir
++oldincludedir
++docdir
++infodir
++htmldir
++dvidir
++pdfdir
++psdir
++libdir
++localedir
++mandir
++DEFS
++ECHO_C
++ECHO_N
++ECHO_T
++LIBS
++build_alias
++host_alias
++target_alias
++build
++build_cpu
++build_vendor
++build_os
++host
++host_cpu
++host_vendor
++host_os
++target
++target_cpu
++target_vendor
++target_os
++CC
++CFLAGS
++LDFLAGS
++CPPFLAGS
++ac_ct_CC
++EXEEXT
++OBJEXT
++INSTALL_PROGRAM
++INSTALL_SCRIPT
++INSTALL_DATA
++CYGPATH_W
++PACKAGE
++VERSION
++ACLOCAL
++AUTOCONF
++AUTOMAKE
++AUTOHEADER
++MAKEINFO
++install_sh
++STRIP
++INSTALL_STRIP_PROGRAM
++mkdir_p
++AWK
++SET_MAKE
++am__leading_dot
++AMTAR
++am__tar
++am__untar
++DEPDIR
++am__include
++am__quote
++AMDEP_TRUE
++AMDEP_FALSE
++AMDEPBACKSLASH
++CCDEPMODE
++am__fastdepCC_TRUE
++am__fastdepCC_FALSE
++AR
++RANLIB
++LN_S
++LIBTOOL
++WARN_CFLAGS
++NO_WERROR
++MAINTAINER_MODE_TRUE
++MAINTAINER_MODE_FALSE
++MAINT
++INSTALL_LIBBFD_TRUE
++INSTALL_LIBBFD_FALSE
++host_noncanonical
++target_noncanonical
++bfdlibdir
++bfdincludedir
++CPP
++GREP
++EGREP
++ALLOCA
++USE_NLS
++MSGFMT
++GMSGFMT
++XGETTEXT
++USE_INCLUDED_LIBINTL
++CATALOGS
++CATOBJEXT
++DATADIRNAME
++GMOFILES
++INSTOBJEXT
++INTLDEPS
++INTLLIBS
++INTLOBJS
++POFILES
++POSUB
++INCLUDE_LOCALE_H
++GT_NO
++GT_YES
++MKINSTALLDIRS
++l
++HDEFINES
++BFD_HOST_64BIT_LONG
++BFD_HOST_LONG_LONG
++BFD_HOST_64_BIT_DEFINED
++BFD_HOST_64_BIT
++BFD_HOST_U_64_BIT
++CC_FOR_BUILD
++EXEEXT_FOR_BUILD
++COREFILE
++COREFLAG
++WIN32LDFLAGS
++WIN32LIBADD
++TDEFINES
++wordsize
++bfd_libs
++all_backends
++bfd_backends
++bfd_machines
++bfd_default_target_size
++bfd_file_ptr
++bfd_ufile_ptr
++tdefaults
++LIBOBJS
++LTLIBOBJS'
+ ac_subst_files=''
++      ac_precious_vars='build_alias
++host_alias
++target_alias
++CC
++CFLAGS
++LDFLAGS
++LIBS
++CPPFLAGS
++CPP'
++
+ # Initialize some variables set by options.
+ ac_init_help=
+@@ -337,34 +799,48 @@ x_libraries=NONE
+ # and all the variables that are supposed to be based on exec_prefix
+ # by default will actually change.
+ # Use braces instead of parens because sh, perl, etc. also accept them.
++# (The list follows the same order as the GNU Coding Standards.)
+ bindir='${exec_prefix}/bin'
+ sbindir='${exec_prefix}/sbin'
+ libexecdir='${exec_prefix}/libexec'
+-datadir='${prefix}/share'
++datarootdir='${prefix}/share'
++datadir='${datarootdir}'
+ sysconfdir='${prefix}/etc'
+ sharedstatedir='${prefix}/com'
+ localstatedir='${prefix}/var'
+-libdir='${exec_prefix}/lib'
+ includedir='${prefix}/include'
+ oldincludedir='/usr/include'
+-infodir='${prefix}/info'
+-mandir='${prefix}/man'
++docdir='${datarootdir}/doc/${PACKAGE}'
++infodir='${datarootdir}/info'
++htmldir='${docdir}'
++dvidir='${docdir}'
++pdfdir='${docdir}'
++psdir='${docdir}'
++libdir='${exec_prefix}/lib'
++localedir='${datarootdir}/locale'
++mandir='${datarootdir}/man'
+ ac_prev=
++ac_dashdash=
+ for ac_option
+ do
+   # If the previous option needs an argument, assign it.
+   if test -n "$ac_prev"; then
+-    eval "$ac_prev=\$ac_option"
++    eval $ac_prev=\$ac_option
+     ac_prev=
+     continue
+   fi
+-  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
++  case $ac_option in
++  *=*)        ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
++  *)  ac_optarg=yes ;;
++  esac
+   # Accept the important Cygnus configure options, so we can diagnose typos.
+-  case $ac_option in
++  case $ac_dashdash$ac_option in
++  --)
++    ac_dashdash=yes ;;
+   -bindir | --bindir | --bindi | --bind | --bin | --bi)
+     ac_prev=bindir ;;
+@@ -386,33 +862,45 @@ do
+   --config-cache | -C)
+     cache_file=config.cache ;;
+-  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
++  -datadir | --datadir | --datadi | --datad)
+     ac_prev=datadir ;;
+-  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+-  | --da=*)
++  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+     datadir=$ac_optarg ;;
++  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
++  | --dataroo | --dataro | --datar)
++    ac_prev=datarootdir ;;
++  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
++  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
++    datarootdir=$ac_optarg ;;
++
+   -disable-* | --disable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    eval "enable_$ac_feature=no" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=no ;;
++
++  -docdir | --docdir | --docdi | --doc | --do)
++    ac_prev=docdir ;;
++  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
++    docdir=$ac_optarg ;;
++
++  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
++    ac_prev=dvidir ;;
++  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
++    dvidir=$ac_optarg ;;
+   -enable-* | --enable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "enable_$ac_feature='$ac_optarg'" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=\$ac_optarg ;;
+   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+@@ -439,6 +927,12 @@ do
+   -host=* | --host=* | --hos=* | --ho=*)
+     host_alias=$ac_optarg ;;
++  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
++    ac_prev=htmldir ;;
++  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
++  | --ht=*)
++    htmldir=$ac_optarg ;;
++
+   -includedir | --includedir | --includedi | --included | --include \
+   | --includ | --inclu | --incl | --inc)
+     ac_prev=includedir ;;
+@@ -463,13 +957,16 @@ do
+   | --libexe=* | --libex=* | --libe=*)
+     libexecdir=$ac_optarg ;;
++  -localedir | --localedir | --localedi | --localed | --locale)
++    ac_prev=localedir ;;
++  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
++    localedir=$ac_optarg ;;
++
+   -localstatedir | --localstatedir | --localstatedi | --localstated \
+-  | --localstate | --localstat | --localsta | --localst \
+-  | --locals | --local | --loca | --loc | --lo)
++  | --localstate | --localstat | --localsta | --localst | --locals)
+     ac_prev=localstatedir ;;
+   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+-  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+-  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
++  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+     localstatedir=$ac_optarg ;;
+   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+@@ -534,6 +1031,16 @@ do
+   | --progr-tra=* | --program-tr=* | --program-t=*)
+     program_transform_name=$ac_optarg ;;
++  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
++    ac_prev=pdfdir ;;
++  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
++    pdfdir=$ac_optarg ;;
++
++  -psdir | --psdir | --psdi | --psd | --ps)
++    ac_prev=psdir ;;
++  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
++    psdir=$ac_optarg ;;
++
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil)
+     silent=yes ;;
+@@ -586,24 +1093,20 @@ do
+   -with-* | --with-*)
+     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package| sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "with_$ac_package='$ac_optarg'" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=\$ac_optarg ;;
+   -without-* | --without-*)
+     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package | sed 's/-/_/g'`
+-    eval "with_$ac_package=no" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=no ;;
+   --x)
+     # Obsolete; use --with-x.
+@@ -634,8 +1137,7 @@ Try \`$0 --help' for more information." 
+     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
+    { (exit 1); exit 1; }; }
+-    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
+-    eval "$ac_envvar='$ac_optarg'"
++    eval $ac_envvar=\$ac_optarg
+     export $ac_envvar ;;
+   *)
+@@ -655,27 +1157,19 @@ if test -n "$ac_prev"; then
+    { (exit 1); exit 1; }; }
+ fi
+-# Be sure to have absolute paths.
+-for ac_var in exec_prefix prefix
+-do
+-  eval ac_val=$`echo $ac_var`
+-  case $ac_val in
+-    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
+-  esac
+-done
+-
+-# Be sure to have absolute paths.
+-for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
+-            localstatedir libdir includedir oldincludedir infodir mandir
++# Be sure to have absolute directory names.
++for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
++              datadir sysconfdir sharedstatedir localstatedir includedir \
++              oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
++              libdir localedir mandir
+ do
+-  eval ac_val=$`echo $ac_var`
++  eval ac_val=\$$ac_var
+   case $ac_val in
+-    [\\/$]* | ?:[\\/]* ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
++    [\\/$]* | ?:[\\/]* )  continue;;
++    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+   esac
++  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
++   { (exit 1); exit 1; }; }
+ done
+ # There might be people who depend on the old broken behavior: `$host'
+@@ -702,74 +1196,76 @@ test -n "$host_alias" && ac_tool_prefix=
+ test "$silent" = yes && exec 6>/dev/null
++ac_pwd=`pwd` && test -n "$ac_pwd" &&
++ac_ls_di=`ls -di .` &&
++ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
++  { echo "$as_me: error: Working directory cannot be determined" >&2
++   { (exit 1); exit 1; }; }
++test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
++  { echo "$as_me: error: pwd does not report name of working directory" >&2
++   { (exit 1); exit 1; }; }
++
++
+ # Find the source files, if location was not specified.
+ if test -z "$srcdir"; then
+   ac_srcdir_defaulted=yes
+-  # Try the directory containing this script, then its parent.
+-  ac_confdir=`(dirname "$0") 2>/dev/null ||
++  # Try the directory containing this script, then the parent directory.
++  ac_confdir=`$as_dirname -- "$0" ||
+ $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$0" : 'X\(//\)[^/]' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$0" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   srcdir=$ac_confdir
+-  if test ! -r $srcdir/$ac_unique_file; then
++  if test ! -r "$srcdir/$ac_unique_file"; then
+     srcdir=..
+   fi
+ else
+   ac_srcdir_defaulted=no
+ fi
+-if test ! -r $srcdir/$ac_unique_file; then
+-  if test "$ac_srcdir_defaulted" = yes; then
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
+-   { (exit 1); exit 1; }; }
+-  else
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-fi
+-(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
+-  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
+-   { (exit 1); exit 1; }; }
+-srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
+-ac_env_build_alias_set=${build_alias+set}
+-ac_env_build_alias_value=$build_alias
+-ac_cv_env_build_alias_set=${build_alias+set}
+-ac_cv_env_build_alias_value=$build_alias
+-ac_env_host_alias_set=${host_alias+set}
+-ac_env_host_alias_value=$host_alias
+-ac_cv_env_host_alias_set=${host_alias+set}
+-ac_cv_env_host_alias_value=$host_alias
+-ac_env_target_alias_set=${target_alias+set}
+-ac_env_target_alias_value=$target_alias
+-ac_cv_env_target_alias_set=${target_alias+set}
+-ac_cv_env_target_alias_value=$target_alias
+-ac_env_CC_set=${CC+set}
+-ac_env_CC_value=$CC
+-ac_cv_env_CC_set=${CC+set}
+-ac_cv_env_CC_value=$CC
+-ac_env_CFLAGS_set=${CFLAGS+set}
+-ac_env_CFLAGS_value=$CFLAGS
+-ac_cv_env_CFLAGS_set=${CFLAGS+set}
+-ac_cv_env_CFLAGS_value=$CFLAGS
+-ac_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_env_LDFLAGS_value=$LDFLAGS
+-ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_cv_env_LDFLAGS_value=$LDFLAGS
+-ac_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_env_CPPFLAGS_value=$CPPFLAGS
+-ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_cv_env_CPPFLAGS_value=$CPPFLAGS
+-ac_env_CPP_set=${CPP+set}
+-ac_env_CPP_value=$CPP
+-ac_cv_env_CPP_set=${CPP+set}
+-ac_cv_env_CPP_value=$CPP
++if test ! -r "$srcdir/$ac_unique_file"; then
++  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
++  { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
++   { (exit 1); exit 1; }; }
++fi
++ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
++ac_abs_confdir=`(
++      cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2
++   { (exit 1); exit 1; }; }
++      pwd)`
++# When building in place, set srcdir=.
++if test "$ac_abs_confdir" = "$ac_pwd"; then
++  srcdir=.
++fi
++# Remove unnecessary trailing slashes from srcdir.
++# Double slashes in file names in object file debugging info
++# mess up M-x gdb in Emacs.
++case $srcdir in
++*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
++esac
++for ac_var in $ac_precious_vars; do
++  eval ac_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_env_${ac_var}_value=\$${ac_var}
++  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_cv_env_${ac_var}_value=\$${ac_var}
++done
+ #
+ # Report the --help message.
+@@ -798,9 +1294,6 @@ Configuration:
+   -n, --no-create         do not create output files
+       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+-_ACEOF
+-
+-  cat <<_ACEOF
+ Installation directories:
+   --prefix=PREFIX         install architecture-independent files in PREFIX
+                         [$ac_default_prefix]
+@@ -818,15 +1311,22 @@ Fine tuning of the installation director
+   --bindir=DIR           user executables [EPREFIX/bin]
+   --sbindir=DIR          system admin executables [EPREFIX/sbin]
+   --libexecdir=DIR       program executables [EPREFIX/libexec]
+-  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
+   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
+   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
+   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
+   --libdir=DIR           object code libraries [EPREFIX/lib]
+   --includedir=DIR       C header files [PREFIX/include]
+   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
+-  --infodir=DIR          info documentation [PREFIX/info]
+-  --mandir=DIR           man documentation [PREFIX/man]
++  --datarootdir=DIR      read-only arch.-independent data root [PREFIX/share]
++  --datadir=DIR          read-only architecture-independent data [DATAROOTDIR]
++  --infodir=DIR          info documentation [DATAROOTDIR/info]
++  --localedir=DIR        locale-dependent data [DATAROOTDIR/locale]
++  --mandir=DIR           man documentation [DATAROOTDIR/man]
++  --docdir=DIR           documentation root [DATAROOTDIR/doc/PACKAGE]
++  --htmldir=DIR          html documentation [DOCDIR]
++  --dvidir=DIR           dvi documentation [DOCDIR]
++  --pdfdir=DIR           pdf documentation [DOCDIR]
++  --psdir=DIR            ps documentation [DOCDIR]
+ _ACEOF
+   cat <<\_ACEOF
+@@ -880,126 +1380,95 @@ Some influential environment variables:
+   CFLAGS      C compiler flags
+   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+               nonstandard directory <lib dir>
+-  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
+-              headers in a nonstandard directory <include dir>
++  LIBS        libraries to pass to the linker, e.g. -l<library>
++  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
++              you have headers in a nonstandard directory <include dir>
+   CPP         C preprocessor
+ Use these variables to override the choices made by `configure' or to help
+ it to find libraries and programs with nonstandard names/locations.
+ _ACEOF
++ac_status=$?
+ fi
+ if test "$ac_init_help" = "recursive"; then
+   # If there are subdirs, report their specific --help.
+-  ac_popdir=`pwd`
+   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+-    test -d $ac_dir || continue
++    test -d "$ac_dir" || continue
+     ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
+-
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
+-
+-    cd $ac_dir
+-    # Check for guested configure; otherwise get Cygnus style configure.
+-    if test -f $ac_srcdir/configure.gnu; then
+-      echo
+-      $SHELL $ac_srcdir/configure.gnu  --help=recursive
+-    elif test -f $ac_srcdir/configure; then
+-      echo
+-      $SHELL $ac_srcdir/configure  --help=recursive
+-    elif test -f $ac_srcdir/configure.ac ||
+-         test -f $ac_srcdir/configure.in; then
+-      echo
+-      $ac_configure --help
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
++
++    cd "$ac_dir" || { ac_status=$?; continue; }
++    # Check for guested configure.
++    if test -f "$ac_srcdir/configure.gnu"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
++    elif test -f "$ac_srcdir/configure"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure" --help=recursive
+     else
+       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+-    fi
+-    cd $ac_popdir
++    fi || ac_status=$?
++    cd "$ac_pwd" || { ac_status=$?; break; }
+   done
+ fi
+-test -n "$ac_init_help" && exit 0
++test -n "$ac_init_help" && exit $ac_status
+ if $ac_init_version; then
+   cat <<\_ACEOF
++configure
++generated by GNU Autoconf 2.61
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ This configure script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it.
+ _ACEOF
+-  exit 0
++  exit
+ fi
+-exec 5>config.log
+-cat >&5 <<_ACEOF
++cat >config.log <<_ACEOF
+ This file contains any messages produced by compilers while
+ running configure, to aid debugging if configure makes a mistake.
+ It was created by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   $ $0 $@
+ _ACEOF
++exec 5>>config.log
+ {
+ cat <<_ASUNAME
+ ## --------- ##
+@@ -1018,7 +1487,7 @@ uname -v = `(uname -v) 2>/dev/null || ec
+ /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+ /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+ /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+-hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
++/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+ /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+ /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+ /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+@@ -1032,6 +1501,7 @@ do
+   test -z "$as_dir" && as_dir=.
+   echo "PATH: $as_dir"
+ done
++IFS=$as_save_IFS
+ } >&5
+@@ -1053,7 +1523,6 @@ _ACEOF
+ ac_configure_args=
+ ac_configure_args0=
+ ac_configure_args1=
+-ac_sep=
+ ac_must_keep_next=false
+ for ac_pass in 1 2
+ do
+@@ -1064,7 +1533,7 @@ do
+     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+     | -silent | --silent | --silen | --sile | --sil)
+       continue ;;
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
++    *\'*)
+       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+     esac
+     case $ac_pass in
+@@ -1086,9 +1555,7 @@ do
+         -* ) ac_must_keep_next=true ;;
+       esac
+       fi
+-      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
+-      # Get rid of the leading space.
+-      ac_sep=" "
++      ac_configure_args="$ac_configure_args '$ac_arg'"
+       ;;
+     esac
+   done
+@@ -1099,8 +1566,8 @@ $as_unset ac_configure_args1 || test "${
+ # When interrupted or exit'd, cleanup temporary files, and complete
+ # config.log.  We remove comments because anyway the quotes in there
+ # would cause problems or look ugly.
+-# WARNING: Be sure not to use single quotes in there, as some shells,
+-# such as our DU 5.0 friend, will then `close' the trap.
++# WARNING: Use '\'' to represent an apostrophe within the trap.
++# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+ trap 'exit_status=$?
+   # Save into config.log some information that might help in debugging.
+   {
+@@ -1113,20 +1580,34 @@ trap 'exit_status=$?
+ _ASBOX
+     echo
+     # The following way of writing the cache mishandles newlines in values,
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
+   (set) 2>&1 |
+-    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       sed -n \
+-      "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
+-        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
+-      ;;
++      "s/'\''/'\''\\\\'\'''\''/g;
++        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
++      ;; #(
+     *)
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-}
++    esac |
++    sort
++)
+     echo
+     cat <<\_ASBOX
+@@ -1137,22 +1618,28 @@ _ASBOX
+     echo
+     for ac_var in $ac_subst_vars
+     do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+     done | sort
+     echo
+     if test -n "$ac_subst_files"; then
+       cat <<\_ASBOX
+-## ------------- ##
+-## Output files. ##
+-## ------------- ##
++## ------------------- ##
++## File substitutions. ##
++## ------------------- ##
+ _ASBOX
+       echo
+       for ac_var in $ac_subst_files
+       do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+       done | sort
+       echo
+     fi
+@@ -1164,26 +1651,24 @@ _ASBOX
+ ## ----------- ##
+ _ASBOX
+       echo
+-      sed "/^$/d" confdefs.h | sort
++      cat confdefs.h
+       echo
+     fi
+     test "$ac_signal" != 0 &&
+       echo "$as_me: caught signal $ac_signal"
+     echo "$as_me: exit $exit_status"
+   } >&5
+-  rm -f core *.core &&
+-  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
++  rm -f core *.core core.conftest.* &&
++    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+     exit $exit_status
+-     ' 0
++' 0
+ for ac_signal in 1 2 13 15; do
+   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+ done
+ ac_signal=0
+ # confdefs.h avoids OS command line length limits that DEFS can exceed.
+-rm -rf conftest* confdefs.h
+-# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+-echo >confdefs.h
++rm -f -r conftest* confdefs.h
+ # Predefined preprocessor variables.
+@@ -1214,14 +1699,17 @@ _ACEOF
+ # Let the site file select an alternate cache file if it wants to.
+ # Prefer explicitly selected file to automatically selected ones.
+-if test -z "$CONFIG_SITE"; then
+-  if test "x$prefix" != xNONE; then
+-    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+-  else
+-    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+-  fi
++if test -n "$CONFIG_SITE"; then
++  set x "$CONFIG_SITE"
++elif test "x$prefix" != xNONE; then
++  set x "$prefix/share/config.site" "$prefix/etc/config.site"
++else
++  set x "$ac_default_prefix/share/config.site" \
++      "$ac_default_prefix/etc/config.site"
+ fi
+-for ac_site_file in $CONFIG_SITE; do
++shift
++for ac_site_file
++do
+   if test -r "$ac_site_file"; then
+     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
+ echo "$as_me: loading site script $ac_site_file" >&6;}
+@@ -1237,8 +1725,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -1250,12 +1738,11 @@ fi
+ # Check that the precious variables saved in the cache have kept the same
+ # value.
+ ac_cache_corrupted=false
+-for ac_var in `(set) 2>&1 |
+-             sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
++for ac_var in $ac_precious_vars; do
+   eval ac_old_set=\$ac_cv_env_${ac_var}_set
+   eval ac_new_set=\$ac_env_${ac_var}_set
+-  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
+-  eval ac_new_val="\$ac_env_${ac_var}_value"
++  eval ac_old_val=\$ac_cv_env_${ac_var}_value
++  eval ac_new_val=\$ac_env_${ac_var}_value
+   case $ac_old_set,$ac_new_set in
+     set,)
+       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+@@ -1280,8 +1767,7 @@ echo "$as_me:   current value: $ac_new_v
+   # Pass precious variables to config.status.
+   if test "$ac_new_set" = set; then
+     case $ac_new_val in
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+-      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
++    *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+     *) ac_arg=$ac_var=$ac_new_val ;;
+     esac
+     case " $ac_configure_args " in
+@@ -1298,12 +1784,6 @@ echo "$as_me: error: run \`make distclea
+    { (exit 1); exit 1; }; }
+ fi
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+@@ -1320,109 +1800,164 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ ac_aux_dir=
+-for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
+-  if test -f $ac_dir/install-sh; then
++for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
++  if test -f "$ac_dir/install-sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install-sh -c"
+     break
+-  elif test -f $ac_dir/install.sh; then
++  elif test -f "$ac_dir/install.sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install.sh -c"
+     break
+-  elif test -f $ac_dir/shtool; then
++  elif test -f "$ac_dir/shtool"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/shtool install -c"
+     break
+   fi
+ done
+ if test -z "$ac_aux_dir"; then
+-  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
+-echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
++  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&5
++echo "$as_me: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-ac_config_guess="$SHELL $ac_aux_dir/config.guess"
+-ac_config_sub="$SHELL $ac_aux_dir/config.sub"
+-ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
++
++# These three variables are undocumented and unsupported,
++# and are intended to be withdrawn in a future Autoconf release.
++# They can cause serious problems if a builder's source tree is in a directory
++# whose full name contains unusual characters.
++ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
++ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
++ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
++
+ # Make sure we can run config.sub.
+-$ac_config_sub sun4 >/dev/null 2>&1 ||
+-  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
+-echo "$as_me: error: cannot run $ac_config_sub" >&2;}
++$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
++  { { echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
++echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking build system type" >&5
+-echo $ECHO_N "checking build system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking build system type" >&5
++echo $ECHO_N "checking build system type... $ECHO_C" >&6; }
+ if test "${ac_cv_build+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_build_alias=$build_alias
+-test -z "$ac_cv_build_alias" &&
+-  ac_cv_build_alias=`$ac_config_guess`
+-test -z "$ac_cv_build_alias" &&
++  ac_build_alias=$build_alias
++test "x$ac_build_alias" = x &&
++  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
++test "x$ac_build_alias" = x &&
+   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
+ echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
+    { (exit 1); exit 1; }; }
+-ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
++ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
++  { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_build" >&5
+-echo "${ECHO_T}$ac_cv_build" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_build" >&5
++echo "${ECHO_T}$ac_cv_build" >&6; }
++case $ac_cv_build in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
++echo "$as_me: error: invalid value of canonical build" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ build=$ac_cv_build
+-build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_build
++shift
++build_cpu=$1
++build_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++build_os=$*
++IFS=$ac_save_IFS
++case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking host system type" >&5
+-echo $ECHO_N "checking host system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking host system type" >&5
++echo $ECHO_N "checking host system type... $ECHO_C" >&6; }
+ if test "${ac_cv_host+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_host_alias=$host_alias
+-test -z "$ac_cv_host_alias" &&
+-  ac_cv_host_alias=$ac_cv_build_alias
+-ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
++  if test "x$host_alias" = x; then
++  ac_cv_host=$ac_cv_build
++else
++  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_host" >&5
+-echo "${ECHO_T}$ac_cv_host" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_host" >&5
++echo "${ECHO_T}$ac_cv_host" >&6; }
++case $ac_cv_host in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
++echo "$as_me: error: invalid value of canonical host" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ host=$ac_cv_host
+-host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_host
++shift
++host_cpu=$1
++host_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++host_os=$*
++IFS=$ac_save_IFS
++case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking target system type" >&5
+-echo $ECHO_N "checking target system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking target system type" >&5
++echo $ECHO_N "checking target system type... $ECHO_C" >&6; }
+ if test "${ac_cv_target+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_target_alias=$target_alias
+-test "x$ac_cv_target_alias" = "x" &&
+-  ac_cv_target_alias=$ac_cv_host_alias
+-ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
++  if test "x$target_alias" = x; then
++  ac_cv_target=$ac_cv_host
++else
++  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_target" >&5
+-echo "${ECHO_T}$ac_cv_target" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_target" >&5
++echo "${ECHO_T}$ac_cv_target" >&6; }
++case $ac_cv_target in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical target" >&5
++echo "$as_me: error: invalid value of canonical target" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ target=$ac_cv_target
+-target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_target
++shift
++target_cpu=$1
++target_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++target_os=$*
++IFS=$ac_save_IFS
++case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
+ # The aliases save the names the user supplied, while $host etc.
+@@ -1439,8 +1974,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1453,32 +1988,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_CC"; then
+   ac_ct_CC=$CC
+   # Extract the first word of "gcc", so it can be a program name with args.
+ set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1491,36 +2028,51 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ else
+   CC="$ac_cv_prog_CC"
+ fi
+ if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1533,74 +2085,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}cc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
+-
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++  fi
+ fi
+ if test -z "$CC"; then
+   # Extract the first word of "cc", so it can be a program name with args.
+ set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1614,7 +2126,7 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+        continue
+@@ -1625,6 +2137,7 @@ do
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ if test $ac_prog_rejected = yes; then
+   # We found a bogon in the path, so make sure we never use it.
+@@ -1642,22 +2155,23 @@ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$CC"; then
+   if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1670,36 +2184,38 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+     test -n "$CC" && break
+   done
+ fi
+ if test -z "$CC"; then
+   ac_ct_CC=$CC
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1712,29 +2228,45 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$ac_ct_CC" && break
+ done
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ fi
+ fi
+@@ -1747,21 +2279,35 @@ See \`config.log' for more details." >&2
+    { (exit 1); exit 1; }; }
+ # Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
++echo "$as_me:$LINENO: checking for C compiler version" >&5
+ ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+@@ -1786,47 +2332,77 @@ ac_clean_files="$ac_clean_files a.out a.
+ # Try to create an executable without -o first, disregard a.out.
+ # It will help us diagnose broken compilers, and finding out an intuition
+ # of exeext.
+-echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
+-echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
++echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6; }
+ ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+-if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
+-  (eval $ac_link_default) 2>&5
++#
++# List of possible output files, starting from the most likely.
++# The algorithm is not robust to junk in `.', hence go to wildcards (a.*)
++# only as a last resort.  b.out is created by i960 compilers.
++ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'
++#
++# The IRIX 6 linker writes into existing files which may not be
++# executable, retaining their permissions.  Remove them first so a
++# subsequent execution test works.
++ac_rmfiles=
++for ac_file in $ac_files
++do
++  case $ac_file in
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
++    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
++  esac
++done
++rm -f $ac_rmfiles
++
++if { (ac_try="$ac_link_default"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link_default") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  # Find the output, starting from the most likely.  This scheme is
+-# not robust to junk in `.', hence go to wildcards (a.*) only as a last
+-# resort.
+-
+-# Be careful to initialize this variable, since it used to be cached.
+-# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
+-ac_cv_exeext=
+-# b.out is created by i960 compilers.
+-for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
++  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
++# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
++# in a Makefile.  We should not override ac_cv_exeext if it was cached,
++# so that the user can short-circuit this test for compilers unknown to
++# Autoconf.
++for ac_file in $ac_files ''
+ do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
+-      ;;
+-    conftest.$ac_ext )
+-      # This is the source file.
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )
+       ;;
+     [ab].out )
+       # We found the default executable, but exeext='' is most
+       # certainly right.
+       break;;
+     *.* )
+-      ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-      # FIXME: I believe we export ac_cv_exeext for Libtool,
+-      # but it would be cool to find out if it's true.  Does anybody
+-      # maintain Libtool? --akim.
+-      export ac_cv_exeext
++        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
++      then :; else
++         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
++      fi
++      # We set ac_cv_exeext here because the later test for it is not
++      # safe: cross compilers may not add the suffix if given an `-o'
++      # argument, so we may need to know it at that point already.
++      # Even if this section looks crufty: it has the advantage of
++      # actually working.
+       break;;
+     * )
+       break;;
+   esac
+ done
++test "$ac_cv_exeext" = no && ac_cv_exeext=
++
+ else
++  ac_file=''
++fi
++
++{ echo "$as_me:$LINENO: result: $ac_file" >&5
++echo "${ECHO_T}$ac_file" >&6; }
++if test -z "$ac_file"; then
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+@@ -1838,19 +2414,21 @@ See \`config.log' for more details." >&2
+ fi
+ ac_exeext=$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_file" >&5
+-echo "${ECHO_T}$ac_file" >&6
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether the C compiler works" >&5
+-echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether the C compiler works" >&5
++echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6; }
+ # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
+ # If not cross compiling, check that we can run a simple program.
+ if test "$cross_compiling" != yes; then
+   if { ac_try='./$ac_file'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -1869,22 +2447,27 @@ See \`config.log' for more details." >&2
+     fi
+   fi
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ rm -f a.out a.exe conftest$ac_cv_exeext b.out
+ ac_clean_files=$ac_clean_files_save
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
+-echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
+-echo "$as_me:$LINENO: result: $cross_compiling" >&5
+-echo "${ECHO_T}$cross_compiling" >&6
+-
+-echo "$as_me:$LINENO: checking for suffix of executables" >&5
+-echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
++echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }
++{ echo "$as_me:$LINENO: result: $cross_compiling" >&5
++echo "${ECHO_T}$cross_compiling" >&6; }
++
++{ echo "$as_me:$LINENO: checking for suffix of executables" >&5
++echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+@@ -1895,9 +2478,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_l
+ for ac_file in conftest.exe conftest conftest.*; do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
+     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-        export ac_cv_exeext
+         break;;
+     * ) break;;
+   esac
+@@ -1911,14 +2493,14 @@ See \`config.log' for more details." >&2
+ fi
+ rm -f conftest$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
+-echo "${ECHO_T}$ac_cv_exeext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
++echo "${ECHO_T}$ac_cv_exeext" >&6; }
+ rm -f conftest.$ac_ext
+ EXEEXT=$ac_cv_exeext
+ ac_exeext=$EXEEXT
+-echo "$as_me:$LINENO: checking for suffix of object files" >&5
+-echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for suffix of object files" >&5
++echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }
+ if test "${ac_cv_objext+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1938,14 +2520,20 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.o conftest.obj
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>&5
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
++  for ac_file in conftest.o conftest.obj conftest.*; do
++  test -f "$ac_file" || continue;
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;
+     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+        break;;
+   esac
+@@ -1963,12 +2551,12 @@ fi
+ rm -f conftest.$ac_cv_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
+-echo "${ECHO_T}$ac_cv_objext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
++echo "${ECHO_T}$ac_cv_objext" >&6; }
+ OBJEXT=$ac_cv_objext
+ ac_objext=$OBJEXT
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+ if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1991,50 +2579,49 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+ GCC=`test $ac_compiler_gnu = yes && echo yes`
+ ac_test_CFLAGS=${CFLAGS+set}
+ ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -2050,38 +2637,118 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
++
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
+ if test "$ac_test_CFLAGS" = set; then
+   CFLAGS=$ac_save_CFLAGS
+ elif test $ac_cv_prog_cc_g = yes; then
+@@ -2097,12 +2764,12 @@ else
+     CFLAGS=
+   fi
+ fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_prog_cc_stdc=no
++  ac_cv_prog_cc_c89=no
+ ac_save_CC=$CC
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -2136,12 +2803,17 @@ static char *f (char * (*g) (char **, in
+ /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+    function prototypes and stuff, but not '\xHH' hex character constants.
+    These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
++   as 'x'.  The following induces an error, until -std is added to get
+    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+    array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
++   that's true only with -std.  */
+ int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
+ int test (int i, double x);
+ struct s1 {int (*f) (int a);};
+ struct s2 {int (*f) (double a);};
+@@ -2156,335 +2828,144 @@ return f (e, argv, 0) != argv[0]  ||  f 
+   return 0;
+ }
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+ do
+   CC="$ac_save_CC $ac_arg"
+   rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext
++
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+-rm -f conftest.$ac_ext conftest.$ac_objext
++rm -f conftest.$ac_ext
+ CC=$ac_save_CC
+ fi
+-
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
+   *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
+ esac
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
++
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
++
++
++{ echo "$as_me:$LINENO: checking for library containing strerror" >&5
++echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6; }
++if test "${ac_cv_search_strerror+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_func_search_save_LIBS=$LIBS
+ cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
++
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
++#ifdef __cplusplus
++extern "C"
++#endif
++char strerror ();
+ int
+ main ()
+ {
+-exit (42);
++return strerror ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++for ac_lib in '' cposix; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_strerror=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
+-fi
+-
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_strerror+set}" = set; then
++  break
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+-
+-echo "$as_me:$LINENO: checking for library containing strerror" >&5
+-echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6
++done
+ if test "${ac_cv_search_strerror+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_strerror=no
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="none required"
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_strerror" = no; then
+-  for ac_lib in cposix; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="-l$ac_lib"
+-break
++  :
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++  ac_cv_search_strerror=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
+-echo "${ECHO_T}$ac_cv_search_strerror" >&6
+-if test "$ac_cv_search_strerror" != no; then
+-  test "$ac_cv_search_strerror" = "none required" || LIBS="$ac_cv_search_strerror $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
++echo "${ECHO_T}$ac_cv_search_strerror" >&6; }
++ac_res=$ac_cv_search_strerror
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+@@ -2503,8 +2984,8 @@ am__api_version="1.9"
+ # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+ # OS/2's system install, which has a completely different semantic
+ # ./install, which can be erroneously created by make from ./install.sh.
+-echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+-echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+ if test -z "$INSTALL"; then
+ if test "${ac_cv_path_install+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -2526,7 +3007,7 @@ case $as_dir/ in
+     # by default.
+     for ac_prog in ginstall scoinst install; do
+       for ac_exec_ext in '' $ac_executable_extensions; do
+-      if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
++      if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+         if test $ac_prog = install &&
+           grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+           # AIX install.  It has an incompatible calling convention.
+@@ -2545,21 +3026,22 @@ case $as_dir/ in
+     ;;
+ esac
+ done
++IFS=$as_save_IFS
+ fi
+   if test "${ac_cv_path_install+set}" = set; then
+     INSTALL=$ac_cv_path_install
+   else
+-    # As a last resort, use the slow shell script.  We don't cache a
+-    # path for INSTALL within a source directory, because that will
++    # As a last resort, use the slow shell script.  Don't cache a
++    # value for INSTALL within a source directory, because that will
+     # break other packages using the cache if that directory is
+-    # removed, or if the path is relative.
++    # removed, or if the value is a relative name.
+     INSTALL=$ac_install_sh
+   fi
+ fi
+-echo "$as_me:$LINENO: result: $INSTALL" >&5
+-echo "${ECHO_T}$INSTALL" >&6
++{ echo "$as_me:$LINENO: result: $INSTALL" >&5
++echo "${ECHO_T}$INSTALL" >&6; }
+ # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+ # It thinks the first close brace ends the variable substitution.
+@@ -2569,8 +3051,8 @@ test -z "$INSTALL_SCRIPT" && INSTALL_SCR
+ test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+-echo "$as_me:$LINENO: checking whether build environment is sane" >&5
+-echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether build environment is sane" >&5
++echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6; }
+ # Just in case
+ sleep 1
+ echo timestamp > conftest.file
+@@ -2612,20 +3094,20 @@ echo "$as_me: error: newly created file 
+ Check your system clock" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ test "$program_prefix" != NONE &&
+-  program_transform_name="s,^,$program_prefix,;$program_transform_name"
++  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+ # Use a double $ so make ignores it.
+ test "$program_suffix" != NONE &&
+-  program_transform_name="s,\$,$program_suffix,;$program_transform_name"
++  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+ # Double any \ or $.  echo might interpret backslashes.
+ # By default was `s,x,x', remove it if useless.
+ cat <<\_ACEOF >conftest.sed
+ s/[\\$]/&&/g;s/;s,x,x,$//
+ _ACEOF
+ program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
+-rm conftest.sed
++rm -f conftest.sed
+ # expand $ac_aux_dir to an absolute path
+ am_aux_dir=`cd $ac_aux_dir && pwd`
+@@ -2677,8 +3159,8 @@ for ac_prog in gawk mawk nawk awk
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_AWK+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2691,54 +3173,57 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_AWK="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ AWK=$ac_cv_prog_AWK
+ if test -n "$AWK"; then
+-  echo "$as_me:$LINENO: result: $AWK" >&5
+-echo "${ECHO_T}$AWK" >&6
++  { echo "$as_me:$LINENO: result: $AWK" >&5
++echo "${ECHO_T}$AWK" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$AWK" && break
+ done
+-echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+-echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
+-set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
+-if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
++echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6; }
++set x ${MAKE-make}; ac_make=`echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
++if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.make <<\_ACEOF
++SHELL = /bin/sh
+ all:
+-      @echo 'ac_maketemp="$(MAKE)"'
++      @echo '@@@%%%=$(MAKE)=@@@%%%'
+ _ACEOF
+ # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
+-eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
+-if test -n "$ac_maketemp"; then
+-  eval ac_cv_prog_make_${ac_make}_set=yes
+-else
+-  eval ac_cv_prog_make_${ac_make}_set=no
+-fi
++case `${MAKE-make} -f conftest.make 2>/dev/null` in
++  *@@@%%%=?*=@@@%%%*)
++    eval ac_cv_prog_make_${ac_make}_set=yes;;
++  *)
++    eval ac_cv_prog_make_${ac_make}_set=no;;
++esac
+ rm -f conftest.make
+ fi
+-if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+   SET_MAKE=
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+   SET_MAKE="MAKE=${MAKE-make}"
+ fi
+@@ -2753,7 +3238,7 @@ rmdir .tst 2>/dev/null
+ DEPDIR="${am__leading_dot}deps"
+-          ac_config_commands="$ac_config_commands depfiles"
++ac_config_commands="$ac_config_commands depfiles"
+ am_make=${MAKE-make}
+@@ -2763,8 +3248,8 @@ am__doit:
+ .PHONY: am__doit
+ END
+ # If we don't find an include directive, just comment out the code.
+-echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
+-echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
++echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6; }
+ am__include="#"
+ am__quote=
+ _am_result=none
+@@ -2791,15 +3276,15 @@ if test "$am__include" = "#"; then
+ fi
+-echo "$as_me:$LINENO: result: $_am_result" >&5
+-echo "${ECHO_T}$_am_result" >&6
++{ echo "$as_me:$LINENO: result: $_am_result" >&5
++echo "${ECHO_T}$_am_result" >&6; }
+ rm -f confinc confmf
+-# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
++# Check whether --enable-dependency-tracking was given.
+ if test "${enable_dependency_tracking+set}" = set; then
+-  enableval="$enable_dependency_tracking"
++  enableval=$enable_dependency_tracking;
++fi
+-fi;
+ if test "x$enable_dependency_tracking" != xno; then
+   am_depcomp="$ac_aux_dir/depcomp"
+   AMDEPBACKSLASH='\'
+@@ -2836,7 +3321,7 @@ fi
+ # Define the identity of the package.
+  PACKAGE=bfd
+- VERSION=2.17
++ VERSION=2.17.atmel.0.0.99
+ cat >>confdefs.h <<_ACEOF
+@@ -2874,8 +3359,8 @@ if test "$cross_compiling" != no; then
+   if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2888,32 +3373,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2926,27 +3413,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -2967,8 +3468,8 @@ am__tar='${AMTAR} chof - "$$tardir"'; am
+ depcc="$CC"   am_compiler_list=
+-echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
+-echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
++echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; }
+ if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3057,8 +3558,8 @@ else
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
+-echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
++echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; }
+ CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+@@ -3079,8 +3580,8 @@ fi
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ar; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_AR+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3093,32 +3594,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_AR="${ac_tool_prefix}ar"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ AR=$ac_cv_prog_AR
+ if test -n "$AR"; then
+-  echo "$as_me:$LINENO: result: $AR" >&5
+-echo "${ECHO_T}$AR" >&6
++  { echo "$as_me:$LINENO: result: $AR" >&5
++echo "${ECHO_T}$AR" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_AR"; then
+   ac_ct_AR=$AR
+   # Extract the first word of "ar", so it can be a program name with args.
+ set dummy ar; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3131,26 +3634,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_AR="ar"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_AR=$ac_cv_prog_ac_ct_AR
+ if test -n "$ac_ct_AR"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
+-echo "${ECHO_T}$ac_ct_AR" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
++echo "${ECHO_T}$ac_ct_AR" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  AR=$ac_ct_AR
++  if test "x$ac_ct_AR" = x; then
++    AR=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    AR=$ac_ct_AR
++  fi
+ else
+   AR="$ac_cv_prog_AR"
+ fi
+@@ -3158,8 +3676,8 @@ fi
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3172,32 +3690,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3210,36 +3730,49 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+-# Check whether --enable-shared or --disable-shared was given.
++# Check whether --enable-shared was given.
+ if test "${enable_shared+set}" = set; then
+-  enableval="$enable_shared"
+-  p=${PACKAGE-default}
++  enableval=$enable_shared; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_shared=yes ;;
+ no) enable_shared=no ;;
+@@ -3257,12 +3790,12 @@ no) enable_shared=no ;;
+ esac
+ else
+   enable_shared=no
+-fi;
++fi
++
+-# Check whether --enable-static or --disable-static was given.
++# Check whether --enable-static was given.
+ if test "${enable_static+set}" = set; then
+-  enableval="$enable_static"
+-  p=${PACKAGE-default}
++  enableval=$enable_static; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_static=yes ;;
+ no) enable_static=no ;;
+@@ -3280,11 +3813,11 @@ no) enable_static=no ;;
+ esac
+ else
+   enable_static=yes
+-fi;
+-# Check whether --enable-fast-install or --disable-fast-install was given.
++fi
++
++# Check whether --enable-fast-install was given.
+ if test "${enable_fast_install+set}" = set; then
+-  enableval="$enable_fast_install"
+-  p=${PACKAGE-default}
++  enableval=$enable_fast_install; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_fast_install=yes ;;
+ no) enable_fast_install=no ;;
+@@ -3302,20 +3835,21 @@ no) enable_fast_install=no ;;
+ esac
+ else
+   enable_fast_install=yes
+-fi;
++fi
++
+-# Check whether --with-gnu-ld or --without-gnu-ld was given.
++# Check whether --with-gnu-ld was given.
+ if test "${with_gnu_ld+set}" = set; then
+-  withval="$with_gnu_ld"
+-  test "$withval" = no || with_gnu_ld=yes
++  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+ else
+   with_gnu_ld=no
+-fi;
++fi
++
+ ac_prog=ld
+ if test "$GCC" = yes; then
+   # Check if gcc -print-prog-name=ld gives a path.
+-  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
+-echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for ld used by GCC" >&5
++echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6; }
+   case $host in
+   *-*-mingw*)
+     # gcc leaves a trailing carriage return which upsets mingw
+@@ -3344,11 +3878,11 @@ echo $ECHO_N "checking for ld used by GC
+     ;;
+   esac
+ elif test "$with_gnu_ld" = yes; then
+-  echo "$as_me:$LINENO: checking for GNU ld" >&5
+-echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for GNU ld" >&5
++echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6; }
+ else
+-  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
+-echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for non-GNU ld" >&5
++echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6; }
+ fi
+ if test "${lt_cv_path_LD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -3377,17 +3911,17 @@ fi
+ LD="$lt_cv_path_LD"
+ if test -n "$LD"; then
+-  echo "$as_me:$LINENO: result: $LD" >&5
+-echo "${ECHO_T}$LD" >&6
++  { echo "$as_me:$LINENO: result: $LD" >&5
++echo "${ECHO_T}$LD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
+ echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
+-echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
++echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6; }
+ if test "${lt_cv_prog_gnu_ld+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3398,25 +3932,25 @@ else
+   lt_cv_prog_gnu_ld=no
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
+-echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
++echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6; }
+ with_gnu_ld=$lt_cv_prog_gnu_ld
+-echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
+-echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
++echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6; }
+ if test "${lt_cv_ld_reload_flag+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   lt_cv_ld_reload_flag='-r'
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
+-echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
++echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6; }
+ reload_flag=$lt_cv_ld_reload_flag
+ test -n "$reload_flag" && reload_flag=" $reload_flag"
+-echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
+-echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
++echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6; }
+ if test "${lt_cv_path_NM+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3451,22 +3985,22 @@ fi
+ fi
+ NM="$lt_cv_path_NM"
+-echo "$as_me:$LINENO: result: $NM" >&5
+-echo "${ECHO_T}$NM" >&6
++{ echo "$as_me:$LINENO: result: $NM" >&5
++echo "${ECHO_T}$NM" >&6; }
+-echo "$as_me:$LINENO: checking whether ln -s works" >&5
+-echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether ln -s works" >&5
++echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6; }
+ LN_S=$as_ln_s
+ if test "$LN_S" = "ln -s"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
+-echo "${ECHO_T}no, using $LN_S" >&6
++  { echo "$as_me:$LINENO: result: no, using $LN_S" >&5
++echo "${ECHO_T}no, using $LN_S" >&6; }
+ fi
+-echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
+-echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
++echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6; }
+ if test "${lt_cv_deplibs_check_method+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3628,8 +4162,8 @@ sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+ esac
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
+-echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
++echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6; }
+ file_magic_cmd=$lt_cv_file_magic_cmd
+ deplibs_check_method=$lt_cv_deplibs_check_method
+@@ -3639,8 +4173,8 @@ deplibs_check_method=$lt_cv_deplibs_chec
+ # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
+ # find the maximum length of command line arguments
+-echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
+-echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
++echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6; }
+ if test "${lt_cv_sys_max_cmd_len+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3691,11 +4225,11 @@ else
+ fi
+ if test -n "$lt_cv_sys_max_cmd_len" ; then
+-  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
+-echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
++  { echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
++echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: none" >&5
+-echo "${ECHO_T}none" >&6
++  { echo "$as_me:$LINENO: result: none" >&5
++echo "${ECHO_T}none" >&6; }
+ fi
+@@ -3703,8 +4237,8 @@ fi
+ case $deplibs_check_method in
+ file_magic*)
+   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+-    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
+-echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
++echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3758,17 +4292,17 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ if test -z "$lt_cv_path_MAGIC_CMD"; then
+   if test -n "$ac_tool_prefix"; then
+-    echo "$as_me:$LINENO: checking for file" >&5
+-echo $ECHO_N "checking for file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for file" >&5
++echo $ECHO_N "checking for file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3822,11 +4356,11 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+   else
+@@ -3841,8 +4375,8 @@ esac
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3855,32 +4389,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3893,27 +4429,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -3921,8 +4471,8 @@ fi
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3935,32 +4485,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3973,27 +4525,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -4008,22 +4574,22 @@ test "$GCC" = yes && libtool_flags="$lib
+ test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
+-# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
++# Check whether --enable-libtool-lock was given.
+ if test "${enable_libtool_lock+set}" = set; then
+-  enableval="$enable_libtool_lock"
++  enableval=$enable_libtool_lock;
++fi
+-fi;
+ test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
+ test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
+-# Check whether --with-pic or --without-pic was given.
++# Check whether --with-pic was given.
+ if test "${with_pic+set}" = set; then
+-  withval="$with_pic"
+-  pic_mode="$withval"
++  withval=$with_pic; pic_mode="$withval"
+ else
+   pic_mode=default
+-fi;
++fi
++
+ test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
+ test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
+@@ -4032,7 +4598,7 @@ test x"$pic_mode" = xno && libtool_flags
+ case $host in
+ *-*-irix6*)
+   # Find out which ABI we are using.
+-  echo '#line 4035 "configure"' > conftest.$ac_ext
++  echo '#line 4601 "configure"' > conftest.$ac_ext
+   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+   (eval $ac_compile) 2>&5
+   ac_status=$?
+@@ -4137,13 +4703,12 @@ x86_64-*linux*|ppc*-*linux*|powerpc*-*li
+   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+   SAVE_CFLAGS="$CFLAGS"
+   CFLAGS="$CFLAGS -belf"
+-  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
+-echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
++echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6; }
+ if test "${lt_cv_cc_needs_belf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -4166,35 +4731,32 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   lt_cv_cc_needs_belf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-lt_cv_cc_needs_belf=no
++      lt_cv_cc_needs_belf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+@@ -4203,8 +4765,8 @@ ac_link='$CC -o conftest$ac_exeext $CFLA
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
+-echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
++echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6; }
+   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+     CFLAGS="$SAVE_CFLAGS"
+@@ -4234,39 +4796,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -4292,8 +4873,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -4319,10 +4900,9 @@ exec 5>>./config.log
+-# Check whether --enable-64-bit-bfd or --disable-64-bit-bfd was given.
++# Check whether --enable-64-bit-bfd was given.
+ if test "${enable_64_bit_bfd+set}" = set; then
+-  enableval="$enable_64_bit_bfd"
+-  case "${enableval}" in
++  enableval=$enable_64_bit_bfd; case "${enableval}" in
+   yes)  want64=true  ;;
+   no)   want64=false ;;
+   *)    { { echo "$as_me:$LINENO: error: bad value ${enableval} for 64-bit-bfd option" >&5
+@@ -4331,10 +4911,10 @@ echo "$as_me: error: bad value ${enablev
+ esac
+ else
+   want64=false
+-fi; # Check whether --enable-targets or --disable-targets was given.
++fi
++# Check whether --enable-targets was given.
+ if test "${enable_targets+set}" = set; then
+-  enableval="$enable_targets"
+-  case "${enableval}" in
++  enableval=$enable_targets; case "${enableval}" in
+   yes | "") { { echo "$as_me:$LINENO: error: enable-targets option must specify target names or 'all'" >&5
+ echo "$as_me: error: enable-targets option must specify target names or 'all'" >&2;}
+    { (exit 1); exit 1; }; }
+@@ -4342,21 +4922,21 @@ echo "$as_me: error: enable-targets opti
+   no)       enable_targets= ;;
+   *)        enable_targets=$enableval ;;
+ esac
+-fi; # Check whether --enable-commonbfdlib or --disable-commonbfdlib was given.
++fi
++# Check whether --enable-commonbfdlib was given.
+ if test "${enable_commonbfdlib+set}" = set; then
+-  enableval="$enable_commonbfdlib"
+-  case "${enableval}" in
++  enableval=$enable_commonbfdlib; case "${enableval}" in
+   yes) commonbfdlib=true ;;
+   no)  commonbfdlib=false ;;
+   *)   { { echo "$as_me:$LINENO: error: bad value ${enableval} for BFD commonbfdlib option" >&5
+ echo "$as_me: error: bad value ${enableval} for BFD commonbfdlib option" >&2;}
+    { (exit 1); exit 1; }; } ;;
+ esac
+-fi;
+-# Check whether --with-mmap or --without-mmap was given.
++fi
++
++# Check whether --with-mmap was given.
+ if test "${with_mmap+set}" = set; then
+-  withval="$with_mmap"
+-  case "${withval}" in
++  withval=$with_mmap; case "${withval}" in
+   yes)  want_mmap=true ;;
+   no)   want_mmap=false ;;
+   *)    { { echo "$as_me:$LINENO: error: bad value ${withval} for BFD with-mmap option" >&5
+@@ -4365,11 +4945,11 @@ echo "$as_me: error: bad value ${withval
+ esac
+ else
+   want_mmap=false
+-fi;
+-# Check whether --enable-secureplt or --disable-secureplt was given.
++fi
++
++# Check whether --enable-secureplt was given.
+ if test "${enable_secureplt+set}" = set; then
+-  enableval="$enable_secureplt"
+-  case "${enableval}" in
++  enableval=$enable_secureplt; case "${enableval}" in
+   yes)  use_secureplt=true  ;;
+   no)   use_secureplt=false ;;
+   *)    { { echo "$as_me:$LINENO: error: bad value ${enableval} for secureplt option" >&5
+@@ -4378,7 +4958,8 @@ echo "$as_me: error: bad value ${enablev
+ esac
+ else
+   use_secureplt=false
+-fi; if test $use_secureplt = true; then
++fi
++if test $use_secureplt = true; then
+ cat >>confdefs.h <<\_ACEOF
+ #define USE_SECUREPLT 1
+@@ -4389,17 +4970,17 @@ fi
+ GCC_WARN_CFLAGS="-W -Wall -Wstrict-prototypes -Wmissing-prototypes"
+-# Check whether --enable-werror or --disable-werror was given.
++# Check whether --enable-werror was given.
+ if test "${enable_werror+set}" = set; then
+-  enableval="$enable_werror"
+-  case "${enableval}" in
++  enableval=$enable_werror; case "${enableval}" in
+      yes | y) ERROR_ON_WARNING="yes" ;;
+      no | n)  ERROR_ON_WARNING="no" ;;
+      *) { { echo "$as_me:$LINENO: error: bad value ${enableval} for --enable-werror" >&5
+ echo "$as_me: error: bad value ${enableval} for --enable-werror" >&2;}
+    { (exit 1); exit 1; }; } ;;
+    esac
+-fi;
++fi
++
+ # Enable -Werror by default when using gcc
+ if test "${GCC}" = yes -a -z "${ERROR_ON_WARNING}" ; then
+@@ -4416,10 +4997,9 @@ if test "${GCC}" = yes ; then
+   WARN_CFLAGS="${GCC_WARN_CFLAGS}"
+ fi
+-# Check whether --enable-build-warnings or --disable-build-warnings was given.
++# Check whether --enable-build-warnings was given.
+ if test "${enable_build_warnings+set}" = set; then
+-  enableval="$enable_build_warnings"
+-  case "${enableval}" in
++  enableval=$enable_build_warnings; case "${enableval}" in
+   yes)        WARN_CFLAGS="${GCC_WARN_CFLAGS}";;
+   no) if test "${GCC}" = yes ; then
+         WARN_CFLAGS="-w"
+@@ -4430,7 +5010,8 @@ if test "${enable_build_warnings+set}" =
+         WARN_CFLAGS="${t} ${GCC_WARN_CFLAGS}";;
+   *)    WARN_CFLAGS=`echo "${enableval}" | sed -e "s/,/ /g"`;;
+ esac
+-fi;
++fi
++
+ if test x"$silent" != x"yes" && test x"$WARN_CFLAGS" != x""; then
+   echo "Setting warning flags = $WARN_CFLAGS" 6>&1
+@@ -4440,7 +5021,7 @@ fi
+-          ac_config_headers="$ac_config_headers config.h:config.in"
++ac_config_headers="$ac_config_headers config.h:config.in"
+ if test -z "$target" ; then
+@@ -4449,17 +5030,17 @@ echo "$as_me: error: Unrecognized target
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
+-echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
+-    # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
++{ echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
++echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6; }
++    # Check whether --enable-maintainer-mode was given.
+ if test "${enable_maintainer_mode+set}" = set; then
+-  enableval="$enable_maintainer_mode"
+-  USE_MAINTAINER_MODE=$enableval
++  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
+ else
+   USE_MAINTAINER_MODE=no
+-fi;
+-  echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
+-echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
++fi
++
++  { echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
++echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6; }
+ if test $USE_MAINTAINER_MODE = yes; then
+@@ -4488,21 +5069,21 @@ esac
+   *) target_noncanonical=${target_alias} ;;
+ esac
+-echo "$as_me:$LINENO: checking whether to install libbfd" >&5
+-echo $ECHO_N "checking whether to install libbfd... $ECHO_C" >&6
+-  # Check whether --enable-install-libbfd or --disable-install-libbfd was given.
++{ echo "$as_me:$LINENO: checking whether to install libbfd" >&5
++echo $ECHO_N "checking whether to install libbfd... $ECHO_C" >&6; }
++  # Check whether --enable-install-libbfd was given.
+ if test "${enable_install_libbfd+set}" = set; then
+-  enableval="$enable_install_libbfd"
+-  install_libbfd_p=$enableval
++  enableval=$enable_install_libbfd; install_libbfd_p=$enableval
+ else
+   if test "${host}" = "${target}" || test "$enable_shared" = "yes"; then
+         install_libbfd_p=yes
+       else
+         install_libbfd_p=no
+       fi
+-fi;
+-  echo "$as_me:$LINENO: result: $install_libbfd_p" >&5
+-echo "${ECHO_T}$install_libbfd_p" >&6
++fi
++
++  { echo "$as_me:$LINENO: result: $install_libbfd_p" >&5
++echo "${ECHO_T}$install_libbfd_p" >&6; }
+ if test $install_libbfd_p = yes; then
+@@ -4545,8 +5126,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4559,32 +5140,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_CC"; then
+   ac_ct_CC=$CC
+   # Extract the first word of "gcc", so it can be a program name with args.
+ set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4597,36 +5180,51 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ else
+   CC="$ac_cv_prog_CC"
+ fi
+ if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4639,74 +5237,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}cc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
+-
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++  fi
+ fi
+ if test -z "$CC"; then
+   # Extract the first word of "cc", so it can be a program name with args.
+ set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4720,7 +5278,7 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+        continue
+@@ -4731,6 +5289,7 @@ do
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ if test $ac_prog_rejected = yes; then
+   # We found a bogon in the path, so make sure we never use it.
+@@ -4748,22 +5307,23 @@ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$CC"; then
+   if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4776,36 +5336,38 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+     test -n "$CC" && break
+   done
+ fi
+ if test -z "$CC"; then
+   ac_ct_CC=$CC
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4818,29 +5380,45 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$ac_ct_CC" && break
+ done
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ fi
+ fi
+@@ -4853,27 +5431,41 @@ See \`config.log' for more details." >&2
+    { (exit 1); exit 1; }; }
+ # Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
++echo "$as_me:$LINENO: checking for C compiler version" >&5
+ ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+ if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4896,50 +5488,49 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+ GCC=`test $ac_compiler_gnu = yes && echo yes`
+ ac_test_CFLAGS=${CFLAGS+set}
+ ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -4955,46 +5546,126 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
+-if test "$ac_test_CFLAGS" = set; then
+-  CFLAGS=$ac_save_CFLAGS
+-elif test $ac_cv_prog_cc_g = yes; then
+-  if test "$GCC" = yes; then
+-    CFLAGS="-g -O2"
+-  else
+-    CFLAGS="-g"
+-  fi
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
++if test "$ac_test_CFLAGS" = set; then
++  CFLAGS=$ac_save_CFLAGS
++elif test $ac_cv_prog_cc_g = yes; then
++  if test "$GCC" = yes; then
++    CFLAGS="-g -O2"
++  else
++    CFLAGS="-g"
++  fi
+ else
+   if test "$GCC" = yes; then
+     CFLAGS="-O2"
+@@ -5002,12 +5673,12 @@ else
+     CFLAGS=
+   fi
+ fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_prog_cc_stdc=no
++  ac_cv_prog_cc_c89=no
+ ac_save_CC=$CC
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -5041,12 +5712,17 @@ static char *f (char * (*g) (char **, in
+ /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+    function prototypes and stuff, but not '\xHH' hex character constants.
+    These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
++   as 'x'.  The following induces an error, until -std is added to get
+    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+    array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
++   that's true only with -std.  */
+ int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
+ int test (int i, double x);
+ struct s1 {int (*f) (int a);};
+ struct s2 {int (*f) (double a);};
+@@ -5061,205 +5737,57 @@ return f (e, argv, 0) != argv[0]  ||  f 
+   return 0;
+ }
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+ do
+   CC="$ac_save_CC $ac_arg"
+   rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext
++
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+-rm -f conftest.$ac_ext conftest.$ac_objext
++rm -f conftest.$ac_ext
+ CC=$ac_save_CC
+ fi
+-
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
+   *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
+ esac
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
+-cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
+-fi
+-
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -5277,8 +5805,8 @@ ALL_LINGUAS="fr tr ja es sv da zh_CN ro 
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5291,32 +5819,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5329,27 +5859,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -5359,8 +5903,8 @@ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
+-echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
++echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }
+ # On Suns, sometimes $CPP names a directory.
+ if test -n "$CPP" && test -d "$CPP"; then
+   CPP=
+@@ -5394,24 +5938,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #endif
+                    Syntax error
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   :
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -5420,9 +5962,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   # Broken: fails on valid input.
+ continue
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
++  # OK, works on sane cases.  Now check whether nonexistent headers
+   # can be detected and how.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -5432,24 +5975,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   # Broken: success on invalid input.
+ continue
+ else
+@@ -5460,6 +6001,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ac_preproc_ok=:
+ break
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+ done
+@@ -5477,8 +6019,8 @@ fi
+ else
+   ac_cv_prog_CPP=$CPP
+ fi
+-echo "$as_me:$LINENO: result: $CPP" >&5
+-echo "${ECHO_T}$CPP" >&6
++{ echo "$as_me:$LINENO: result: $CPP" >&5
++echo "${ECHO_T}$CPP" >&6; }
+ ac_preproc_ok=false
+ for ac_c_preproc_warn_flag in '' yes
+ do
+@@ -5501,24 +6043,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #endif
+                    Syntax error
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   :
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -5527,9 +6067,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   # Broken: fails on valid input.
+ continue
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
++  # OK, works on sane cases.  Now check whether nonexistent headers
+   # can be detected and how.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -5539,24 +6080,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   # Broken: success on invalid input.
+ continue
+ else
+@@ -5567,6 +6106,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ac_preproc_ok=:
+ break
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+ done
+@@ -5589,87 +6129,230 @@ ac_link='$CC -o conftest$ac_exeext $CFLA
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-echo "$as_me:$LINENO: checking for egrep" >&5
+-echo $ECHO_N "checking for egrep... $ECHO_C" >&6
+-if test "${ac_cv_prog_egrep+set}" = set; then
++{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
++echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }
++if test "${ac_cv_path_GREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  # Extract the first word of "grep ggrep" to use in msg output
++if test -z "$GREP"; then
++set dummy grep ggrep; ac_prog_name=$2
++if test "${ac_cv_path_GREP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
+-    then ac_cv_prog_egrep='grep -E'
+-    else ac_cv_prog_egrep='egrep'
++  ac_path_GREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in grep ggrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
++    # Check for GNU ac_path_GREP and select it if it is found.
++  # Check for GNU $ac_path_GREP
++case `"$ac_path_GREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'GREP' >> "conftest.nl"
++    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_GREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_GREP="$ac_path_GREP"
++      ac_path_GREP_max=$ac_count
+     fi
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
+-echo "${ECHO_T}$ac_cv_prog_egrep" >&6
+- EGREP=$ac_cv_prog_egrep
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
+-echo "$as_me:$LINENO: checking for ANSI C header files" >&5
+-echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
+-if test "${ac_cv_header_stdc+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <stdlib.h>
+-#include <stdarg.h>
+-#include <string.h>
+-#include <float.h>
++    $ac_path_GREP_found && break 3
++  done
++done
+-int
+-main ()
+-{
++done
++IFS=$as_save_IFS
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_header_stdc=yes
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_header_stdc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-if test $ac_cv_header_stdc = yes; then
+-  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <string.h>
++GREP="$ac_cv_path_GREP"
++if test -z "$GREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
+-_ACEOF
++else
++  ac_cv_path_GREP=$GREP
++fi
++
++
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
++echo "${ECHO_T}$ac_cv_path_GREP" >&6; }
++ GREP="$ac_cv_path_GREP"
++
++
++{ echo "$as_me:$LINENO: checking for egrep" >&5
++echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }
++if test "${ac_cv_path_EGREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
++   then ac_cv_path_EGREP="$GREP -E"
++   else
++     # Extract the first word of "egrep" to use in msg output
++if test -z "$EGREP"; then
++set dummy egrep; ac_prog_name=$2
++if test "${ac_cv_path_EGREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_path_EGREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in egrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
++    # Check for GNU ac_path_EGREP and select it if it is found.
++  # Check for GNU $ac_path_EGREP
++case `"$ac_path_EGREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'EGREP' >> "conftest.nl"
++    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_EGREP="$ac_path_EGREP"
++      ac_path_EGREP_max=$ac_count
++    fi
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
++
++
++    $ac_path_EGREP_found && break 3
++  done
++done
++
++done
++IFS=$as_save_IFS
++
++
++fi
++
++EGREP="$ac_cv_path_EGREP"
++if test -z "$EGREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
++
++else
++  ac_cv_path_EGREP=$EGREP
++fi
++
++
++   fi
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
++echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }
++ EGREP="$ac_cv_path_EGREP"
++
++
++{ echo "$as_me:$LINENO: checking for ANSI C header files" >&5
++echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
++if test "${ac_cv_header_stdc+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <stdlib.h>
++#include <stdarg.h>
++#include <string.h>
++#include <float.h>
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_header_stdc=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_cv_header_stdc=no
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++
++if test $ac_cv_header_stdc = yes; then
++  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <string.h>
++
++_ACEOF
+ if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+   $EGREP "memchr" >/dev/null 2>&1; then
+   :
+@@ -5713,6 +6396,7 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ctype.h>
++#include <stdlib.h>
+ #if ((' ' & 0x0FF) == 0x020)
+ # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+ # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+@@ -5732,18 +6416,27 @@ main ()
+   for (i = 0; i < 256; i++)
+     if (XOR (islower (i), ISLOWER (i))
+       || toupper (i) != TOUPPER (i))
+-      exit(2);
+-  exit (0);
++      return 2;
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -5756,12 +6449,14 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_header_stdc=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
+-echo "${ECHO_T}$ac_cv_header_stdc" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
++echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
+ if test $ac_cv_header_stdc = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -5770,8 +6465,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
+-echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
++echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; }
+ if test "${ac_cv_c_const+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5789,10 +6484,10 @@ main ()
+ #ifndef __cplusplus
+   /* Ultrix mips cc rejects this.  */
+   typedef int charset[2];
+-  const charset x;
++  const charset cs;
+   /* SunOS 4.1.1 cc rejects this.  */
+-  char const *const *ccp;
+-  char **p;
++  char const *const *pcpcc;
++  char **ppc;
+   /* NEC SVR4.0.2 mips cc rejects this.  */
+   struct point {int x, y;};
+   static struct point const zero = {0,0};
+@@ -5801,16 +6496,17 @@ main ()
+      an arm of an if-expression whose if-part is not a constant
+      expression */
+   const char *g = "string";
+-  ccp = &g + (g ? g-g : 0);
++  pcpcc = &g + (g ? g-g : 0);
+   /* HPUX 7.0 cc rejects these. */
+-  ++ccp;
+-  p = (char**) ccp;
+-  ccp = (char const *const *) p;
++  ++pcpcc;
++  ppc = (char**) pcpcc;
++  pcpcc = (char const *const *) ppc;
+   { /* SCO 3.2v4 cc rejects this.  */
+     char *t;
+     char const *s = 0 ? (char *) 0 : (char const *) 0;
+     *t++ = 0;
++    if (s) return 0;
+   }
+   { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+     int x[] = {25, 17};
+@@ -5829,7 +6525,9 @@ main ()
+   }
+   { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+     const int foo = 10;
++    if (!foo) return 0;
+   }
++  return !cs[0] && !zero.x;
+ #endif
+   ;
+@@ -5837,38 +6535,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_c_const=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_c_const=no
++      ac_cv_c_const=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
+-echo "${ECHO_T}$ac_cv_c_const" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
++echo "${ECHO_T}$ac_cv_c_const" >&6; }
+ if test $ac_cv_c_const = no; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -5877,8 +6571,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for inline" >&5
+-echo $ECHO_N "checking for inline... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for inline" >&5
++echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
+ if test "${ac_cv_c_inline+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5898,39 +6592,37 @@ $ac_kw foo_t foo () {return 0; }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_c_inline=$ac_kw; break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_c_inline=$ac_kw
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++  test "$ac_cv_c_inline" != no && break
+ done
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
+-echo "${ECHO_T}$ac_cv_c_inline" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
++echo "${ECHO_T}$ac_cv_c_inline" >&6; }
+ case $ac_cv_c_inline in
+@@ -5962,9 +6654,9 @@ for ac_header in sys/types.h sys/stat.h 
+                 inttypes.h stdint.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -5978,38 +6670,35 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   eval "$as_ac_Header=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_Header=no"
++      eval "$as_ac_Header=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+@@ -6020,8 +6709,8 @@ fi
+ done
+-echo "$as_me:$LINENO: checking for off_t" >&5
+-echo $ECHO_N "checking for off_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for off_t" >&5
++echo $ECHO_N "checking for off_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_off_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6032,62 +6721,59 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef off_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((off_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (off_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_off_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_off_t=no
++      ac_cv_type_off_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
+-echo "${ECHO_T}$ac_cv_type_off_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
++echo "${ECHO_T}$ac_cv_type_off_t" >&6; }
+ if test $ac_cv_type_off_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define off_t long
++#define off_t long int
+ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for size_t" >&5
+-echo $ECHO_N "checking for size_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for size_t" >&5
++echo $ECHO_N "checking for size_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_size_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6098,64 +6784,61 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef size_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((size_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (size_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_size_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_size_t=no
++      ac_cv_type_size_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
+-echo "${ECHO_T}$ac_cv_type_size_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
++echo "${ECHO_T}$ac_cv_type_size_t" >&6; }
+ if test $ac_cv_type_size_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define size_t unsigned
++#define size_t unsigned int
+ _ACEOF
+ fi
+ # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+ # for constant arguments.  Useless!
+-echo "$as_me:$LINENO: checking for working alloca.h" >&5
+-echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working alloca.h" >&5
++echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6; }
+ if test "${ac_cv_working_alloca_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6170,44 +6853,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (2 * sizeof (int));
++                        if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_working_alloca_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_working_alloca_h=no
++      ac_cv_working_alloca_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
+-echo "${ECHO_T}$ac_cv_working_alloca_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
++echo "${ECHO_T}$ac_cv_working_alloca_h" >&6; }
+ if test $ac_cv_working_alloca_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -6216,8 +6897,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for alloca" >&5
+-echo $ECHO_N "checking for alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for alloca" >&5
++echo $ECHO_N "checking for alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_func_alloca_works+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6234,7 +6915,7 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #  include <malloc.h>
+ #  define alloca _alloca
+ # else
+-#  if HAVE_ALLOCA_H
++#  ifdef HAVE_ALLOCA_H
+ #   include <alloca.h>
+ #  else
+ #   ifdef _AIX
+@@ -6252,44 +6933,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (1);
++                                  if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_func_alloca_works=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_func_alloca_works=no
++      ac_cv_func_alloca_works=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
+-echo "${ECHO_T}$ac_cv_func_alloca_works" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
++echo "${ECHO_T}$ac_cv_func_alloca_works" >&6; }
+ if test $ac_cv_func_alloca_works = yes; then
+@@ -6303,15 +6982,15 @@ else
+ # contain a buggy version.  If you still want to use their alloca,
+ # use ar to extract alloca.o from them instead of compiling alloca.c.
+-ALLOCA=alloca.$ac_objext
++ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
+ cat >>confdefs.h <<\_ACEOF
+ #define C_ALLOCA 1
+ _ACEOF
+-echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
+-echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
++echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6; }
+ if test "${ac_cv_os_cray+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6321,7 +7000,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#if defined(CRAY) && ! defined(CRAY2)
++#if defined CRAY && ! defined CRAY2
+ webecray
+ #else
+ wenotbecray
+@@ -6337,14 +7016,14 @@ fi
+ rm -f conftest*
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
+-echo "${ECHO_T}$ac_cv_os_cray" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
++echo "${ECHO_T}$ac_cv_os_cray" >&6; }
+ if test $ac_cv_os_cray = yes; then
+   for ac_func in _getb67 GETB67 getb67; do
+     as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6370,68 +7049,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -6444,8 +7115,8 @@ fi
+   done
+ fi
+-echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
+-echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
++echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_c_stack_direction+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6458,6 +7129,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
++$ac_includes_default
+ int
+ find_stack_direction ()
+ {
+@@ -6475,17 +7147,26 @@ find_stack_direction ()
+ int
+ main ()
+ {
+-  exit (find_stack_direction () < 0);
++  return find_stack_direction () < 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -6498,11 +7179,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_c_stack_direction=-1
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
+-echo "${ECHO_T}$ac_cv_c_stack_direction" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
++echo "${ECHO_T}$ac_cv_c_stack_direction" >&6; }
+ cat >>confdefs.h <<_ACEOF
+ #define STACK_DIRECTION $ac_cv_c_stack_direction
+@@ -6516,18 +7199,19 @@ fi
+ for ac_header in stdlib.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6538,41 +7222,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6581,24 +7261,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -6606,9 +7284,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -6632,25 +7311,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -6666,9 +7339,9 @@ done
+ for ac_func in getpagesize
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6694,68 +7367,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -6764,8 +7429,8 @@ _ACEOF
+ fi
+ done
+-echo "$as_me:$LINENO: checking for working mmap" >&5
+-echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working mmap" >&5
++echo $ECHO_N "checking for working mmap... $ECHO_C" >&6; }
+ if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6807,21 +7472,21 @@ $ac_includes_default
+ #include <fcntl.h>
+ #include <sys/mman.h>
+-#if !STDC_HEADERS && !HAVE_STDLIB_H
++#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H
+ char *malloc ();
+ #endif
+ /* This mess was copied from the GNU getpagesize.h.  */
+-#if !HAVE_GETPAGESIZE
++#ifndef HAVE_GETPAGESIZE
+ /* Assume that all systems that can run configure have sys/param.h.  */
+-# if !HAVE_SYS_PARAM_H
++# ifndef HAVE_SYS_PARAM_H
+ #  define HAVE_SYS_PARAM_H 1
+ # endif
+ # ifdef _SC_PAGESIZE
+ #  define getpagesize() sysconf(_SC_PAGESIZE)
+ # else /* no _SC_PAGESIZE */
+-#  if HAVE_SYS_PARAM_H
++#  ifdef HAVE_SYS_PARAM_H
+ #   include <sys/param.h>
+ #   ifdef EXEC_PAGESIZE
+ #    define getpagesize() EXEC_PAGESIZE
+@@ -6860,15 +7525,15 @@ main ()
+   /* First, make a file with some known garbage in it. */
+   data = (char *) malloc (pagesize);
+   if (!data)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     *(data + i) = rand ();
+   umask (0);
+   fd = creat ("conftest.mmap", 0600);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   if (write (fd, data, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   close (fd);
+   /* Next, try to mmap the file at a fixed address which already has
+@@ -6876,17 +7541,17 @@ main ()
+      we see the same garbage.  */
+   fd = open ("conftest.mmap", O_RDWR);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   data2 = (char *) malloc (2 * pagesize);
+   if (!data2)
+-    exit (1);
+-  data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
++    return 1;
++  data2 += (pagesize - ((long int) data2 & (pagesize - 1))) & (pagesize - 1);
+   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_FIXED, fd, 0L))
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data2 + i))
+-      exit (1);
++      return 1;
+   /* Finally, make sure that changes to the mapped area do not
+      percolate back to the file as seen by read().  (This is a bug on
+@@ -6895,24 +7560,33 @@ main ()
+     *(data2 + i) = *(data2 + i) + 1;
+   data3 = (char *) malloc (pagesize);
+   if (!data3)
+-    exit (1);
++    return 1;
+   if (read (fd, data3, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data3 + i))
+-      exit (1);
++      return 1;
+   close (fd);
+-  exit (0);
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -6925,11 +7599,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_func_mmap_fixed_mapped=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
+-echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
++echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6; }
+ if test $ac_cv_func_mmap_fixed_mapped = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -6953,18 +7629,19 @@ for ac_header in argz.h limits.h locale.
+ unistd.h values.h sys/param.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6975,41 +7652,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7018,24 +7691,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -7043,9 +7714,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -7069,25 +7741,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -7113,9 +7779,9 @@ for ac_func in getcwd munmap putenv sete
+ __argz_count __argz_stringify __argz_next
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7141,68 +7807,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7217,9 +7875,9 @@ done
+ for ac_func in stpcpy
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7245,68 +7903,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7325,8 +7975,8 @@ _ACEOF
+    fi
+    if test $ac_cv_header_locale_h = yes; then
+-    echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
+-echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
++echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6; }
+ if test "${am_cv_val_LC_MESSAGES+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7346,39 +7996,36 @@ return LC_MESSAGES
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   am_cv_val_LC_MESSAGES=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-am_cv_val_LC_MESSAGES=no
++      am_cv_val_LC_MESSAGES=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
+-echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
++echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6; }
+     if test $am_cv_val_LC_MESSAGES = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -7387,34 +8034,34 @@ _ACEOF
+     fi
+   fi
+-   echo "$as_me:$LINENO: checking whether NLS is requested" >&5
+-echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6
+-        # Check whether --enable-nls or --disable-nls was given.
++   { echo "$as_me:$LINENO: checking whether NLS is requested" >&5
++echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6; }
++        # Check whether --enable-nls was given.
+ if test "${enable_nls+set}" = set; then
+-  enableval="$enable_nls"
+-  USE_NLS=$enableval
++  enableval=$enable_nls; USE_NLS=$enableval
+ else
+   USE_NLS=yes
+-fi;
+-    echo "$as_me:$LINENO: result: $USE_NLS" >&5
+-echo "${ECHO_T}$USE_NLS" >&6
++fi
++
++    { echo "$as_me:$LINENO: result: $USE_NLS" >&5
++echo "${ECHO_T}$USE_NLS" >&6; }
+     USE_INCLUDED_LIBINTL=no
+         if test "$USE_NLS" = "yes"; then
+-      echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
+-echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6
++      { echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
++echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6; }
+-# Check whether --with-included-gettext or --without-included-gettext was given.
++# Check whether --with-included-gettext was given.
+ if test "${with_included_gettext+set}" = set; then
+-  withval="$with_included_gettext"
+-  nls_cv_force_use_gnu_gettext=$withval
++  withval=$with_included_gettext; nls_cv_force_use_gnu_gettext=$withval
+ else
+   nls_cv_force_use_gnu_gettext=no
+-fi;
+-      echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
+-echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6
++fi
++
++      { echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
++echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6; }
+       nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext"
+       if test "$nls_cv_force_use_gnu_gettext" != "yes"; then
+@@ -7423,17 +8070,17 @@ echo "${ECHO_T}$nls_cv_force_use_gnu_get
+       CATOBJEXT=
+       if test "${ac_cv_header_libintl_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking libintl.h usability" >&5
+-echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h usability" >&5
++echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7444,41 +8091,37 @@ $ac_includes_default
+ #include <libintl.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking libintl.h presence" >&5
+-echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h presence" >&5
++echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7487,24 +8130,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <libintl.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -7512,9 +8153,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -7538,30 +8180,23 @@ echo "$as_me: WARNING: libintl.h:     se
+ echo "$as_me: WARNING: libintl.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: libintl.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: libintl.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_libintl_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ fi
+ if test $ac_cv_header_libintl_h = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libc" >&5
+-echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libc" >&5
++echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libc+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7581,43 +8216,40 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libc=no
++      gt_cv_func_gettext_libc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6; }
+          if test "$gt_cv_func_gettext_libc" != "yes"; then
+-           echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
+-echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6
++           { echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
++echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6; }
+ if test "${ac_cv_lib_intl_bindtextdomain+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7630,59 +8262,56 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char bindtextdomain ();
+ int
+ main ()
+ {
+-bindtextdomain ();
++return bindtextdomain ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_lib_intl_bindtextdomain=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_intl_bindtextdomain=no
++      ac_cv_lib_intl_bindtextdomain=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
+-echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
++echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6; }
+ if test $ac_cv_lib_intl_bindtextdomain = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libintl" >&5
+-echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libintl" >&5
++echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libintl+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7702,39 +8331,36 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libintl=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libintl=no
++      gt_cv_func_gettext_libintl=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6; }
+ fi
+          fi
+@@ -7748,8 +8374,8 @@ _ACEOF
+             # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7775,20 +8401,20 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+             if test "$MSGFMT" != "no"; then
+ for ac_func in dcgettext
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7814,68 +8440,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7886,8 +8504,8 @@ done
+               # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7902,32 +8520,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+               # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7953,11 +8572,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+               cat >conftest.$ac_ext <<_ACEOF
+@@ -7977,37 +8596,34 @@ extern int _nl_msg_cat_cntr;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   CATOBJEXT=.gmo
+                  DATADIRNAME=share
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-CATOBJEXT=.mo
++      CATOBJEXT=.mo
+                  DATADIRNAME=lib
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+               INSTOBJEXT=.mo
+             fi
+@@ -8029,8 +8645,8 @@ fi
+                 INTLOBJS="\$(GETTOBJS)"
+         # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8056,17 +8672,17 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+         # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8081,32 +8697,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+         # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8132,11 +8749,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+@@ -8155,8 +8772,8 @@ fi
+                       if $XGETTEXT --omit-header /dev/null 2> /dev/null; then
+         : ;
+       else
+-        echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
+-echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6
++        { echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
++echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6; }
+         XGETTEXT=":"
+       fi
+       fi
+@@ -8205,8 +8822,8 @@ _ACEOF
+      if test "x$ALL_LINGUAS" = "x"; then
+        LINGUAS=
+      else
+-       echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
+-echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6
++       { echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
++echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6; }
+        NEW_LINGUAS=
+        for lang in ${LINGUAS=$ALL_LINGUAS}; do
+          case "$ALL_LINGUAS" in
+@@ -8214,8 +8831,8 @@ echo $ECHO_N "checking for catalogs to b
+          esac
+        done
+        LINGUAS=$NEW_LINGUAS
+-       echo "$as_me:$LINENO: result: $LINGUAS" >&5
+-echo "${ECHO_T}$LINGUAS" >&6
++       { echo "$as_me:$LINENO: result: $LINGUAS" >&5
++echo "${ECHO_T}$LINGUAS" >&6; }
+      fi
+           if test -n "$LINGUAS"; then
+@@ -8234,17 +8851,17 @@ echo "${ECHO_T}$LINGUAS" >&6
+             if test -f $srcdir/po2tbl.sed.in; then
+       if test "$CATOBJEXT" = ".cat"; then
+        if test "${ac_cv_header_linux_version_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking linux/version.h usability" >&5
+-echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h usability" >&5
++echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8255,41 +8872,37 @@ $ac_includes_default
+ #include <linux/version.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking linux/version.h presence" >&5
+-echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h presence" >&5
++echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8298,24 +8911,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <linux/version.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -8323,9 +8934,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -8349,25 +8961,18 @@ echo "$as_me: WARNING: linux/version.h: 
+ echo "$as_me: WARNING: linux/version.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: linux/version.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: linux/version.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_linux_version_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ fi
+ if test $ac_cv_header_linux_version_h = yes; then
+@@ -8434,8 +9039,8 @@ fi
+ # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+ # OS/2's system install, which has a completely different semantic
+ # ./install, which can be erroneously created by make from ./install.sh.
+-echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+-echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+ if test -z "$INSTALL"; then
+ if test "${ac_cv_path_install+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -8457,7 +9062,7 @@ case $as_dir/ in
+     # by default.
+     for ac_prog in ginstall scoinst install; do
+       for ac_exec_ext in '' $ac_executable_extensions; do
+-      if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
++      if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+         if test $ac_prog = install &&
+           grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+           # AIX install.  It has an incompatible calling convention.
+@@ -8476,21 +9081,22 @@ case $as_dir/ in
+     ;;
+ esac
+ done
++IFS=$as_save_IFS
+ fi
+   if test "${ac_cv_path_install+set}" = set; then
+     INSTALL=$ac_cv_path_install
+   else
+-    # As a last resort, use the slow shell script.  We don't cache a
+-    # path for INSTALL within a source directory, because that will
++    # As a last resort, use the slow shell script.  Don't cache a
++    # value for INSTALL within a source directory, because that will
+     # break other packages using the cache if that directory is
+-    # removed, or if the path is relative.
++    # removed, or if the value is a relative name.
+     INSTALL=$ac_install_sh
+   fi
+ fi
+-echo "$as_me:$LINENO: result: $INSTALL" >&5
+-echo "${ECHO_T}$INSTALL" >&6
++{ echo "$as_me:$LINENO: result: $INSTALL" >&5
++echo "${ECHO_T}$INSTALL" >&6; }
+ # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+ # It thinks the first close brace ends the variable substitution.
+@@ -8507,8 +9113,8 @@ BFD_HOST_64_BIT_DEFINED=0
+ BFD_HOST_64_BIT=
+ BFD_HOST_U_64_BIT=
+-echo "$as_me:$LINENO: checking for long long" >&5
+-echo $ECHO_N "checking for long long... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for long long" >&5
++echo $ECHO_N "checking for long long... $ECHO_C" >&6; }
+ if test "${bfd_cv_has_long_long+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8528,43 +9134,39 @@ unsigned long long ll = 1844674407370955
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_has_long_long=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_has_long_long=no
++      bfd_cv_has_long_long=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $bfd_cv_has_long_long" >&5
+-echo "${ECHO_T}$bfd_cv_has_long_long" >&6
++{ echo "$as_me:$LINENO: result: $bfd_cv_has_long_long" >&5
++echo "${ECHO_T}$bfd_cv_has_long_long" >&6; }
+ if test $bfd_cv_has_long_long = yes; then
+   BFD_HOST_LONG_LONG=1
+-  echo "$as_me:$LINENO: checking for long long" >&5
+-echo $ECHO_N "checking for long long... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for long long" >&5
++echo $ECHO_N "checking for long long... $ECHO_C" >&6; }
+ if test "${ac_cv_type_long_long+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8575,61 +9177,57 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef long long ac__type_new_;
+ int
+ main ()
+ {
+-if ((long long *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (long long))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_long_long=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_long_long=no
++      ac_cv_type_long_long=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5
+-echo "${ECHO_T}$ac_cv_type_long_long" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5
++echo "${ECHO_T}$ac_cv_type_long_long" >&6; }
+-echo "$as_me:$LINENO: checking size of long long" >&5
+-echo $ECHO_N "checking size of long long... $ECHO_C" >&6
++# The cast to long int works around a bug in the HP C Compiler
++# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
++# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
++# This bug is HP SR number 8606223364.
++{ echo "$as_me:$LINENO: checking size of long long" >&5
++echo $ECHO_N "checking size of long long... $ECHO_C" >&6; }
+ if test "${ac_cv_sizeof_long_long+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if test "$ac_cv_type_long_long" = yes; then
+-  # The cast to unsigned long works around a bug in the HP C Compiler
+-  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+-  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+-  # This bug is HP SR number 8606223364.
+   if test "$cross_compiling" = yes; then
+   # Depending upon the size, compute the lo and hi bounds.
+ cat >conftest.$ac_ext <<_ACEOF
+@@ -8639,10 +9237,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= 0)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
+ test_array [0] = 0
+   ;
+@@ -8650,27 +9249,22 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_lo=0 ac_mid=0
+   while :; do
+     cat >conftest.$ac_ext <<_ACEOF
+@@ -8680,10 +9274,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
+ test_array [0] = 0
+   ;
+@@ -8691,56 +9286,53 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_hi=$ac_mid; break
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_lo=`expr $ac_mid + 1`
+-                  if test $ac_lo -le $ac_mid; then
+-                    ac_lo= ac_hi=
+-                    break
+-                  fi
+-                  ac_mid=`expr 2 '*' $ac_mid + 1`
++      ac_lo=`expr $ac_mid + 1`
++                      if test $ac_lo -le $ac_mid; then
++                        ac_lo= ac_hi=
++                        break
++                      fi
++                      ac_mid=`expr 2 '*' $ac_mid + 1`
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   done
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-cat >conftest.$ac_ext <<_ACEOF
++      cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long long))) < 0)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
+ test_array [0] = 0
+   ;
+@@ -8748,27 +9340,22 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_hi=-1 ac_mid=-1
+   while :; do
+     cat >conftest.$ac_ext <<_ACEOF
+@@ -8778,10 +9365,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= $ac_mid)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
+ test_array [0] = 0
+   ;
+@@ -8789,50 +9377,48 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_lo=$ac_mid; break
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_hi=`expr '(' $ac_mid ')' - 1`
+-                     if test $ac_mid -le $ac_hi; then
+-                       ac_lo= ac_hi=
+-                       break
+-                     fi
+-                     ac_mid=`expr 2 '*' $ac_mid`
++      ac_hi=`expr '(' $ac_mid ')' - 1`
++                      if test $ac_mid -le $ac_hi; then
++                        ac_lo= ac_hi=
++                        break
++                      fi
++                      ac_mid=`expr 2 '*' $ac_mid`
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   done
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_lo= ac_hi=
++      ac_lo= ac_hi=
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ # Binary search between lo and hi bounds.
+ while test "x$ac_lo" != "x$ac_hi"; do
+   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
+@@ -8843,10 +9429,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
+ test_array [0] = 0
+   ;
+@@ -8854,52 +9441,45 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_hi=$ac_mid
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_lo=`expr '(' $ac_mid ')' + 1`
++      ac_lo=`expr '(' $ac_mid ')' + 1`
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ done
+ case $ac_lo in
+ ?*) ac_cv_sizeof_long_long=$ac_lo;;
+-'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77
++'') if test "$ac_cv_type_long_long" = yes; then
++     { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long)
+ See \`config.log' for more details." >&5
+-echo "$as_me: error: cannot compute sizeof (long long), 77
++echo "$as_me: error: cannot compute sizeof (long long)
+ See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; } ;;
++   { (exit 77); exit 77; }; }
++   else
++     ac_cv_sizeof_long_long=0
++   fi ;;
+ esac
+ else
+-  if test "$cross_compiling" = yes; then
+-  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
+-See \`config.log' for more details." >&5
+-echo "$as_me: error: cannot run test program while cross compiling
+-See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; }
+-else
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8907,8 +9487,9 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
+-long longval () { return (long) (sizeof (long long)); }
+-unsigned long ulongval () { return (long) (sizeof (long long)); }
++   typedef long long ac__type_sizeof_;
++static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
++static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
+ #include <stdio.h>
+ #include <stdlib.h>
+ int
+@@ -8917,35 +9498,44 @@ main ()
+   FILE *f = fopen ("conftest.val", "w");
+   if (! f)
+-    exit (1);
+-  if (((long) (sizeof (long long))) < 0)
++    return 1;
++  if (((long int) (sizeof (ac__type_sizeof_))) < 0)
+     {
+-      long i = longval ();
+-      if (i != ((long) (sizeof (long long))))
+-      exit (1);
++      long int i = longval ();
++      if (i != ((long int) (sizeof (ac__type_sizeof_))))
++      return 1;
+       fprintf (f, "%ld\n", i);
+     }
+   else
+     {
+-      unsigned long i = ulongval ();
+-      if (i != ((long) (sizeof (long long))))
+-      exit (1);
++      unsigned long int i = ulongval ();
++      if (i != ((long int) (sizeof (ac__type_sizeof_))))
++      return 1;
+       fprintf (f, "%lu\n", i);
+     }
+-  exit (ferror (f) || fclose (f) != 0);
++  return ferror (f) || fclose (f) != 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -8956,22 +9546,25 @@ echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+-{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77
++if test "$ac_cv_type_long_long" = yes; then
++     { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long)
+ See \`config.log' for more details." >&5
+-echo "$as_me: error: cannot compute sizeof (long long), 77
++echo "$as_me: error: cannot compute sizeof (long long)
+ See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; }
+-fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++   { (exit 77); exit 77; }; }
++   else
++     ac_cv_sizeof_long_long=0
++   fi
+ fi
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
+ rm -f conftest.val
+-else
+-  ac_cv_sizeof_long_long=0
+-fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5
+-echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5
++echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6; }
++
++
++
+ cat >>confdefs.h <<_ACEOF
+ #define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long
+ _ACEOF
+@@ -8979,8 +9572,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for long" >&5
+-echo $ECHO_N "checking for long... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for long" >&5
++echo $ECHO_N "checking for long... $ECHO_C" >&6; }
+ if test "${ac_cv_type_long+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8991,61 +9584,57 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef long ac__type_new_;
+ int
+ main ()
+ {
+-if ((long *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (long))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_long=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_long=no
++      ac_cv_type_long=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
+-echo "${ECHO_T}$ac_cv_type_long" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
++echo "${ECHO_T}$ac_cv_type_long" >&6; }
+-echo "$as_me:$LINENO: checking size of long" >&5
+-echo $ECHO_N "checking size of long... $ECHO_C" >&6
++# The cast to long int works around a bug in the HP C Compiler
++# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
++# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
++# This bug is HP SR number 8606223364.
++{ echo "$as_me:$LINENO: checking size of long" >&5
++echo $ECHO_N "checking size of long... $ECHO_C" >&6; }
+ if test "${ac_cv_sizeof_long+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if test "$ac_cv_type_long" = yes; then
+-  # The cast to unsigned long works around a bug in the HP C Compiler
+-  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+-  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+-  # This bug is HP SR number 8606223364.
+   if test "$cross_compiling" = yes; then
+   # Depending upon the size, compute the lo and hi bounds.
+ cat >conftest.$ac_ext <<_ACEOF
+@@ -9055,10 +9644,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
+ test_array [0] = 0
+   ;
+@@ -9066,27 +9656,22 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_lo=0 ac_mid=0
+   while :; do
+     cat >conftest.$ac_ext <<_ACEOF
+@@ -9096,10 +9681,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
+ test_array [0] = 0
+   ;
+@@ -9107,56 +9693,53 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_hi=$ac_mid; break
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_lo=`expr $ac_mid + 1`
+-                  if test $ac_lo -le $ac_mid; then
+-                    ac_lo= ac_hi=
+-                    break
+-                  fi
+-                  ac_mid=`expr 2 '*' $ac_mid + 1`
++      ac_lo=`expr $ac_mid + 1`
++                      if test $ac_lo -le $ac_mid; then
++                        ac_lo= ac_hi=
++                        break
++                      fi
++                      ac_mid=`expr 2 '*' $ac_mid + 1`
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   done
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-cat >conftest.$ac_ext <<_ACEOF
++      cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
+ test_array [0] = 0
+   ;
+@@ -9164,27 +9747,22 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_hi=-1 ac_mid=-1
+   while :; do
+     cat >conftest.$ac_ext <<_ACEOF
+@@ -9194,10 +9772,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
+ test_array [0] = 0
+   ;
+@@ -9205,50 +9784,48 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_lo=$ac_mid; break
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_hi=`expr '(' $ac_mid ')' - 1`
+-                     if test $ac_mid -le $ac_hi; then
+-                       ac_lo= ac_hi=
+-                       break
+-                     fi
+-                     ac_mid=`expr 2 '*' $ac_mid`
++      ac_hi=`expr '(' $ac_mid ')' - 1`
++                      if test $ac_mid -le $ac_hi; then
++                        ac_lo= ac_hi=
++                        break
++                      fi
++                      ac_mid=`expr 2 '*' $ac_mid`
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   done
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_lo= ac_hi=
++      ac_lo= ac_hi=
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ # Binary search between lo and hi bounds.
+ while test "x$ac_lo" != "x$ac_hi"; do
+   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
+@@ -9259,10 +9836,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef long ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
+ test_array [0] = 0
+   ;
+@@ -9270,52 +9848,45 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_hi=$ac_mid
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_lo=`expr '(' $ac_mid ')' + 1`
++      ac_lo=`expr '(' $ac_mid ')' + 1`
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ done
+ case $ac_lo in
+ ?*) ac_cv_sizeof_long=$ac_lo;;
+-'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
++'') if test "$ac_cv_type_long" = yes; then
++     { { echo "$as_me:$LINENO: error: cannot compute sizeof (long)
+ See \`config.log' for more details." >&5
+-echo "$as_me: error: cannot compute sizeof (long), 77
++echo "$as_me: error: cannot compute sizeof (long)
+ See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; } ;;
++   { (exit 77); exit 77; }; }
++   else
++     ac_cv_sizeof_long=0
++   fi ;;
+ esac
+ else
+-  if test "$cross_compiling" = yes; then
+-  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
+-See \`config.log' for more details." >&5
+-echo "$as_me: error: cannot run test program while cross compiling
+-See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; }
+-else
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9323,8 +9894,9 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
+-long longval () { return (long) (sizeof (long)); }
+-unsigned long ulongval () { return (long) (sizeof (long)); }
++   typedef long ac__type_sizeof_;
++static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
++static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
+ #include <stdio.h>
+ #include <stdlib.h>
+ int
+@@ -9333,35 +9905,44 @@ main ()
+   FILE *f = fopen ("conftest.val", "w");
+   if (! f)
+-    exit (1);
+-  if (((long) (sizeof (long))) < 0)
++    return 1;
++  if (((long int) (sizeof (ac__type_sizeof_))) < 0)
+     {
+-      long i = longval ();
+-      if (i != ((long) (sizeof (long))))
+-      exit (1);
++      long int i = longval ();
++      if (i != ((long int) (sizeof (ac__type_sizeof_))))
++      return 1;
+       fprintf (f, "%ld\n", i);
+     }
+   else
+     {
+-      unsigned long i = ulongval ();
+-      if (i != ((long) (sizeof (long))))
+-      exit (1);
++      unsigned long int i = ulongval ();
++      if (i != ((long int) (sizeof (ac__type_sizeof_))))
++      return 1;
+       fprintf (f, "%lu\n", i);
+     }
+-  exit (ferror (f) || fclose (f) != 0);
++  return ferror (f) || fclose (f) != 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -9372,22 +9953,25 @@ echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+-{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
++if test "$ac_cv_type_long" = yes; then
++     { { echo "$as_me:$LINENO: error: cannot compute sizeof (long)
+ See \`config.log' for more details." >&5
+-echo "$as_me: error: cannot compute sizeof (long), 77
++echo "$as_me: error: cannot compute sizeof (long)
+ See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; }
+-fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++   { (exit 77); exit 77; }; }
++   else
++     ac_cv_sizeof_long=0
++   fi
+ fi
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
+ rm -f conftest.val
+-else
+-  ac_cv_sizeof_long=0
+-fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
+-echo "${ECHO_T}$ac_cv_sizeof_long" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
++echo "${ECHO_T}$ac_cv_sizeof_long" >&6; }
++
++
++
+ cat >>confdefs.h <<_ACEOF
+ #define SIZEOF_LONG $ac_cv_sizeof_long
+ _ACEOF
+@@ -9428,8 +10012,8 @@ fi
+ if test "x$cross_compiling" = "xno"; then
+   EXEEXT_FOR_BUILD='$(EXEEXT)'
+ else
+-  echo "$as_me:$LINENO: checking for build system executable suffix" >&5
+-echo $ECHO_N "checking for build system executable suffix... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for build system executable suffix" >&5
++echo $ECHO_N "checking for build system executable suffix... $ECHO_C" >&6; }
+ if test "${bfd_cv_build_exeext+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9446,8 +10030,8 @@ else
+      rm -f conftest*
+      test x"${bfd_cv_build_exeext}" = x && bfd_cv_build_exeext=no
+ fi
+-echo "$as_me:$LINENO: result: $bfd_cv_build_exeext" >&5
+-echo "${ECHO_T}$bfd_cv_build_exeext" >&6
++{ echo "$as_me:$LINENO: result: $bfd_cv_build_exeext" >&5
++echo "${ECHO_T}$bfd_cv_build_exeext" >&6; }
+   EXEEXT_FOR_BUILD=""
+   test x"${bfd_cv_build_exeext}" != xno && EXEEXT_FOR_BUILD=${bfd_cv_build_exeext}
+ fi
+@@ -9462,18 +10046,19 @@ fi
+ for ac_header in stddef.h string.h strings.h stdlib.h time.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9484,41 +10069,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9527,24 +10108,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -9552,9 +10131,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -9578,25 +10158,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -9614,18 +10188,19 @@ done
+ for ac_header in fcntl.h sys/file.h sys/time.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9636,41 +10211,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9679,24 +10250,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -9704,9 +10273,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -9730,25 +10300,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -9760,8 +10324,8 @@ fi
+ done
+-echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
+-echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
++echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6; }
+ if test "${ac_cv_header_time+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9785,38 +10349,34 @@ return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_header_time=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_header_time=no
++      ac_cv_header_time=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
+-echo "${ECHO_T}$ac_cv_header_time" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
++echo "${ECHO_T}$ac_cv_header_time" >&6; }
+ if test $ac_cv_header_time = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -9833,9 +10393,9 @@ fi
+ ac_header_dirent=no
+ for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do
+   as_ac_Header=`echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_hdr that defines DIR" >&5
+-echo $ECHO_N "checking for $ac_hdr that defines DIR... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_hdr that defines DIR" >&5
++echo $ECHO_N "checking for $ac_hdr that defines DIR... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -9857,38 +10417,35 @@ return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   eval "$as_ac_Header=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_Header=no"
++      eval "$as_ac_Header=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_hdr" | $as_tr_cpp` 1
+@@ -9900,13 +10457,12 @@ fi
+ done
+ # Two versions of opendir et al. are in -ldir and -lx on SCO Xenix.
+ if test $ac_header_dirent = dirent.h; then
+-  echo "$as_me:$LINENO: checking for library containing opendir" >&5
+-echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for library containing opendir" >&5
++echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6; }
+ if test "${ac_cv_search_opendir+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_opendir=no
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9914,126 +10470,83 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char opendir ();
+ int
+ main ()
+ {
+-opendir ();
++return opendir ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++for ac_lib in '' dir; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_opendir="none required"
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_opendir=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_opendir" = no; then
+-  for ac_lib in dir; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char opendir ();
+-int
+-main ()
+-{
+-opendir ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_opendir="-l$ac_lib"
+-break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++fi
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_opendir+set}" = set; then
++  break
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++done
++if test "${ac_cv_search_opendir+set}" = set; then
++  :
++else
++  ac_cv_search_opendir=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5
+-echo "${ECHO_T}$ac_cv_search_opendir" >&6
+-if test "$ac_cv_search_opendir" != no; then
+-  test "$ac_cv_search_opendir" = "none required" || LIBS="$ac_cv_search_opendir $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5
++echo "${ECHO_T}$ac_cv_search_opendir" >&6; }
++ac_res=$ac_cv_search_opendir
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+ else
+-  echo "$as_me:$LINENO: checking for library containing opendir" >&5
+-echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for library containing opendir" >&5
++echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6; }
+ if test "${ac_cv_search_opendir+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_opendir=no
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -10041,122 +10554,80 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char opendir ();
+ int
+ main ()
+ {
+-opendir ();
++return opendir ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++for ac_lib in '' x; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_opendir="none required"
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_opendir=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_opendir" = no; then
+-  for ac_lib in x; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char opendir ();
+-int
+-main ()
+-{
+-opendir ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_opendir="-l$ac_lib"
+-break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++fi
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_opendir+set}" = set; then
++  break
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++done
++if test "${ac_cv_search_opendir+set}" = set; then
++  :
++else
++  ac_cv_search_opendir=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5
+-echo "${ECHO_T}$ac_cv_search_opendir" >&6
+-if test "$ac_cv_search_opendir" != no; then
+-  test "$ac_cv_search_opendir" = "none required" || LIBS="$ac_cv_search_opendir $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5
++echo "${ECHO_T}$ac_cv_search_opendir" >&6; }
++ac_res=$ac_cv_search_opendir
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+ fi
+-echo "$as_me:$LINENO: checking whether string.h and strings.h may both be included" >&5
+-echo $ECHO_N "checking whether string.h and strings.h may both be included... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether string.h and strings.h may both be included" >&5
++echo $ECHO_N "checking whether string.h and strings.h may both be included... $ECHO_C" >&6; }
+ if test "${gcc_cv_header_string+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10177,38 +10648,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   gcc_cv_header_string=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gcc_cv_header_string=no
++      gcc_cv_header_string=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gcc_cv_header_string" >&5
+-echo "${ECHO_T}$gcc_cv_header_string" >&6
++{ echo "$as_me:$LINENO: result: $gcc_cv_header_string" >&5
++echo "${ECHO_T}$gcc_cv_header_string" >&6; }
+ if test $gcc_cv_header_string = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -10227,9 +10694,9 @@ fi
+ for ac_func in fcntl getpagesize setitimer sysconf fdopen getuid getgid
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -10255,68 +10722,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -10329,9 +10788,9 @@ done
+ for ac_func in strtoull
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -10357,68 +10816,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -10428,8 +10879,8 @@ fi
+ done
+-echo "$as_me:$LINENO: checking whether basename is declared" >&5
+-echo $ECHO_N "checking whether basename is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether basename is declared" >&5
++echo $ECHO_N "checking whether basename is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_basename+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10444,7 +10895,7 @@ int
+ main ()
+ {
+ #ifndef basename
+-  char *p = (char *) basename;
++  (void) basename;
+ #endif
+   ;
+@@ -10452,38 +10903,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_basename=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_basename=no
++      ac_cv_have_decl_basename=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_basename" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_basename" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_basename" >&5
++echo "${ECHO_T}$ac_cv_have_decl_basename" >&6; }
+ if test $ac_cv_have_decl_basename = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10500,8 +10947,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether ftello is declared" >&5
+-echo $ECHO_N "checking whether ftello is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether ftello is declared" >&5
++echo $ECHO_N "checking whether ftello is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_ftello+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10516,7 +10963,7 @@ int
+ main ()
+ {
+ #ifndef ftello
+-  char *p = (char *) ftello;
++  (void) ftello;
+ #endif
+   ;
+@@ -10524,38 +10971,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_ftello=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_ftello=no
++      ac_cv_have_decl_ftello=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_ftello" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_ftello" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_ftello" >&5
++echo "${ECHO_T}$ac_cv_have_decl_ftello" >&6; }
+ if test $ac_cv_have_decl_ftello = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10572,8 +11015,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether ftello64 is declared" >&5
+-echo $ECHO_N "checking whether ftello64 is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether ftello64 is declared" >&5
++echo $ECHO_N "checking whether ftello64 is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_ftello64+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10588,7 +11031,7 @@ int
+ main ()
+ {
+ #ifndef ftello64
+-  char *p = (char *) ftello64;
++  (void) ftello64;
+ #endif
+   ;
+@@ -10596,38 +11039,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_ftello64=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_ftello64=no
++      ac_cv_have_decl_ftello64=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_ftello64" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_ftello64" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_ftello64" >&5
++echo "${ECHO_T}$ac_cv_have_decl_ftello64" >&6; }
+ if test $ac_cv_have_decl_ftello64 = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10644,8 +11083,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether fseeko is declared" >&5
+-echo $ECHO_N "checking whether fseeko is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether fseeko is declared" >&5
++echo $ECHO_N "checking whether fseeko is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_fseeko+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10660,7 +11099,7 @@ int
+ main ()
+ {
+ #ifndef fseeko
+-  char *p = (char *) fseeko;
++  (void) fseeko;
+ #endif
+   ;
+@@ -10668,38 +11107,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_fseeko=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_fseeko=no
++      ac_cv_have_decl_fseeko=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_fseeko" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_fseeko" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_fseeko" >&5
++echo "${ECHO_T}$ac_cv_have_decl_fseeko" >&6; }
+ if test $ac_cv_have_decl_fseeko = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10716,8 +11151,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether fseeko64 is declared" >&5
+-echo $ECHO_N "checking whether fseeko64 is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether fseeko64 is declared" >&5
++echo $ECHO_N "checking whether fseeko64 is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_fseeko64+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10732,7 +11167,7 @@ int
+ main ()
+ {
+ #ifndef fseeko64
+-  char *p = (char *) fseeko64;
++  (void) fseeko64;
+ #endif
+   ;
+@@ -10740,38 +11175,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_fseeko64=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_fseeko64=no
++      ac_cv_have_decl_fseeko64=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_fseeko64" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_fseeko64" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_fseeko64" >&5
++echo "${ECHO_T}$ac_cv_have_decl_fseeko64" >&6; }
+ if test $ac_cv_have_decl_fseeko64 = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10799,8 +11230,8 @@ _ACEOF
+  ;;
+ esac
+-echo "$as_me:$LINENO: checking whether ffs is declared" >&5
+-echo $ECHO_N "checking whether ffs is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether ffs is declared" >&5
++echo $ECHO_N "checking whether ffs is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_ffs+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10815,7 +11246,7 @@ int
+ main ()
+ {
+ #ifndef ffs
+-  char *p = (char *) ffs;
++  (void) ffs;
+ #endif
+   ;
+@@ -10823,38 +11254,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_ffs=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_ffs=no
++      ac_cv_have_decl_ffs=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_ffs" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_ffs" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_ffs" >&5
++echo "${ECHO_T}$ac_cv_have_decl_ffs" >&6; }
+ if test $ac_cv_have_decl_ffs = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10871,8 +11298,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether free is declared" >&5
+-echo $ECHO_N "checking whether free is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether free is declared" >&5
++echo $ECHO_N "checking whether free is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_free+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10887,7 +11314,7 @@ int
+ main ()
+ {
+ #ifndef free
+-  char *p = (char *) free;
++  (void) free;
+ #endif
+   ;
+@@ -10895,38 +11322,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_free=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_free=no
++      ac_cv_have_decl_free=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_free" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_free" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_free" >&5
++echo "${ECHO_T}$ac_cv_have_decl_free" >&6; }
+ if test $ac_cv_have_decl_free = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10943,8 +11366,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether getenv is declared" >&5
+-echo $ECHO_N "checking whether getenv is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether getenv is declared" >&5
++echo $ECHO_N "checking whether getenv is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_getenv+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10959,7 +11382,7 @@ int
+ main ()
+ {
+ #ifndef getenv
+-  char *p = (char *) getenv;
++  (void) getenv;
+ #endif
+   ;
+@@ -10967,38 +11390,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_getenv=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_getenv=no
++      ac_cv_have_decl_getenv=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_getenv" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_getenv" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_getenv" >&5
++echo "${ECHO_T}$ac_cv_have_decl_getenv" >&6; }
+ if test $ac_cv_have_decl_getenv = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -11015,8 +11434,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether malloc is declared" >&5
+-echo $ECHO_N "checking whether malloc is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether malloc is declared" >&5
++echo $ECHO_N "checking whether malloc is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_malloc+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11031,7 +11450,7 @@ int
+ main ()
+ {
+ #ifndef malloc
+-  char *p = (char *) malloc;
++  (void) malloc;
+ #endif
+   ;
+@@ -11039,38 +11458,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_malloc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_malloc=no
++      ac_cv_have_decl_malloc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_malloc" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_malloc" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_malloc" >&5
++echo "${ECHO_T}$ac_cv_have_decl_malloc" >&6; }
+ if test $ac_cv_have_decl_malloc = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -11087,8 +11502,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether realloc is declared" >&5
+-echo $ECHO_N "checking whether realloc is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether realloc is declared" >&5
++echo $ECHO_N "checking whether realloc is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_realloc+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11103,7 +11518,7 @@ int
+ main ()
+ {
+ #ifndef realloc
+-  char *p = (char *) realloc;
++  (void) realloc;
+ #endif
+   ;
+@@ -11111,38 +11526,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_realloc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_realloc=no
++      ac_cv_have_decl_realloc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_realloc" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_realloc" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_realloc" >&5
++echo "${ECHO_T}$ac_cv_have_decl_realloc" >&6; }
+ if test $ac_cv_have_decl_realloc = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -11159,8 +11570,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether stpcpy is declared" >&5
+-echo $ECHO_N "checking whether stpcpy is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether stpcpy is declared" >&5
++echo $ECHO_N "checking whether stpcpy is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_stpcpy+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11175,7 +11586,7 @@ int
+ main ()
+ {
+ #ifndef stpcpy
+-  char *p = (char *) stpcpy;
++  (void) stpcpy;
+ #endif
+   ;
+@@ -11183,38 +11594,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_stpcpy=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_stpcpy=no
++      ac_cv_have_decl_stpcpy=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_stpcpy" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_stpcpy" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_stpcpy" >&5
++echo "${ECHO_T}$ac_cv_have_decl_stpcpy" >&6; }
+ if test $ac_cv_have_decl_stpcpy = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -11231,8 +11638,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether strstr is declared" >&5
+-echo $ECHO_N "checking whether strstr is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether strstr is declared" >&5
++echo $ECHO_N "checking whether strstr is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_strstr+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11247,7 +11654,7 @@ int
+ main ()
+ {
+ #ifndef strstr
+-  char *p = (char *) strstr;
++  (void) strstr;
+ #endif
+   ;
+@@ -11255,38 +11662,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_strstr=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_strstr=no
++      ac_cv_have_decl_strstr=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_strstr" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_strstr" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_strstr" >&5
++echo "${ECHO_T}$ac_cv_have_decl_strstr" >&6; }
+ if test $ac_cv_have_decl_strstr = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -11303,8 +11706,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether snprintf is declared" >&5
+-echo $ECHO_N "checking whether snprintf is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether snprintf is declared" >&5
++echo $ECHO_N "checking whether snprintf is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_snprintf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11319,7 +11722,7 @@ int
+ main ()
+ {
+ #ifndef snprintf
+-  char *p = (char *) snprintf;
++  (void) snprintf;
+ #endif
+   ;
+@@ -11327,38 +11730,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_snprintf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_snprintf=no
++      ac_cv_have_decl_snprintf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_snprintf" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_snprintf" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_snprintf" >&5
++echo "${ECHO_T}$ac_cv_have_decl_snprintf" >&6; }
+ if test $ac_cv_have_decl_snprintf = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -11375,8 +11774,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether vsnprintf is declared" >&5
+-echo $ECHO_N "checking whether vsnprintf is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether vsnprintf is declared" >&5
++echo $ECHO_N "checking whether vsnprintf is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_vsnprintf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11391,7 +11790,7 @@ int
+ main ()
+ {
+ #ifndef vsnprintf
+-  char *p = (char *) vsnprintf;
++  (void) vsnprintf;
+ #endif
+   ;
+@@ -11399,38 +11798,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_vsnprintf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_vsnprintf=no
++      ac_cv_have_decl_vsnprintf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_vsnprintf" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_vsnprintf" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_vsnprintf" >&5
++echo "${ECHO_T}$ac_cv_have_decl_vsnprintf" >&6; }
+ if test $ac_cv_have_decl_vsnprintf = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -11609,8 +12004,8 @@ if test "${target}" = "${host}"; then
+       COREFLAG="$COREFLAG -DAIX_CORE_DUMPX_CORE"
+       # Not all versions of AIX with -DAIX_CORE_DUMPX_CORE
+       # have c_impl as a member of struct core_dumpx
+-      echo "$as_me:$LINENO: checking for c_impl in struct core_dumpx" >&5
+-echo $ECHO_N "checking for c_impl in struct core_dumpx... $ECHO_C" >&6
++      { echo "$as_me:$LINENO: checking for c_impl in struct core_dumpx" >&5
++echo $ECHO_N "checking for c_impl in struct core_dumpx... $ECHO_C" >&6; }
+       cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -11627,42 +12022,38 @@ struct core_dumpx c; c.c_impl = 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+ cat >>confdefs.h <<\_ACEOF
+ #define HAVE_ST_C_IMPL 1
+ _ACEOF
+-        echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++        { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++      { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+       ;;
+   rs6000-*-aix4*)     COREFILE=rs6000-core.lo ;;
+   rs6000-*-*)         COREFILE=rs6000-core.lo ;;
+@@ -11726,18 +12117,19 @@ rm -f conftest.err conftest.$ac_objext c
+ for ac_header in sys/procfs.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -11748,41 +12140,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -11791,24 +12179,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -11816,9 +12202,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -11842,25 +12229,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -11873,8 +12254,8 @@ fi
+ done
+   if test "$ac_cv_header_sys_procfs_h" = yes; then
+-    echo "$as_me:$LINENO: checking for prstatus_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for prstatus_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for prstatus_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for prstatus_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_prstatus_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11896,36 +12277,32 @@ prstatus_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_prstatus_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_prstatus_t=no
++      bfd_cv_have_sys_procfs_type_prstatus_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_prstatus_t = yes; then
+@@ -11935,11 +12312,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_prstatus_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_prstatus_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_prstatus_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_prstatus_t" >&6; }
+-    echo "$as_me:$LINENO: checking for prstatus32_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for prstatus32_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for prstatus32_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for prstatus32_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_prstatus32_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11961,36 +12338,32 @@ prstatus32_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_prstatus32_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_prstatus32_t=no
++      bfd_cv_have_sys_procfs_type_prstatus32_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_prstatus32_t = yes; then
+@@ -12000,11 +12373,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_prstatus32_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_prstatus32_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_prstatus32_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_prstatus32_t" >&6; }
+-    echo "$as_me:$LINENO: checking for prstatus_t.pr_who in sys/procfs.h" >&5
+-echo $ECHO_N "checking for prstatus_t.pr_who in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for prstatus_t.pr_who in sys/procfs.h" >&5
++echo $ECHO_N "checking for prstatus_t.pr_who in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_member_prstatus_t_pr_who+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12026,36 +12399,32 @@ prstatus_t avar; void* aref = (void*) &a
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_member_prstatus_t_pr_who=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_member_prstatus_t_pr_who=no
++      bfd_cv_have_sys_procfs_type_member_prstatus_t_pr_who=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_member_prstatus_t_pr_who = yes; then
+@@ -12065,11 +12434,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_member_prstatus_t_pr_who" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_member_prstatus_t_pr_who" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_member_prstatus_t_pr_who" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_member_prstatus_t_pr_who" >&6; }
+-    echo "$as_me:$LINENO: checking for prstatus32_t.pr_who in sys/procfs.h" >&5
+-echo $ECHO_N "checking for prstatus32_t.pr_who in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for prstatus32_t.pr_who in sys/procfs.h" >&5
++echo $ECHO_N "checking for prstatus32_t.pr_who in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_member_prstatus32_t_pr_who+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12091,36 +12460,32 @@ prstatus32_t avar; void* aref = (void*) 
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_member_prstatus32_t_pr_who=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_member_prstatus32_t_pr_who=no
++      bfd_cv_have_sys_procfs_type_member_prstatus32_t_pr_who=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_member_prstatus32_t_pr_who = yes; then
+@@ -12130,11 +12495,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_member_prstatus32_t_pr_who" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_member_prstatus32_t_pr_who" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_member_prstatus32_t_pr_who" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_member_prstatus32_t_pr_who" >&6; }
+-    echo "$as_me:$LINENO: checking for pstatus_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for pstatus_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for pstatus_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for pstatus_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_pstatus_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12156,36 +12521,32 @@ pstatus_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_pstatus_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_pstatus_t=no
++      bfd_cv_have_sys_procfs_type_pstatus_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_pstatus_t = yes; then
+@@ -12195,11 +12556,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_pstatus_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_pstatus_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_pstatus_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_pstatus_t" >&6; }
+-    echo "$as_me:$LINENO: checking for pxstatus_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for pxstatus_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for pxstatus_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for pxstatus_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_pxstatus_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12221,36 +12582,32 @@ pxstatus_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_pxstatus_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_pxstatus_t=no
++      bfd_cv_have_sys_procfs_type_pxstatus_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_pxstatus_t = yes; then
+@@ -12260,11 +12617,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_pxstatus_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_pxstatus_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_pxstatus_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_pxstatus_t" >&6; }
+-    echo "$as_me:$LINENO: checking for pstatus32_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for pstatus32_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for pstatus32_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for pstatus32_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_pstatus32_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12286,36 +12643,32 @@ pstatus32_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_pstatus32_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_pstatus32_t=no
++      bfd_cv_have_sys_procfs_type_pstatus32_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_pstatus32_t = yes; then
+@@ -12325,11 +12678,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_pstatus32_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_pstatus32_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_pstatus32_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_pstatus32_t" >&6; }
+-    echo "$as_me:$LINENO: checking for prpsinfo_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for prpsinfo_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for prpsinfo_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for prpsinfo_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_prpsinfo_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12351,36 +12704,32 @@ prpsinfo_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_prpsinfo_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_prpsinfo_t=no
++      bfd_cv_have_sys_procfs_type_prpsinfo_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_prpsinfo_t = yes; then
+@@ -12390,11 +12739,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_prpsinfo_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_prpsinfo_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_prpsinfo_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_prpsinfo_t" >&6; }
+-    echo "$as_me:$LINENO: checking for prpsinfo32_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for prpsinfo32_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for prpsinfo32_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for prpsinfo32_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_prpsinfo32_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12416,36 +12765,32 @@ prpsinfo32_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_prpsinfo32_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_prpsinfo32_t=no
++      bfd_cv_have_sys_procfs_type_prpsinfo32_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_prpsinfo32_t = yes; then
+@@ -12455,11 +12800,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_prpsinfo32_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_prpsinfo32_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_prpsinfo32_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_prpsinfo32_t" >&6; }
+-    echo "$as_me:$LINENO: checking for psinfo_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for psinfo_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for psinfo_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for psinfo_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_psinfo_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12481,36 +12826,32 @@ psinfo_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_psinfo_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_psinfo_t=no
++      bfd_cv_have_sys_procfs_type_psinfo_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_psinfo_t = yes; then
+@@ -12520,11 +12861,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_psinfo_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_psinfo_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_psinfo_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_psinfo_t" >&6; }
+-    echo "$as_me:$LINENO: checking for psinfo32_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for psinfo32_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for psinfo32_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for psinfo32_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_psinfo32_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12546,36 +12887,32 @@ psinfo32_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_psinfo32_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_psinfo32_t=no
++      bfd_cv_have_sys_procfs_type_psinfo32_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_psinfo32_t = yes; then
+@@ -12585,11 +12922,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_psinfo32_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_psinfo32_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_psinfo32_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_psinfo32_t" >&6; }
+-    echo "$as_me:$LINENO: checking for lwpstatus_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for lwpstatus_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for lwpstatus_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for lwpstatus_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_lwpstatus_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12611,36 +12948,32 @@ lwpstatus_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_lwpstatus_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_lwpstatus_t=no
++      bfd_cv_have_sys_procfs_type_lwpstatus_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_lwpstatus_t = yes; then
+@@ -12650,11 +12983,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_lwpstatus_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_lwpstatus_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_lwpstatus_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_lwpstatus_t" >&6; }
+-    echo "$as_me:$LINENO: checking for lwpxstatus_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for lwpxstatus_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for lwpxstatus_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for lwpxstatus_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_lwpxstatus_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12676,36 +13009,32 @@ lwpxstatus_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_lwpxstatus_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_lwpxstatus_t=no
++      bfd_cv_have_sys_procfs_type_lwpxstatus_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_lwpxstatus_t = yes; then
+@@ -12715,11 +13044,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_lwpxstatus_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_lwpxstatus_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_lwpxstatus_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_lwpxstatus_t" >&6; }
+-    echo "$as_me:$LINENO: checking for lwpstatus_t.pr_context in sys/procfs.h" >&5
+-echo $ECHO_N "checking for lwpstatus_t.pr_context in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for lwpstatus_t.pr_context in sys/procfs.h" >&5
++echo $ECHO_N "checking for lwpstatus_t.pr_context in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_context+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12741,36 +13070,32 @@ lwpstatus_t avar; void* aref = (void*) &
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_context=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_context=no
++      bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_context=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_context = yes; then
+@@ -12780,11 +13105,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_context" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_context" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_context" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_context" >&6; }
+-    echo "$as_me:$LINENO: checking for lwpstatus_t.pr_reg in sys/procfs.h" >&5
+-echo $ECHO_N "checking for lwpstatus_t.pr_reg in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for lwpstatus_t.pr_reg in sys/procfs.h" >&5
++echo $ECHO_N "checking for lwpstatus_t.pr_reg in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_reg+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12806,36 +13131,32 @@ lwpstatus_t avar; void* aref = (void*) &
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_reg=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_reg=no
++      bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_reg=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_reg = yes; then
+@@ -12845,11 +13166,11 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_reg" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_reg" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_reg" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_member_lwpstatus_t_pr_reg" >&6; }
+-    echo "$as_me:$LINENO: checking for win32_pstatus_t in sys/procfs.h" >&5
+-echo $ECHO_N "checking for win32_pstatus_t in sys/procfs.h... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for win32_pstatus_t in sys/procfs.h" >&5
++echo $ECHO_N "checking for win32_pstatus_t in sys/procfs.h... $ECHO_C" >&6; }
+  if test "${bfd_cv_have_sys_procfs_type_win32_pstatus_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -12871,36 +13192,32 @@ win32_pstatus_t avar
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bfd_cv_have_sys_procfs_type_win32_pstatus_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bfd_cv_have_sys_procfs_type_win32_pstatus_t=no
++      bfd_cv_have_sys_procfs_type_win32_pstatus_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+  if test $bfd_cv_have_sys_procfs_type_win32_pstatus_t = yes; then
+@@ -12910,8 +13227,8 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+  fi
+- echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_win32_pstatus_t" >&5
+-echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_win32_pstatus_t" >&6
++ { echo "$as_me:$LINENO: result: $bfd_cv_have_sys_procfs_type_win32_pstatus_t" >&5
++echo "${ECHO_T}$bfd_cv_have_sys_procfs_type_win32_pstatus_t" >&6; }
+   fi
+ fi
+@@ -13070,6 +13387,7 @@ do
+     bfd_efi_app_ia64_vec)     tb="$tb efi-app-ia64.lo pepigen.lo cofflink.lo"; target_size=64 ;;
+     bfd_elf32_am33lin_vec)    tb="$tb elf32-am33lin.lo elf32.lo $elf" ;;
+     bfd_elf32_avr_vec)                tb="$tb elf32-avr.lo elf32.lo $elf" ;;
++    bfd_elf32_avr32_vec)      tb="$tb elf32-avr32.lo elf32.lo $elf" ;;
+     bfd_elf32_bfin_vec)               tb="$tb elf32-bfin.lo elf32.lo $elf" ;;
+     bfd_elf32_bfinfdpic_vec)  tb="$tb elf32-bfin.lo elf32.lo $elf" ;;
+     bfd_elf32_big_generic_vec)        tb="$tb elf32-gen.lo elf32.lo $elf" ;;
+@@ -13389,8 +13707,8 @@ echo "$as_me: WARNING: your compiler may
+     fi
+     if test -n "$GCC" ; then
+        bad_64bit_gcc=no;
+-       echo "$as_me:$LINENO: checking for gcc version with buggy 64-bit support" >&5
+-echo $ECHO_N "checking for gcc version with buggy 64-bit support... $ECHO_C" >&6
++       { echo "$as_me:$LINENO: checking for gcc version with buggy 64-bit support" >&5
++echo $ECHO_N "checking for gcc version with buggy 64-bit support... $ECHO_C" >&6; }
+        # Add more tests for gcc versions with non-working 64-bit support here.
+        cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -13403,11 +13721,11 @@ _ACEOF
+ if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+   $EGREP ": 2 : 91 : 1 :" >/dev/null 2>&1; then
+   bad_64bit_gcc=yes;
+-                  echo "$as_me:$LINENO: result: yes: egcs-1.1.2 on ix86 spotted" >&5
+-echo "${ECHO_T}yes: egcs-1.1.2 on ix86 spotted" >&6
++                  { echo "$as_me:$LINENO: result: yes: egcs-1.1.2 on ix86 spotted" >&5
++echo "${ECHO_T}yes: egcs-1.1.2 on ix86 spotted" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ rm -f conftest*
+@@ -13445,9 +13763,9 @@ esac
+ for ac_func in ftello ftello64 fseeko fseeko64 fopen64
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -13473,68 +13791,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -13544,8 +13854,8 @@ fi
+ done
+ if test x"$ac_cv_func_ftello" = xyes -a x"$ac_cv_func_fseeko" = xyes; then
+-    echo "$as_me:$LINENO: checking for off_t" >&5
+-echo $ECHO_N "checking for off_t... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for off_t" >&5
++echo $ECHO_N "checking for off_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_off_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -13556,61 +13866,57 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef off_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((off_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (off_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_off_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_off_t=no
++      ac_cv_type_off_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
+-echo "${ECHO_T}$ac_cv_type_off_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
++echo "${ECHO_T}$ac_cv_type_off_t" >&6; }
+-echo "$as_me:$LINENO: checking size of off_t" >&5
+-echo $ECHO_N "checking size of off_t... $ECHO_C" >&6
++# The cast to long int works around a bug in the HP C Compiler
++# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
++# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
++# This bug is HP SR number 8606223364.
++{ echo "$as_me:$LINENO: checking size of off_t" >&5
++echo $ECHO_N "checking size of off_t... $ECHO_C" >&6; }
+ if test "${ac_cv_sizeof_off_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if test "$ac_cv_type_off_t" = yes; then
+-  # The cast to unsigned long works around a bug in the HP C Compiler
+-  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+-  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+-  # This bug is HP SR number 8606223364.
+   if test "$cross_compiling" = yes; then
+   # Depending upon the size, compute the lo and hi bounds.
+ cat >conftest.$ac_ext <<_ACEOF
+@@ -13620,10 +13926,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef off_t ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (off_t))) >= 0)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
+ test_array [0] = 0
+   ;
+@@ -13631,27 +13938,22 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_lo=0 ac_mid=0
+   while :; do
+     cat >conftest.$ac_ext <<_ACEOF
+@@ -13661,10 +13963,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef off_t ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (off_t))) <= $ac_mid)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
+ test_array [0] = 0
+   ;
+@@ -13672,56 +13975,53 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_hi=$ac_mid; break
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_lo=`expr $ac_mid + 1`
+-                  if test $ac_lo -le $ac_mid; then
+-                    ac_lo= ac_hi=
+-                    break
+-                  fi
+-                  ac_mid=`expr 2 '*' $ac_mid + 1`
++      ac_lo=`expr $ac_mid + 1`
++                      if test $ac_lo -le $ac_mid; then
++                        ac_lo= ac_hi=
++                        break
++                      fi
++                      ac_mid=`expr 2 '*' $ac_mid + 1`
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   done
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-cat >conftest.$ac_ext <<_ACEOF
++      cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef off_t ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (off_t))) < 0)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
+ test_array [0] = 0
+   ;
+@@ -13729,27 +14029,22 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_hi=-1 ac_mid=-1
+   while :; do
+     cat >conftest.$ac_ext <<_ACEOF
+@@ -13759,10 +14054,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef off_t ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (off_t))) >= $ac_mid)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
+ test_array [0] = 0
+   ;
+@@ -13770,50 +14066,48 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_lo=$ac_mid; break
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_hi=`expr '(' $ac_mid ')' - 1`
+-                     if test $ac_mid -le $ac_hi; then
+-                       ac_lo= ac_hi=
+-                       break
+-                     fi
+-                     ac_mid=`expr 2 '*' $ac_mid`
++      ac_hi=`expr '(' $ac_mid ')' - 1`
++                      if test $ac_mid -le $ac_hi; then
++                        ac_lo= ac_hi=
++                        break
++                      fi
++                      ac_mid=`expr 2 '*' $ac_mid`
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   done
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_lo= ac_hi=
++      ac_lo= ac_hi=
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ # Binary search between lo and hi bounds.
+ while test "x$ac_lo" != "x$ac_hi"; do
+   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
+@@ -13824,10 +14118,11 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++   typedef off_t ac__type_sizeof_;
+ int
+ main ()
+ {
+-static int test_array [1 - 2 * !(((long) (sizeof (off_t))) <= $ac_mid)];
++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
+ test_array [0] = 0
+   ;
+@@ -13835,52 +14130,45 @@ test_array [0] = 0
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_hi=$ac_mid
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_lo=`expr '(' $ac_mid ')' + 1`
++      ac_lo=`expr '(' $ac_mid ')' + 1`
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ done
+ case $ac_lo in
+ ?*) ac_cv_sizeof_off_t=$ac_lo;;
+-'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (off_t), 77
++'') if test "$ac_cv_type_off_t" = yes; then
++     { { echo "$as_me:$LINENO: error: cannot compute sizeof (off_t)
+ See \`config.log' for more details." >&5
+-echo "$as_me: error: cannot compute sizeof (off_t), 77
++echo "$as_me: error: cannot compute sizeof (off_t)
+ See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; } ;;
++   { (exit 77); exit 77; }; }
++   else
++     ac_cv_sizeof_off_t=0
++   fi ;;
+ esac
+ else
+-  if test "$cross_compiling" = yes; then
+-  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
+-See \`config.log' for more details." >&5
+-echo "$as_me: error: cannot run test program while cross compiling
+-See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; }
+-else
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -13888,8 +14176,9 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
+-long longval () { return (long) (sizeof (off_t)); }
+-unsigned long ulongval () { return (long) (sizeof (off_t)); }
++   typedef off_t ac__type_sizeof_;
++static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
++static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
+ #include <stdio.h>
+ #include <stdlib.h>
+ int
+@@ -13898,35 +14187,44 @@ main ()
+   FILE *f = fopen ("conftest.val", "w");
+   if (! f)
+-    exit (1);
+-  if (((long) (sizeof (off_t))) < 0)
++    return 1;
++  if (((long int) (sizeof (ac__type_sizeof_))) < 0)
+     {
+-      long i = longval ();
+-      if (i != ((long) (sizeof (off_t))))
+-      exit (1);
++      long int i = longval ();
++      if (i != ((long int) (sizeof (ac__type_sizeof_))))
++      return 1;
+       fprintf (f, "%ld\n", i);
+     }
+   else
+     {
+-      unsigned long i = ulongval ();
+-      if (i != ((long) (sizeof (off_t))))
+-      exit (1);
++      unsigned long int i = ulongval ();
++      if (i != ((long int) (sizeof (ac__type_sizeof_))))
++      return 1;
+       fprintf (f, "%lu\n", i);
+     }
+-  exit (ferror (f) || fclose (f) != 0);
++  return ferror (f) || fclose (f) != 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -13937,30 +14235,33 @@ echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+-{ { echo "$as_me:$LINENO: error: cannot compute sizeof (off_t), 77
++if test "$ac_cv_type_off_t" = yes; then
++     { { echo "$as_me:$LINENO: error: cannot compute sizeof (off_t)
+ See \`config.log' for more details." >&5
+-echo "$as_me: error: cannot compute sizeof (off_t), 77
++echo "$as_me: error: cannot compute sizeof (off_t)
+ See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; }
+-fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++   { (exit 77); exit 77; }; }
++   else
++     ac_cv_sizeof_off_t=0
++   fi
+ fi
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
+ rm -f conftest.val
+-else
+-  ac_cv_sizeof_off_t=0
+-fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_sizeof_off_t" >&5
+-echo "${ECHO_T}$ac_cv_sizeof_off_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_off_t" >&5
++echo "${ECHO_T}$ac_cv_sizeof_off_t" >&6; }
++
++
++
+ cat >>confdefs.h <<_ACEOF
+ #define SIZEOF_OFF_T $ac_cv_sizeof_off_t
+ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking file_ptr type" >&5
+-echo $ECHO_N "checking file_ptr type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking file_ptr type" >&5
++echo $ECHO_N "checking file_ptr type... $ECHO_C" >&6; }
+ bfd_file_ptr="long"
+ bfd_ufile_ptr="unsigned long"
+ if test x"$ac_cv_func_ftello64" = xyes -a x"$ac_cv_func_fseeko64" = xyes \
+@@ -13968,8 +14269,8 @@ if test x"$ac_cv_func_ftello64" = xyes -
+     bfd_file_ptr=BFD_HOST_64_BIT
+     bfd_ufile_ptr=BFD_HOST_U_64_BIT
+ fi
+-echo "$as_me:$LINENO: result: $bfd_file_ptr" >&5
+-echo "${ECHO_T}$bfd_file_ptr" >&6
++{ echo "$as_me:$LINENO: result: $bfd_file_ptr" >&5
++echo "${ECHO_T}$bfd_file_ptr" >&6; }
+@@ -13987,18 +14288,19 @@ test -n "${havevecs}" && tdefaults="${td
+ for ac_header in stdlib.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -14009,41 +14311,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -14052,24 +14350,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -14077,9 +14373,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -14103,25 +14400,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -14137,9 +14428,9 @@ done
+ for ac_func in getpagesize
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -14165,68 +14456,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -14235,8 +14518,8 @@ _ACEOF
+ fi
+ done
+-echo "$as_me:$LINENO: checking for working mmap" >&5
+-echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working mmap" >&5
++echo $ECHO_N "checking for working mmap... $ECHO_C" >&6; }
+ if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -14278,21 +14561,21 @@ $ac_includes_default
+ #include <fcntl.h>
+ #include <sys/mman.h>
+-#if !STDC_HEADERS && !HAVE_STDLIB_H
++#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H
+ char *malloc ();
+ #endif
+ /* This mess was copied from the GNU getpagesize.h.  */
+-#if !HAVE_GETPAGESIZE
++#ifndef HAVE_GETPAGESIZE
+ /* Assume that all systems that can run configure have sys/param.h.  */
+-# if !HAVE_SYS_PARAM_H
++# ifndef HAVE_SYS_PARAM_H
+ #  define HAVE_SYS_PARAM_H 1
+ # endif
+ # ifdef _SC_PAGESIZE
+ #  define getpagesize() sysconf(_SC_PAGESIZE)
+ # else /* no _SC_PAGESIZE */
+-#  if HAVE_SYS_PARAM_H
++#  ifdef HAVE_SYS_PARAM_H
+ #   include <sys/param.h>
+ #   ifdef EXEC_PAGESIZE
+ #    define getpagesize() EXEC_PAGESIZE
+@@ -14331,15 +14614,15 @@ main ()
+   /* First, make a file with some known garbage in it. */
+   data = (char *) malloc (pagesize);
+   if (!data)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     *(data + i) = rand ();
+   umask (0);
+   fd = creat ("conftest.mmap", 0600);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   if (write (fd, data, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   close (fd);
+   /* Next, try to mmap the file at a fixed address which already has
+@@ -14347,17 +14630,17 @@ main ()
+      we see the same garbage.  */
+   fd = open ("conftest.mmap", O_RDWR);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   data2 = (char *) malloc (2 * pagesize);
+   if (!data2)
+-    exit (1);
+-  data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
++    return 1;
++  data2 += (pagesize - ((long int) data2 & (pagesize - 1))) & (pagesize - 1);
+   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_FIXED, fd, 0L))
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data2 + i))
+-      exit (1);
++      return 1;
+   /* Finally, make sure that changes to the mapped area do not
+      percolate back to the file as seen by read().  (This is a bug on
+@@ -14366,24 +14649,33 @@ main ()
+     *(data2 + i) = *(data2 + i) + 1;
+   data3 = (char *) malloc (pagesize);
+   if (!data3)
+-    exit (1);
++    return 1;
+   if (read (fd, data3, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data3 + i))
+-      exit (1);
++      return 1;
+   close (fd);
+-  exit (0);
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -14396,11 +14688,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_func_mmap_fixed_mapped=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
+-echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
++echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6; }
+ if test $ac_cv_func_mmap_fixed_mapped = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -14415,9 +14709,9 @@ rm -f conftest.mmap
+ for ac_func in madvise mprotect
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -14443,68 +14737,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -14522,9 +14808,9 @@ _ACEOF
+ esac
+ rm -f doc/config.status
+-                                        ac_config_files="$ac_config_files Makefile doc/Makefile bfd-in3.h:bfd-in2.h po/Makefile.in:po/Make-in"
++ac_config_files="$ac_config_files Makefile doc/Makefile bfd-in3.h:bfd-in2.h po/Makefile.in:po/Make-in"
+-          ac_config_commands="$ac_config_commands default"
++ac_config_commands="$ac_config_commands default"
+@@ -14549,39 +14835,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -14590,32 +14895,18 @@ test "x$prefix" = xNONE && prefix=$ac_de
+ # Let make expand exec_prefix.
+ test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+-# VPATH may cause trouble with some makes, so we remove $(srcdir),
+-# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+-# trailing colons and then remove the whole line if VPATH becomes empty
+-# (actually we leave an empty line to preserve line numbers).
+-if test "x$srcdir" = x.; then
+-  ac_vpsub='/^[        ]*VPATH[        ]*=/{
+-s/:*\$(srcdir):*/:/;
+-s/:*\${srcdir}:*/:/;
+-s/:*@srcdir@:*/:/;
+-s/^\([^=]*=[   ]*\):*/\1/;
+-s/:*$//;
+-s/^[^=]*=[     ]*$//;
+-}'
+-fi
+-
+ DEFS=-DHAVE_CONFIG_H
+ ac_libobjs=
+ ac_ltlibobjs=
+ for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+   # 1. Remove the extension, and $U if already installed.
+-  ac_i=`echo "$ac_i" |
+-       sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
+-  # 2. Add them.
+-  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
+-  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
++  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
++  ac_i=`echo "$ac_i" | sed "$ac_script"`
++  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
++  #    will be set to the directory where LIBOBJS objects are built.
++  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
++  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
+ done
+ LIBOBJS=$ac_libobjs
+@@ -14674,17 +14965,45 @@ cat >>$CONFIG_STATUS <<\_ACEOF
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -14694,8 +15013,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -14709,18 +15063,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -14728,159 +15083,120 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+-
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
+-
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
+-fi
++# CDPATH.
++$as_unset CDPATH
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+-echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
+-    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
+-       /*)
+-         if ("$as_dir/$as_base" -c '
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
+-    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+-echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
++  chmod +x "$as_me.lineno" ||
++    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -14889,7 +15205,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -14898,31 +15235,14 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
+-
+ exec 6>&1
+-# Open the log real soon, to keep \$[0] and so on meaningful, and to
++# Save the log message, to keep $[0] and so on meaningful, and to
+ # report actual input values of CONFIG_FILES etc. instead of their
+-# values after options handling.  Logging --version etc. is OK.
+-exec 5>>config.log
+-{
+-  echo
+-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+-## Running $as_me. ##
+-_ASBOX
+-} >&5
+-cat >&5 <<_CSEOF
+-
++# values after options handling.
++ac_log="
+ This file was extended by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   CONFIG_FILES    = $CONFIG_FILES
+   CONFIG_HEADERS  = $CONFIG_HEADERS
+@@ -14930,30 +15250,20 @@ generated by GNU Autoconf 2.59.  Invocat
+   CONFIG_COMMANDS = $CONFIG_COMMANDS
+   $ $0 $@
+-_CSEOF
+-echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+-echo >&5
++on `(hostname || uname -n) 2>/dev/null | sed 1q`
++"
++
+ _ACEOF
++cat >>$CONFIG_STATUS <<_ACEOF
+ # Files that config.status was made for.
+-if test -n "$ac_config_files"; then
+-  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
+-fi
++config_files="$ac_config_files"
++config_headers="$ac_config_headers"
++config_commands="$ac_config_commands"
+-if test -n "$ac_config_headers"; then
+-  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_links"; then
+-  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_commands"; then
+-  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
+-fi
++_ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-
+ ac_cs_usage="\
+ \`$as_me' instantiates files from templates according to the
+ current configuration.
+@@ -14961,7 +15271,7 @@ current configuration.
+ Usage: $0 [OPTIONS] [FILE]...
+   -h, --help       print this help, then exit
+-  -V, --version    print version number, then exit
++  -V, --version    print version number and configuration settings, then exit
+   -q, --quiet      do not print progress messages
+   -d, --debug      don't remove temporary files
+       --recheck    update $as_me by reconfiguring in the same conditions
+@@ -14980,19 +15290,21 @@ Configuration commands:
+ $config_commands
+ Report bugs to <bug-autoconf@gnu.org>."
+-_ACEOF
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ ac_cs_version="\\
+ config.status
+-configured by $0, generated by GNU Autoconf 2.59,
+-  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
++configured by $0, generated by GNU Autoconf 2.61,
++  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 2006 Free Software Foundation, Inc.
+ This config.status script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it."
+-srcdir=$srcdir
+-INSTALL="$INSTALL"
++
++ac_pwd='$ac_pwd'
++srcdir='$srcdir'
++INSTALL='$INSTALL'
+ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+@@ -15003,39 +15315,24 @@ while test $# != 0
+ do
+   case $1 in
+   --*=*)
+-    ac_option=`expr "x$1" : 'x\([^=]*\)='`
+-    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
++    ac_option=`expr "X$1" : 'X\([^=]*\)='`
++    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+     ac_shift=:
+     ;;
+-  -*)
++  *)
+     ac_option=$1
+     ac_optarg=$2
+     ac_shift=shift
+     ;;
+-  *) # This is not an option, so the user has probably given explicit
+-     # arguments.
+-     ac_option=$1
+-     ac_need_defaults=false;;
+   esac
+   case $ac_option in
+   # Handling of the options.
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+     ac_cs_recheck=: ;;
+-  --version | --vers* | -V )
+-    echo "$ac_cs_version"; exit 0 ;;
+-  --he | --h)
+-    # Conflict between --help and --header
+-    { { echo "$as_me:$LINENO: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&2;}
+-   { (exit 1); exit 1; }; };;
+-  --help | --hel | -h )
+-    echo "$ac_cs_usage"; exit 0 ;;
+-  --debug | --d* | -d )
++  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
++    echo "$ac_cs_version"; exit ;;
++  --debug | --debu | --deb | --de | --d | -d )
+     debug=: ;;
+   --file | --fil | --fi | --f )
+     $ac_shift
+@@ -15045,18 +15342,24 @@ Try \`$0 --help' for more information." 
+     $ac_shift
+     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+     ac_need_defaults=false;;
++  --he | --h)
++    # Conflict between --help and --header
++    { echo "$as_me: error: ambiguous option: $1
++Try \`$0 --help' for more information." >&2
++   { (exit 1); exit 1; }; };;
++  --help | --hel | -h )
++    echo "$ac_cs_usage"; exit ;;
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil | --si | --s)
+     ac_cs_silent=: ;;
+   # This is an error.
+-  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&2;}
++  -*) { echo "$as_me: error: unrecognized option: $1
++Try \`$0 --help' for more information." >&2
+    { (exit 1); exit 1; }; } ;;
+-  *) ac_config_targets="$ac_config_targets $1" ;;
++  *) ac_config_targets="$ac_config_targets $1"
++     ac_need_defaults=false ;;
+   esac
+   shift
+@@ -15072,42 +15375,54 @@ fi
+ _ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ if \$ac_cs_recheck; then
+-  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
+-  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
++  echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
++  CONFIG_SHELL=$SHELL
++  export CONFIG_SHELL
++  exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+ fi
+ _ACEOF
++cat >>$CONFIG_STATUS <<\_ACEOF
++exec 5>>config.log
++{
++  echo
++  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
++## Running $as_me. ##
++_ASBOX
++  echo "$ac_log"
++} >&5
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ #
+-# INIT-COMMANDS section.
++# INIT-COMMANDS
+ #
+-
+ AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+ _ACEOF
+-
+-
+ cat >>$CONFIG_STATUS <<\_ACEOF
++
++# Handling of arguments.
+ for ac_config_target in $ac_config_targets
+ do
+-  case "$ac_config_target" in
+-  # Handling of arguments.
+-  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+-  "doc/Makefile" ) CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
+-  "bfd-in3.h" ) CONFIG_FILES="$CONFIG_FILES bfd-in3.h:bfd-in2.h" ;;
+-  "po/Makefile.in" ) CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
+-  "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+-  "default" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
+-  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++  case $ac_config_target in
++    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
++    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
++    "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
++    "bfd-in3.h") CONFIG_FILES="$CONFIG_FILES bfd-in3.h:bfd-in2.h" ;;
++    "po/Makefile.in") CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
++    "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
++
+   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+ echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+    { (exit 1); exit 1; }; };;
+   esac
+ done
++
+ # If the user did not use the arguments to specify the items to instantiate,
+ # then the envvar interface is used.  Set only those that are not.
+ # We use the long form for the default assignment because of an extremely
+@@ -15119,401 +15434,504 @@ if $ac_need_defaults; then
+ fi
+ # Have a temporary directory for convenience.  Make it in the build tree
+-# simply because there is no reason to put it here, and in addition,
++# simply because there is no reason against having it here, and in addition,
+ # creating and moving files from /tmp can sometimes cause problems.
+-# Create a temporary directory, and hook for its removal unless debugging.
++# Hook for its removal unless debugging.
++# Note that there is a small window in which the directory will not be cleaned:
++# after its creation but before its name has been assigned to `$tmp'.
+ $debug ||
+ {
+-  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
++  tmp=
++  trap 'exit_status=$?
++  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
++' 0
+   trap '{ (exit 1); exit 1; }' 1 2 13 15
+ }
+-
+ # Create a (secure) tmp directory for tmp files.
+ {
+-  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
++  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+   test -n "$tmp" && test -d "$tmp"
+ }  ||
+ {
+-  tmp=./confstat$$-$RANDOM
+-  (umask 077 && mkdir $tmp)
++  tmp=./conf$$-$RANDOM
++  (umask 077 && mkdir "$tmp")
+ } ||
+ {
+    echo "$me: cannot create a temporary directory in ." >&2
+    { (exit 1); exit 1; }
+ }
+-_ACEOF
+-
+-cat >>$CONFIG_STATUS <<_ACEOF
+-
+ #
+-# CONFIG_FILES section.
++# Set up the sed scripts for CONFIG_FILES section.
+ #
+ # No need to generate the scripts if there are no CONFIG_FILES.
+ # This happens for instance when ./config.status config.h
+-if test -n "\$CONFIG_FILES"; then
+-  # Protect against being on the right side of a sed subst in config.status.
+-  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
+-   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
+-s,@SHELL@,$SHELL,;t t
+-s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
+-s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
+-s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
+-s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
+-s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
+-s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
+-s,@exec_prefix@,$exec_prefix,;t t
+-s,@prefix@,$prefix,;t t
+-s,@program_transform_name@,$program_transform_name,;t t
+-s,@bindir@,$bindir,;t t
+-s,@sbindir@,$sbindir,;t t
+-s,@libexecdir@,$libexecdir,;t t
+-s,@datadir@,$datadir,;t t
+-s,@sysconfdir@,$sysconfdir,;t t
+-s,@sharedstatedir@,$sharedstatedir,;t t
+-s,@localstatedir@,$localstatedir,;t t
+-s,@libdir@,$libdir,;t t
+-s,@includedir@,$includedir,;t t
+-s,@oldincludedir@,$oldincludedir,;t t
+-s,@infodir@,$infodir,;t t
+-s,@mandir@,$mandir,;t t
+-s,@build_alias@,$build_alias,;t t
+-s,@host_alias@,$host_alias,;t t
+-s,@target_alias@,$target_alias,;t t
+-s,@DEFS@,$DEFS,;t t
+-s,@ECHO_C@,$ECHO_C,;t t
+-s,@ECHO_N@,$ECHO_N,;t t
+-s,@ECHO_T@,$ECHO_T,;t t
+-s,@LIBS@,$LIBS,;t t
+-s,@build@,$build,;t t
+-s,@build_cpu@,$build_cpu,;t t
+-s,@build_vendor@,$build_vendor,;t t
+-s,@build_os@,$build_os,;t t
+-s,@host@,$host,;t t
+-s,@host_cpu@,$host_cpu,;t t
+-s,@host_vendor@,$host_vendor,;t t
+-s,@host_os@,$host_os,;t t
+-s,@target@,$target,;t t
+-s,@target_cpu@,$target_cpu,;t t
+-s,@target_vendor@,$target_vendor,;t t
+-s,@target_os@,$target_os,;t t
+-s,@CC@,$CC,;t t
+-s,@CFLAGS@,$CFLAGS,;t t
+-s,@LDFLAGS@,$LDFLAGS,;t t
+-s,@CPPFLAGS@,$CPPFLAGS,;t t
+-s,@ac_ct_CC@,$ac_ct_CC,;t t
+-s,@EXEEXT@,$EXEEXT,;t t
+-s,@OBJEXT@,$OBJEXT,;t t
+-s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
+-s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
+-s,@INSTALL_DATA@,$INSTALL_DATA,;t t
+-s,@CYGPATH_W@,$CYGPATH_W,;t t
+-s,@PACKAGE@,$PACKAGE,;t t
+-s,@VERSION@,$VERSION,;t t
+-s,@ACLOCAL@,$ACLOCAL,;t t
+-s,@AUTOCONF@,$AUTOCONF,;t t
+-s,@AUTOMAKE@,$AUTOMAKE,;t t
+-s,@AUTOHEADER@,$AUTOHEADER,;t t
+-s,@MAKEINFO@,$MAKEINFO,;t t
+-s,@install_sh@,$install_sh,;t t
+-s,@STRIP@,$STRIP,;t t
+-s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
+-s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
+-s,@mkdir_p@,$mkdir_p,;t t
+-s,@AWK@,$AWK,;t t
+-s,@SET_MAKE@,$SET_MAKE,;t t
+-s,@am__leading_dot@,$am__leading_dot,;t t
+-s,@AMTAR@,$AMTAR,;t t
+-s,@am__tar@,$am__tar,;t t
+-s,@am__untar@,$am__untar,;t t
+-s,@DEPDIR@,$DEPDIR,;t t
+-s,@am__include@,$am__include,;t t
+-s,@am__quote@,$am__quote,;t t
+-s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
+-s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
+-s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
+-s,@CCDEPMODE@,$CCDEPMODE,;t t
+-s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
+-s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
+-s,@AR@,$AR,;t t
+-s,@ac_ct_AR@,$ac_ct_AR,;t t
+-s,@RANLIB@,$RANLIB,;t t
+-s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
+-s,@LN_S@,$LN_S,;t t
+-s,@LIBTOOL@,$LIBTOOL,;t t
+-s,@WARN_CFLAGS@,$WARN_CFLAGS,;t t
+-s,@NO_WERROR@,$NO_WERROR,;t t
+-s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
+-s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
+-s,@MAINT@,$MAINT,;t t
+-s,@INSTALL_LIBBFD_TRUE@,$INSTALL_LIBBFD_TRUE,;t t
+-s,@INSTALL_LIBBFD_FALSE@,$INSTALL_LIBBFD_FALSE,;t t
+-s,@host_noncanonical@,$host_noncanonical,;t t
+-s,@target_noncanonical@,$target_noncanonical,;t t
+-s,@bfdlibdir@,$bfdlibdir,;t t
+-s,@bfdincludedir@,$bfdincludedir,;t t
+-s,@CPP@,$CPP,;t t
+-s,@EGREP@,$EGREP,;t t
+-s,@ALLOCA@,$ALLOCA,;t t
+-s,@USE_NLS@,$USE_NLS,;t t
+-s,@MSGFMT@,$MSGFMT,;t t
+-s,@GMSGFMT@,$GMSGFMT,;t t
+-s,@XGETTEXT@,$XGETTEXT,;t t
+-s,@USE_INCLUDED_LIBINTL@,$USE_INCLUDED_LIBINTL,;t t
+-s,@CATALOGS@,$CATALOGS,;t t
+-s,@CATOBJEXT@,$CATOBJEXT,;t t
+-s,@DATADIRNAME@,$DATADIRNAME,;t t
+-s,@GMOFILES@,$GMOFILES,;t t
+-s,@INSTOBJEXT@,$INSTOBJEXT,;t t
+-s,@INTLDEPS@,$INTLDEPS,;t t
+-s,@INTLLIBS@,$INTLLIBS,;t t
+-s,@INTLOBJS@,$INTLOBJS,;t t
+-s,@POFILES@,$POFILES,;t t
+-s,@POSUB@,$POSUB,;t t
+-s,@INCLUDE_LOCALE_H@,$INCLUDE_LOCALE_H,;t t
+-s,@GT_NO@,$GT_NO,;t t
+-s,@GT_YES@,$GT_YES,;t t
+-s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t
+-s,@l@,$l,;t t
+-s,@HDEFINES@,$HDEFINES,;t t
+-s,@BFD_HOST_64BIT_LONG@,$BFD_HOST_64BIT_LONG,;t t
+-s,@BFD_HOST_LONG_LONG@,$BFD_HOST_LONG_LONG,;t t
+-s,@BFD_HOST_64_BIT_DEFINED@,$BFD_HOST_64_BIT_DEFINED,;t t
+-s,@BFD_HOST_64_BIT@,$BFD_HOST_64_BIT,;t t
+-s,@BFD_HOST_U_64_BIT@,$BFD_HOST_U_64_BIT,;t t
+-s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
+-s,@EXEEXT_FOR_BUILD@,$EXEEXT_FOR_BUILD,;t t
+-s,@COREFILE@,$COREFILE,;t t
+-s,@COREFLAG@,$COREFLAG,;t t
+-s,@WIN32LDFLAGS@,$WIN32LDFLAGS,;t t
+-s,@WIN32LIBADD@,$WIN32LIBADD,;t t
+-s,@TDEFINES@,$TDEFINES,;t t
+-s,@wordsize@,$wordsize,;t t
+-s,@bfd_libs@,$bfd_libs,;t t
+-s,@all_backends@,$all_backends,;t t
+-s,@bfd_backends@,$bfd_backends,;t t
+-s,@bfd_machines@,$bfd_machines,;t t
+-s,@bfd_default_target_size@,$bfd_default_target_size,;t t
+-s,@bfd_file_ptr@,$bfd_file_ptr,;t t
+-s,@bfd_ufile_ptr@,$bfd_ufile_ptr,;t t
+-s,@tdefaults@,$tdefaults,;t t
+-s,@datarootdir@,$datarootdir,;t t
+-s,@docdir@,$docdir,;t t
+-s,@htmldir@,$htmldir,;t t
+-s,@LIBOBJS@,$LIBOBJS,;t t
+-s,@LTLIBOBJS@,$LTLIBOBJS,;t t
+-CEOF
+-
+-_ACEOF
+-
+-  cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Split the substitutions into bite-sized pieces for seds with
+-  # small command number limits, like on Digital OSF/1 and HP-UX.
+-  ac_max_sed_lines=48
+-  ac_sed_frag=1 # Number of current file.
+-  ac_beg=1 # First line for current file.
+-  ac_end=$ac_max_sed_lines # Line after last line for current file.
+-  ac_more_lines=:
+-  ac_sed_cmds=
+-  while $ac_more_lines; do
+-    if test $ac_beg -gt 1; then
+-      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    else
+-      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    fi
+-    if test ! -s $tmp/subs.frag; then
+-      ac_more_lines=false
+-    else
+-      # The purpose of the label and of the branching condition is to
+-      # speed up the sed processing (if there are no `@' at all, there
+-      # is no need to browse any of the substitutions).
+-      # These are the two extra sed commands mentioned above.
+-      (echo ':t
+-  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
+-      if test -z "$ac_sed_cmds"; then
+-      ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
+-      else
+-      ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
+-      fi
+-      ac_sed_frag=`expr $ac_sed_frag + 1`
+-      ac_beg=$ac_end
+-      ac_end=`expr $ac_end + $ac_max_sed_lines`
+-    fi
+-  done
+-  if test -z "$ac_sed_cmds"; then
+-    ac_sed_cmds=cat
++if test -n "$CONFIG_FILES"; then
++
++_ACEOF
++
++
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++SHELL!$SHELL$ac_delim
++PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim
++PACKAGE_NAME!$PACKAGE_NAME$ac_delim
++PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim
++PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim
++PACKAGE_STRING!$PACKAGE_STRING$ac_delim
++PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim
++exec_prefix!$exec_prefix$ac_delim
++prefix!$prefix$ac_delim
++program_transform_name!$program_transform_name$ac_delim
++bindir!$bindir$ac_delim
++sbindir!$sbindir$ac_delim
++libexecdir!$libexecdir$ac_delim
++datarootdir!$datarootdir$ac_delim
++datadir!$datadir$ac_delim
++sysconfdir!$sysconfdir$ac_delim
++sharedstatedir!$sharedstatedir$ac_delim
++localstatedir!$localstatedir$ac_delim
++includedir!$includedir$ac_delim
++oldincludedir!$oldincludedir$ac_delim
++docdir!$docdir$ac_delim
++infodir!$infodir$ac_delim
++htmldir!$htmldir$ac_delim
++dvidir!$dvidir$ac_delim
++pdfdir!$pdfdir$ac_delim
++psdir!$psdir$ac_delim
++libdir!$libdir$ac_delim
++localedir!$localedir$ac_delim
++mandir!$mandir$ac_delim
++DEFS!$DEFS$ac_delim
++ECHO_C!$ECHO_C$ac_delim
++ECHO_N!$ECHO_N$ac_delim
++ECHO_T!$ECHO_T$ac_delim
++LIBS!$LIBS$ac_delim
++build_alias!$build_alias$ac_delim
++host_alias!$host_alias$ac_delim
++target_alias!$target_alias$ac_delim
++build!$build$ac_delim
++build_cpu!$build_cpu$ac_delim
++build_vendor!$build_vendor$ac_delim
++build_os!$build_os$ac_delim
++host!$host$ac_delim
++host_cpu!$host_cpu$ac_delim
++host_vendor!$host_vendor$ac_delim
++host_os!$host_os$ac_delim
++target!$target$ac_delim
++target_cpu!$target_cpu$ac_delim
++target_vendor!$target_vendor$ac_delim
++target_os!$target_os$ac_delim
++CC!$CC$ac_delim
++CFLAGS!$CFLAGS$ac_delim
++LDFLAGS!$LDFLAGS$ac_delim
++CPPFLAGS!$CPPFLAGS$ac_delim
++ac_ct_CC!$ac_ct_CC$ac_delim
++EXEEXT!$EXEEXT$ac_delim
++OBJEXT!$OBJEXT$ac_delim
++INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
++INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim
++INSTALL_DATA!$INSTALL_DATA$ac_delim
++CYGPATH_W!$CYGPATH_W$ac_delim
++PACKAGE!$PACKAGE$ac_delim
++VERSION!$VERSION$ac_delim
++ACLOCAL!$ACLOCAL$ac_delim
++AUTOCONF!$AUTOCONF$ac_delim
++AUTOMAKE!$AUTOMAKE$ac_delim
++AUTOHEADER!$AUTOHEADER$ac_delim
++MAKEINFO!$MAKEINFO$ac_delim
++install_sh!$install_sh$ac_delim
++STRIP!$STRIP$ac_delim
++INSTALL_STRIP_PROGRAM!$INSTALL_STRIP_PROGRAM$ac_delim
++mkdir_p!$mkdir_p$ac_delim
++AWK!$AWK$ac_delim
++SET_MAKE!$SET_MAKE$ac_delim
++am__leading_dot!$am__leading_dot$ac_delim
++AMTAR!$AMTAR$ac_delim
++am__tar!$am__tar$ac_delim
++am__untar!$am__untar$ac_delim
++DEPDIR!$DEPDIR$ac_delim
++am__include!$am__include$ac_delim
++am__quote!$am__quote$ac_delim
++AMDEP_TRUE!$AMDEP_TRUE$ac_delim
++AMDEP_FALSE!$AMDEP_FALSE$ac_delim
++AMDEPBACKSLASH!$AMDEPBACKSLASH$ac_delim
++CCDEPMODE!$CCDEPMODE$ac_delim
++am__fastdepCC_TRUE!$am__fastdepCC_TRUE$ac_delim
++am__fastdepCC_FALSE!$am__fastdepCC_FALSE$ac_delim
++AR!$AR$ac_delim
++RANLIB!$RANLIB$ac_delim
++LN_S!$LN_S$ac_delim
++LIBTOOL!$LIBTOOL$ac_delim
++WARN_CFLAGS!$WARN_CFLAGS$ac_delim
++NO_WERROR!$NO_WERROR$ac_delim
++MAINTAINER_MODE_TRUE!$MAINTAINER_MODE_TRUE$ac_delim
++MAINTAINER_MODE_FALSE!$MAINTAINER_MODE_FALSE$ac_delim
++MAINT!$MAINT$ac_delim
++INSTALL_LIBBFD_TRUE!$INSTALL_LIBBFD_TRUE$ac_delim
++INSTALL_LIBBFD_FALSE!$INSTALL_LIBBFD_FALSE$ac_delim
++_ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+   fi
+-fi # test -n "$CONFIG_FILES"
++done
++
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
++_ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++CEOF$ac_eof
++_ACEOF
++
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++host_noncanonical!$host_noncanonical$ac_delim
++target_noncanonical!$target_noncanonical$ac_delim
++bfdlibdir!$bfdlibdir$ac_delim
++bfdincludedir!$bfdincludedir$ac_delim
++CPP!$CPP$ac_delim
++GREP!$GREP$ac_delim
++EGREP!$EGREP$ac_delim
++ALLOCA!$ALLOCA$ac_delim
++USE_NLS!$USE_NLS$ac_delim
++MSGFMT!$MSGFMT$ac_delim
++GMSGFMT!$GMSGFMT$ac_delim
++XGETTEXT!$XGETTEXT$ac_delim
++USE_INCLUDED_LIBINTL!$USE_INCLUDED_LIBINTL$ac_delim
++CATALOGS!$CATALOGS$ac_delim
++CATOBJEXT!$CATOBJEXT$ac_delim
++DATADIRNAME!$DATADIRNAME$ac_delim
++GMOFILES!$GMOFILES$ac_delim
++INSTOBJEXT!$INSTOBJEXT$ac_delim
++INTLDEPS!$INTLDEPS$ac_delim
++INTLLIBS!$INTLLIBS$ac_delim
++INTLOBJS!$INTLOBJS$ac_delim
++POFILES!$POFILES$ac_delim
++POSUB!$POSUB$ac_delim
++INCLUDE_LOCALE_H!$INCLUDE_LOCALE_H$ac_delim
++GT_NO!$GT_NO$ac_delim
++GT_YES!$GT_YES$ac_delim
++MKINSTALLDIRS!$MKINSTALLDIRS$ac_delim
++l!$l$ac_delim
++HDEFINES!$HDEFINES$ac_delim
++BFD_HOST_64BIT_LONG!$BFD_HOST_64BIT_LONG$ac_delim
++BFD_HOST_LONG_LONG!$BFD_HOST_LONG_LONG$ac_delim
++BFD_HOST_64_BIT_DEFINED!$BFD_HOST_64_BIT_DEFINED$ac_delim
++BFD_HOST_64_BIT!$BFD_HOST_64_BIT$ac_delim
++BFD_HOST_U_64_BIT!$BFD_HOST_U_64_BIT$ac_delim
++CC_FOR_BUILD!$CC_FOR_BUILD$ac_delim
++EXEEXT_FOR_BUILD!$EXEEXT_FOR_BUILD$ac_delim
++COREFILE!$COREFILE$ac_delim
++COREFLAG!$COREFLAG$ac_delim
++WIN32LDFLAGS!$WIN32LDFLAGS$ac_delim
++WIN32LIBADD!$WIN32LIBADD$ac_delim
++TDEFINES!$TDEFINES$ac_delim
++wordsize!$wordsize$ac_delim
++bfd_libs!$bfd_libs$ac_delim
++all_backends!$all_backends$ac_delim
++bfd_backends!$bfd_backends$ac_delim
++bfd_machines!$bfd_machines$ac_delim
++bfd_default_target_size!$bfd_default_target_size$ac_delim
++bfd_file_ptr!$bfd_file_ptr$ac_delim
++bfd_ufile_ptr!$bfd_ufile_ptr$ac_delim
++tdefaults!$tdefaults$ac_delim
++LIBOBJS!$LIBOBJS$ac_delim
++LTLIBOBJS!$LTLIBOBJS$ac_delim
+ _ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 52; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
++  fi
++done
++
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-2.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end
++_ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++:end
++s/|#_!!_#|//g
++CEOF$ac_eof
++_ACEOF
++
++
++# VPATH may cause trouble with some makes, so we remove $(srcdir),
++# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
++# trailing colons and then remove the whole line if VPATH becomes empty
++# (actually we leave an empty line to preserve line numbers).
++if test "x$srcdir" = x.; then
++  ac_vpsub='/^[        ]*VPATH[        ]*=/{
++s/:*\$(srcdir):*/:/
++s/:*\${srcdir}:*/:/
++s/:*@srcdir@:*/:/
++s/^\([^=]*=[   ]*\):*/\1/
++s/:*$//
++s/^[^=]*=[     ]*$//
++}'
++fi
++
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+-  case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++fi # test -n "$CONFIG_FILES"
++
++
++for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS
++do
++  case $ac_tag in
++  :[FHLC]) ac_mode=$ac_tag; continue;;
++  esac
++  case $ac_mode$ac_tag in
++  :[FHL]*:*);;
++  :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
++echo "$as_me: error: Invalid tag $ac_tag." >&2;}
++   { (exit 1); exit 1; }; };;
++  :[FH]-) ac_tag=-:-;;
++  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
++  esac
++  ac_save_IFS=$IFS
++  IFS=:
++  set x $ac_tag
++  IFS=$ac_save_IFS
++  shift
++  ac_file=$1
++  shift
++
++  case $ac_mode in
++  :L) ac_source=$1;;
++  :[FH])
++    ac_file_inputs=
++    for ac_f
++    do
++      case $ac_f in
++      -) ac_f="$tmp/stdin";;
++      *) # Look for the file first in the build tree, then in the source tree
++       # (if the path is not absolute).  The absolute path cannot be DOS-style,
++       # because $ac_f cannot contain `:'.
++       test -f "$ac_f" ||
++         case $ac_f in
++         [\\/$]*) false;;
++         *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
++         esac ||
++         { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
++echo "$as_me: error: cannot find input file: $ac_f" >&2;}
++   { (exit 1); exit 1; }; };;
++      esac
++      ac_file_inputs="$ac_file_inputs $ac_f"
++    done
++
++    # Let's still pretend it is `configure' which instantiates (i.e., don't
++    # use $as_me), people would be surprised to read:
++    #    /* config.h.  Generated by config.status.  */
++    configure_input="Generated from "`IFS=:
++        echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."
++    if test x"$ac_file" != x-; then
++      configure_input="$ac_file.  $configure_input"
++      { echo "$as_me:$LINENO: creating $ac_file" >&5
++echo "$as_me: creating $ac_file" >&6;}
++    fi
++
++    case $ac_tag in
++    *:-:* | *:-) cat >"$tmp/stdin";;
++    esac
++    ;;
+   esac
+-  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
+-  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
++  ac_dir=`$as_dirname -- "$ac_file" ||
+ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$ac_file" : 'X\(//\)[^/]' \| \
+        X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++  { as_dir="$ac_dir"
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+   ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  case $ac_mode in
++  :F)
++  #
++  # CONFIG_FILE
++  #
+   case $INSTALL in
+   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+-  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
++  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+   esac
++_ACEOF
+-  if test x"$ac_file" != x-; then
+-    { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-    rm -f "$ac_file"
+-  fi
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    configure_input=
+-  else
+-    configure_input="$ac_file.  "
+-  fi
+-  configure_input=$configure_input"Generated from `echo $ac_file_in |
+-                                   sed 's,.*/,,'` by configure."
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
++cat >>$CONFIG_STATUS <<\_ACEOF
++# If the template does not know about datarootdir, expand it.
++# FIXME: This hack should be removed a few years after 2.60.
++ac_datarootdir_hack=; ac_datarootdir_seen=
++
++case `sed -n '/datarootdir/ {
++  p
++  q
++}
++/@datadir@/p
++/@docdir@/p
++/@infodir@/p
++/@localedir@/p
++/@mandir@/p
++' $ac_file_inputs` in
++*datarootdir*) ac_datarootdir_seen=yes;;
++*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
++  { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
++echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
++_ACEOF
++cat >>$CONFIG_STATUS <<_ACEOF
++  ac_datarootdir_hack='
++  s&@datadir@&$datadir&g
++  s&@docdir@&$docdir&g
++  s&@infodir@&$infodir&g
++  s&@localedir@&$localedir&g
++  s&@mandir@&$mandir&g
++    s&\\\${datarootdir}&$datarootdir&g' ;;
++esac
+ _ACEOF
++
++# Neutralize VPATH when `$srcdir' = `.'.
++# Shell code in configure.ac might set extrasub.
++# FIXME: do we really want to maintain this feature?
+ cat >>$CONFIG_STATUS <<_ACEOF
+   sed "$ac_vpsub
+ $extrasub
+@@ -15521,248 +15939,130 @@ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+ :t
+ /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+-s,@configure_input@,$configure_input,;t t
+-s,@srcdir@,$ac_srcdir,;t t
+-s,@abs_srcdir@,$ac_abs_srcdir,;t t
+-s,@top_srcdir@,$ac_top_srcdir,;t t
+-s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+-s,@builddir@,$ac_builddir,;t t
+-s,@abs_builddir@,$ac_abs_builddir,;t t
+-s,@top_builddir@,$ac_top_builddir,;t t
+-s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
+-s,@INSTALL@,$ac_INSTALL,;t t
+-" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
+-  rm -f $tmp/stdin
+-  if test x"$ac_file" != x-; then
+-    mv $tmp/out $ac_file
+-  else
+-    cat $tmp/out
+-    rm -f $tmp/out
+-  fi
+-
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_HEADER section.
+-#
+-
+-# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
+-# NAME is the cpp macro being defined and VALUE is the value it is being given.
+-#
+-# ac_d sets the value in "#define NAME VALUE" lines.
+-ac_dA='s,^\([  ]*\)#\([        ]*define[       ][      ]*\)'
+-ac_dB='[       ].*$,\1#\2'
+-ac_dC=' '
+-ac_dD=',;t'
+-# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
+-ac_uA='s,^\([  ]*\)#\([        ]*\)undef\([    ][      ]*\)'
+-ac_uB='$,\1#\2define\3'
+-ac_uC=' '
+-ac_uD=',;t'
++s&@configure_input@&$configure_input&;t t
++s&@top_builddir@&$ac_top_builddir_sub&;t t
++s&@srcdir@&$ac_srcdir&;t t
++s&@abs_srcdir@&$ac_abs_srcdir&;t t
++s&@top_srcdir@&$ac_top_srcdir&;t t
++s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
++s&@builddir@&$ac_builddir&;t t
++s&@abs_builddir@&$ac_abs_builddir&;t t
++s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
++s&@INSTALL@&$ac_INSTALL&;t t
++$ac_datarootdir_hack
++" $ac_file_inputs | sed -f "$tmp/subs-1.sed" | sed -f "$tmp/subs-2.sed" >$tmp/out
++
++test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
++  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
++  { ac_out=`sed -n '/^[        ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
++  { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&5
++echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&2;}
+-for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
++  rm -f "$tmp/stdin"
+   case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++  -) cat "$tmp/out"; rm -f "$tmp/out";;
++  *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;
+   esac
++ ;;
++  :H)
++  #
++  # CONFIG_HEADER
++  #
++_ACEOF
++
++# Transform confdefs.h into a sed script `conftest.defines', that
++# substitutes the proper values into config.h.in to produce config.h.
++rm -f conftest.defines conftest.tail
++# First, append a space to every undef/define line, to ease matching.
++echo 's/$/ /' >conftest.defines
++# Then, protect against being on the right side of a sed subst, or in
++# an unquoted here document, in config.status.  If some macros were
++# called several times there might be several #defines for the same
++# symbol, which is useless.  But do not sort them, since the last
++# AC_DEFINE must be honored.
++ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
++# These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where
++# NAME is the cpp macro being defined, VALUE is the value it is being given.
++# PARAMS is the parameter list in the macro definition--in most cases, it's
++# just an empty string.
++ac_dA='s,^\\([         #]*\\)[^        ]*\\([  ]*'
++ac_dB='\\)[    (].*,\\1define\\2'
++ac_dC=' '
++ac_dD=' ,'
+-  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       # Do quote $f, to prevent DOS paths from being IFS'd.
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
+-  # Remove the trailing spaces.
+-  sed 's/[     ]*$//' $ac_file_inputs >$tmp/in
+-
+-_ACEOF
+-
+-# Transform confdefs.h into two sed scripts, `conftest.defines' and
+-# `conftest.undefs', that substitutes the proper values into
+-# config.h.in to produce config.h.  The first handles `#define'
+-# templates, and the second `#undef' templates.
+-# And first: Protect against being on the right side of a sed subst in
+-# config.status.  Protect against being in an unquoted here document
+-# in config.status.
+-rm -f conftest.defines conftest.undefs
+-# Using a here document instead of a string reduces the quoting nightmare.
+-# Putting comments in sed scripts is not portable.
+-#
+-# `end' is used to avoid that the second main sed command (meant for
+-# 0-ary CPP macros) applies to n-ary macro definitions.
+-# See the Autoconf documentation for `clear'.
+-cat >confdef2sed.sed <<\_ACEOF
+-s/[\\&,]/\\&/g
+-s,[\\$`],\\&,g
+-t clear
+-: clear
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
+-t end
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
+-: end
+-_ACEOF
+-# If some macros were called several times there might be several times
+-# the same #defines, which is useless.  Nevertheless, we may not want to
+-# sort them, since we want the *last* AC-DEFINE to be honored.
+-uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
+-sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
+-rm -f confdef2sed.sed
++uniq confdefs.h |
++  sed -n '
++      t rset
++      :rset
++      s/^[     ]*#[    ]*define[       ][      ]*//
++      t ok
++      d
++      :ok
++      s/[\\&,]/\\&/g
++      s/^\('"$ac_word_re"'\)\(([^()]*)\)[      ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p
++      s/^\('"$ac_word_re"'\)[  ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p
++  ' >>conftest.defines
+-# This sed command replaces #undef with comments.  This is necessary, for
++# Remove the space that was appended to ease matching.
++# Then replace #undef with comments.  This is necessary, for
+ # example, in the case of _POSIX_SOURCE, which is predefined and required
+ # on some systems where configure will not decide to define it.
+-cat >>conftest.undefs <<\_ACEOF
+-s,^[   ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
++# (The regexp can be short, since the line contains either #define or #undef.)
++echo 's/ $//
++s,^[   #]*u.*,/* & */,' >>conftest.defines
++
++# Break up conftest.defines:
++ac_max_sed_lines=50
++
++# First sed command is:        sed -f defines.sed $ac_file_inputs >"$tmp/out1"
++# Second one is:       sed -f defines.sed "$tmp/out1" >"$tmp/out2"
++# Third one will be:   sed -f defines.sed "$tmp/out2" >"$tmp/out1"
++# et cetera.
++ac_in='$ac_file_inputs'
++ac_out='"$tmp/out1"'
++ac_nxt='"$tmp/out2"'
++
++while :
++do
++  # Write a here document:
++    cat >>$CONFIG_STATUS <<_ACEOF
++    # First, check the format of the line:
++    cat >"\$tmp/defines.sed" <<\\CEOF
++/^[    ]*#[    ]*undef[        ][      ]*$ac_word_re[  ]*\$/b def
++/^[    ]*#[    ]*define[       ][      ]*$ac_word_re[(         ]/b def
++b
++:def
+ _ACEOF
+-
+-# Break up conftest.defines because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
+-echo '  if grep "^[    ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
+-echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
+-echo '  :' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.defines >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/defines.sed.
+-  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#define' lines.
+-  echo '/^[    ]*#[    ]*define/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
++  sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS
+   echo 'CEOF
+-  sed -f $tmp/defines.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
++    sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS
++  ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in
++  sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail
++  grep . conftest.tail >/dev/null || break
+   rm -f conftest.defines
+   mv conftest.tail conftest.defines
+ done
+-rm -f conftest.defines
+-echo '  fi # grep' >>$CONFIG_STATUS
+-echo >>$CONFIG_STATUS
+-
+-# Break up conftest.undefs because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.undefs >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/undefs.sed.
+-  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#undef'
+-  echo '/^[    ]*#[    ]*undef/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
+-  echo 'CEOF
+-  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
+-  rm -f conftest.undefs
+-  mv conftest.tail conftest.undefs
+-done
+-rm -f conftest.undefs
++rm -f conftest.defines conftest.tail
++echo "ac_result=$ac_in" >>$CONFIG_STATUS
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    echo "/* Generated by configure.  */" >$tmp/config.h
+-  else
+-    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
+-  fi
+-  cat $tmp/in >>$tmp/config.h
+-  rm -f $tmp/in
+   if test x"$ac_file" != x-; then
+-    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
++    echo "/* $configure_input  */" >"$tmp/config.h"
++    cat "$ac_result" >>"$tmp/config.h"
++    if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then
+       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
+ echo "$as_me: $ac_file is unchanged" >&6;}
+     else
+-      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_file" : 'X\(//\)[^/]' \| \
+-       X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-      { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+       rm -f $ac_file
+-      mv $tmp/config.h $ac_file
++      mv "$tmp/config.h" $ac_file
+     fi
+   else
+-    cat $tmp/config.h
+-    rm -f $tmp/config.h
++    echo "/* $configure_input  */"
++    cat "$ac_result"
+   fi
++  rm -f "$tmp/out12"
+ # Compute $ac_file's index in $config_headers.
+ _am_stamp_count=1
+ for _am_header in $config_headers :; do
+@@ -15773,135 +16073,39 @@ for _am_header in $config_headers :; do
+       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+   esac
+ done
+-echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
++echo "timestamp for $ac_file" >`$as_dirname -- $ac_file ||
+ $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X$ac_file : 'X\(//\)[^/]' \| \
+        X$ac_file : 'X\(//\)$' \| \
+-       X$ac_file : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X$ac_file : 'X\(/\)' \| . 2>/dev/null ||
+ echo X$ac_file |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`/stamp-h$_am_stamp_count
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_COMMANDS section.
+-#
+-for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
+-  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
+-  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
+-$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_dest" : 'X\(//\)[^/]' \| \
+-       X"$ac_dest" : 'X\(//\)$' \| \
+-       X"$ac_dest" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_dest" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+-  ac_builddir=.
+-
+-if test "$ac_dir" != .; then
+-  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
+-
+-case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
+-    ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
+-    ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`/stamp-h$_am_stamp_count
++ ;;
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  :C)  { echo "$as_me:$LINENO: executing $ac_file commands" >&5
++echo "$as_me: executing $ac_file commands" >&6;}
++ ;;
++  esac
+-  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
+-echo "$as_me: executing $ac_dest commands" >&6;}
+-  case $ac_dest in
+-    depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
++  case $ac_file$ac_mode in
++    "depfiles":C) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
+   # Strip MF so we end up with the name of the file.
+   mf=`echo "$mf" | sed -e 's/:.*$//'`
+   # Check whether this is an Automake generated Makefile or not.
+@@ -15911,18 +16115,29 @@ echo "$as_me: executing $ac_dest command
+   # each Makefile.in and add a new line on top of each file to say so.
+   # So let's grep whole file.
+   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
+-    dirpart=`(dirname "$mf") 2>/dev/null ||
++    dirpart=`$as_dirname -- "$mf" ||
+ $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$mf" : 'X\(//\)[^/]' \| \
+        X"$mf" : 'X\(//\)$' \| \
+-       X"$mf" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$mf" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   else
+     continue
+   fi
+@@ -15944,54 +16159,80 @@ echo X"$mf" |
+        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+     # Make sure the directory exists.
+     test -f "$dirpart/$file" && continue
+-    fdir=`(dirname "$file") 2>/dev/null ||
++    fdir=`$as_dirname -- "$file" ||
+ $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$file" : 'X\(//\)[^/]' \| \
+        X"$file" : 'X\(//\)$' \| \
+-       X"$file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    { if $as_mkdir_p; then
+-    mkdir -p $dirpart/$fdir
+-  else
+-    as_dir=$dirpart/$fdir
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++    { as_dir=$dirpart/$fdir
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
+-echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+     # echo "creating $dirpart/$file"
+     echo '# dummy' > "$dirpart/$file"
+   done
+ done
+  ;;
+-    default ) sed -e '/SRC-POTFILES =/r po/SRC-POTFILES' -e '/BLD-POTFILES =/r po/BLD-POTFILES' po/Makefile.in > po/Makefile ;;
++    "default":C) sed -e '/SRC-POTFILES =/r po/SRC-POTFILES' -e '/BLD-POTFILES =/r po/BLD-POTFILES' po/Makefile.in > po/Makefile ;;
++
+   esac
+-done
+-_ACEOF
++done # for ac_tag
+-cat >>$CONFIG_STATUS <<\_ACEOF
+ { (exit 0); exit 0; }
+ _ACEOF
+diff -Nrup binutils-2.17/bfd/configure.in binutils-2.17-atmel/bfd/configure.in
+--- binutils-2.17/bfd/configure.in     2006-06-23 20:17:07.000000000 +0200
++++ binutils-2.17-atmel/bfd/configure.in       2007-02-12 15:37:09.000000000 +0100
+@@ -8,7 +8,7 @@ AC_CONFIG_SRCDIR([libbfd.c])
+ AC_CANONICAL_TARGET
+ AC_ISC_POSIX
+-AM_INIT_AUTOMAKE(bfd, 2.17)
++AM_INIT_AUTOMAKE(bfd, 2.17.atmel.0.0.99)
+ dnl These must be called before AM_PROG_LIBTOOL, because it may want
+ dnl to call AC_CHECK_PROG.
+@@ -583,6 +583,7 @@ do
+     bfd_efi_app_ia64_vec)     tb="$tb efi-app-ia64.lo pepigen.lo cofflink.lo"; target_size=64 ;;
+     bfd_elf32_am33lin_vec)    tb="$tb elf32-am33lin.lo elf32.lo $elf" ;;
+     bfd_elf32_avr_vec)                tb="$tb elf32-avr.lo elf32.lo $elf" ;;
++    bfd_elf32_avr32_vec)      tb="$tb elf32-avr32.lo elf32.lo $elf" ;;
+     bfd_elf32_bfin_vec)               tb="$tb elf32-bfin.lo elf32.lo $elf" ;;
+     bfd_elf32_bfinfdpic_vec)  tb="$tb elf32-bfin.lo elf32.lo $elf" ;;
+     bfd_elf32_big_generic_vec)        tb="$tb elf32-gen.lo elf32.lo $elf" ;;
+diff -Nrup binutils-2.17/bfd/cpu-avr32.c binutils-2.17-atmel/bfd/cpu-avr32.c
+--- binutils-2.17/bfd/cpu-avr32.c      1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/bfd/cpu-avr32.c        2006-11-10 15:05:48.000000000 +0100
+@@ -0,0 +1,49 @@
++/* BFD library support routines for AVR32.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   This is part of BFD, the Binary File Descriptor library.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
++
++#include "bfd.h"
++#include "sysdep.h"
++#include "libbfd.h"
++
++#define N(machine, print, default, next)                      \
++  {                                                           \
++    32,                               /* 32 bits in a word */         \
++    32,                               /* 32 bits in an address */     \
++    8,                                /* 8 bits in a byte */          \
++    bfd_arch_avr32,           /* architecture */              \
++    machine,                  /* machine */                   \
++    "avr32",                  /* arch name */                 \
++    print,                    /* printable name */            \
++    1,                                /* section align power */       \
++    default,                  /* the default machine? */      \
++    bfd_default_compatible,                                   \
++    bfd_default_scan,                                         \
++    next,                                                     \
++  }
++
++static const bfd_arch_info_type cpu_info[] =
++{
++  N(bfd_mach_avr32_ap, "avr32:ap", FALSE, &cpu_info[1]),
++  N(bfd_mach_avr32_uc, "avr32:uc", FALSE, NULL),
++};
++
++const bfd_arch_info_type bfd_avr32_arch =
++  N(bfd_mach_avr32_ap, "avr32:ap", TRUE, &cpu_info[0]);
+diff -Nrup binutils-2.17/bfd/doc/Makefile.in binutils-2.17-atmel/bfd/doc/Makefile.in
+--- binutils-2.17/bfd/doc/Makefile.in  2006-04-06 23:49:26.000000000 +0200
++++ binutils-2.17-atmel/bfd/doc/Makefile.in    2007-02-20 16:07:07.000000000 +0100
+@@ -1,4 +1,4 @@
+-# Makefile.in generated by automake 1.9.5 from Makefile.am.
++# Makefile.in generated by automake 1.9.6 from Makefile.am.
+ # @configure_input@
+ # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+@@ -105,6 +105,7 @@ EXEEXT = @EXEEXT@
+ EXEEXT_FOR_BUILD = @EXEEXT_FOR_BUILD@
+ GMOFILES = @GMOFILES@
+ GMSGFMT = @GMSGFMT@
++GREP = @GREP@
+ GT_NO = @GT_NO@
+ GT_YES = @GT_YES@
+ HDEFINES = @HDEFINES@
+@@ -154,10 +155,7 @@ WARN_CFLAGS = @WARN_CFLAGS@
+ WIN32LDFLAGS = @WIN32LDFLAGS@
+ WIN32LIBADD = @WIN32LIBADD@
+ XGETTEXT = @XGETTEXT@
+-ac_ct_AR = @ac_ct_AR@
+ ac_ct_CC = @ac_ct_CC@
+-ac_ct_RANLIB = @ac_ct_RANLIB@
+-ac_ct_STRIP = @ac_ct_STRIP@
+ all_backends = @all_backends@
+ am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+ am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+@@ -183,6 +181,7 @@ build_vendor = @build_vendor@
+ datadir = @datadir@
+ datarootdir = @datarootdir@
+ docdir = @docdir@
++dvidir = @dvidir@
+ exec_prefix = @exec_prefix@
+ host = @host@
+ host_alias = @host_alias@
+@@ -197,12 +196,15 @@ install_sh = @install_sh@
+ l = @l@
+ libdir = @libdir@
+ libexecdir = @libexecdir@
++localedir = @localedir@
+ localstatedir = @localstatedir@
+ mandir = @mandir@
+ mkdir_p = @mkdir_p@
+ oldincludedir = @oldincludedir@
++pdfdir = @pdfdir@
+ prefix = @prefix@
+ program_transform_name = @program_transform_name@
++psdir = @psdir@
+ sbindir = @sbindir@
+ sharedstatedir = @sharedstatedir@
+ sysconfdir = @sysconfdir@
+@@ -364,9 +366,11 @@ distclean-libtool:
+       restore=: && backupdir="$(am__leading_dot)am$$$$" && \
+       am__cwd=`pwd` && cd $(srcdir) && \
+       rm -rf $$backupdir && mkdir $$backupdir && \
+-      for f in $@ $@-[0-9] $@-[0-9][0-9] $(@:.info=).i[0-9] $(@:.info=).i[0-9][0-9]; do \
+-        if test -f $$f; then mv $$f $$backupdir; restore=mv; else :; fi; \
+-      done; \
++      if ($(MAKEINFO) --version) >/dev/null 2>&1; then \
++        for f in $@ $@-[0-9] $@-[0-9][0-9] $(@:.info=).i[0-9] $(@:.info=).i[0-9][0-9]; do \
++          if test -f $$f; then mv $$f $$backupdir; restore=mv; else :; fi; \
++        done; \
++      else :; fi && \
+       cd "$$am__cwd"; \
+       if $(MAKEINFO) $(AM_MAKEINFOFLAGS) $(MAKEINFOFLAGS) -I $(srcdir) \
+        -o $@ $<; \
+@@ -408,6 +412,7 @@ bfd.dvi: bfd.texinfo 
+ bfd.pdf: bfd.texinfo 
+ bfd.html: bfd.texinfo 
+ .dvi.ps:
++      TEXINPUTS="$(am__TEXINFO_TEX_DIR)$(PATH_SEPARATOR)$$TEXINPUTS" \
+       $(DVIPS) -o $@ $<
+ uninstall-info-am:
+@@ -440,10 +445,13 @@ dist-info: $(INFO_DEPS)
+           $(srcdir)/*) base=`echo "$$base" | sed "s|^$$srcdirstrip/||"`;; \
+         esac; \
+         if test -f $$base; then d=.; else d=$(srcdir); fi; \
+-        for file in $$d/$$base*; do \
+-          relfile=`expr "$$file" : "$$d/\(.*\)"`; \
+-          test -f $(distdir)/$$relfile || \
+-            cp -p $$file $(distdir)/$$relfile; \
++        base_i=`echo "$$base" | sed 's|\.info$$||;s|$$|.i|'`; \
++        for file in $$d/$$base $$d/$$base-[0-9] $$d/$$base-[0-9][0-9] $$d/$$base_i[0-9] $$d/$$base_i[0-9][0-9]; do \
++          if test -f $$file; then \
++            relfile=`expr "$$file" : "$$d/\(.*\)"`; \
++            test -f $(distdir)/$$relfile || \
++              cp -p $$file $(distdir)/$$relfile; \
++          else :; fi; \
+         done; \
+       done
+diff -Nrup binutils-2.17/bfd/elf32-avr32.c binutils-2.17-atmel/bfd/elf32-avr32.c
+--- binutils-2.17/bfd/elf32-avr32.c    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/bfd/elf32-avr32.c      2007-02-12 15:37:09.000000000 +0100
+@@ -0,0 +1,3847 @@
++/* AVR32-specific support for 32-bit ELF.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   This file is part of BFD, the Binary File Descriptor library.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
++
++#include "bfd.h"
++#include "sysdep.h"
++#include "bfdlink.h"
++#include "libbfd.h"
++#include "elf-bfd.h"
++#include "elf/avr32.h"
++
++#define xDEBUG
++#define xRELAX_DEBUG
++
++#ifdef DEBUG
++# define pr_debug(fmt, args...) fprintf(stderr, fmt, ##args)
++#else
++# define pr_debug(fmt, args...) do { } while (0)
++#endif
++
++#ifdef RELAX_DEBUG
++# define RDBG(fmt, args...) fprintf(stderr, fmt, ##args)
++#else
++# define RDBG(fmt, args...) do { } while (0)
++#endif
++
++/* When things go wrong, we want it to blow up, damnit! */
++#undef BFD_ASSERT
++#undef abort
++#define BFD_ASSERT(expr)                                      \
++  do                                                          \
++    {                                                         \
++      if (!(expr))                                            \
++      {                                                       \
++        bfd_assert(__FILE__, __LINE__);                       \
++        abort();                                              \
++      }                                                       \
++    }                                                         \
++  while (0)
++
++/* The name of the dynamic interpreter. This is put in the .interp section. */
++#define ELF_DYNAMIC_INTERPRETER               "/lib/ld.so.1"
++
++#define AVR32_GOT_HEADER_SIZE         8
++#define AVR32_FUNCTION_STUB_SIZE      8
++
++#define ELF_R_INFO(x, y) ELF32_R_INFO(x, y)
++#define ELF_R_TYPE(x) ELF32_R_TYPE(x)
++#define ELF_R_SYM(x) ELF32_R_SYM(x)
++
++#define NOP_OPCODE 0xd703
++
++\f
++/* Mapping between BFD relocations and ELF relocations */
++
++static reloc_howto_type *
++bfd_elf32_bfd_reloc_type_lookup(bfd *abfd, bfd_reloc_code_real_type code);
++static void
++avr32_info_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst);
++
++/* Generic HOWTO */
++#define GENH(name, align, size, bitsize, pcrel, bitpos, complain, mask)       \
++  HOWTO(name, align, size, bitsize, pcrel, bitpos,                    \
++      complain_overflow_##complain, bfd_elf_generic_reloc, #name,     \
++      FALSE, 0, mask, pcrel)
++
++static reloc_howto_type elf_avr32_howto_table[] = {
++  /*   NAME            ALN SZ BSZ PCREL  BP COMPLAIN  MASK        */
++  GENH(R_AVR32_NONE,    0, 0, 0,  FALSE, 0, dont,     0x00000000),
++
++  GENH(R_AVR32_32,      0, 2, 32, FALSE, 0, dont,     0xffffffff),
++  GENH(R_AVR32_16,      0, 1, 16, FALSE, 0, bitfield, 0x0000ffff),
++  GENH(R_AVR32_8,       0, 0,  8, FALSE, 0, bitfield, 0x000000ff),
++  GENH(R_AVR32_32_PCREL,  0, 2, 32, TRUE,  0, signed,   0xffffffff),
++  GENH(R_AVR32_16_PCREL,  0, 1, 16, TRUE,  0, signed,   0x0000ffff),
++  GENH(R_AVR32_8_PCREL,         0, 0,  8, TRUE,  0, signed,   0x000000ff),
++
++  /* Difference between two symbol (sym2 - sym1).  The reloc encodes
++     the value of sym1.  The field contains the difference before any
++     relaxing is done.  */
++  GENH(R_AVR32_DIFF32,          0, 2, 32, FALSE, 0, dont,     0xffffffff),
++  GENH(R_AVR32_DIFF16,          0, 1, 16, FALSE, 0, signed,   0x0000ffff),
++  GENH(R_AVR32_DIFF8,   0, 0,  8, FALSE, 0, signed,   0x000000ff),
++
++  GENH(R_AVR32_GOT32,   0, 2, 32, FALSE, 0, signed,   0xffffffff),
++  GENH(R_AVR32_GOT16,   0, 1, 16, FALSE, 0, signed,   0x0000ffff),
++  GENH(R_AVR32_GOT8,    0, 0,  8, FALSE, 0, signed,   0x000000ff),
++
++  GENH(R_AVR32_21S,     0, 2, 21, FALSE, 0, signed,   0x1e10ffff),
++  GENH(R_AVR32_16U,     0, 2, 16, FALSE, 0, unsigned, 0x0000ffff),
++  GENH(R_AVR32_16S,     0, 2, 16, FALSE, 0, signed,   0x0000ffff),
++  GENH(R_AVR32_8S,      0, 1,  8, FALSE, 4, signed,   0x00000ff0),
++  GENH(R_AVR32_8S_EXT,          0, 2,  8, FALSE, 0, signed,   0x000000ff),
++
++  GENH(R_AVR32_22H_PCREL, 1, 2, 21, TRUE,  0, signed, 0x1e10ffff),
++  GENH(R_AVR32_18W_PCREL, 2, 2, 16, TRUE,  0, signed, 0x0000ffff),
++  GENH(R_AVR32_16B_PCREL, 0, 2, 16, TRUE,  0, signed, 0x0000ffff),
++  GENH(R_AVR32_16N_PCREL, 0, 2, 16, TRUE,  0, signed, 0x0000ffff),
++  GENH(R_AVR32_14UW_PCREL, 2, 2, 12, TRUE, 0, unsigned, 0x0000f0ff),
++  GENH(R_AVR32_11H_PCREL, 1, 1, 10, TRUE,  4, signed, 0x00000ff3),
++  GENH(R_AVR32_10UW_PCREL, 2, 2, 8, TRUE,  0, unsigned, 0x000000ff),
++  GENH(R_AVR32_9H_PCREL,  1, 1,  8, TRUE,  4, signed, 0x00000ff0),
++  GENH(R_AVR32_9UW_PCREL, 2, 1,  7, TRUE,  4, unsigned,       0x000007f0),
++
++  GENH(R_AVR32_HI16,   16, 2, 16, FALSE, 0, dont,     0x0000ffff),
++  GENH(R_AVR32_LO16,    0, 2, 16, FALSE, 0, dont,     0x0000ffff),
++
++  GENH(R_AVR32_GOTPC,   0, 2, 32, FALSE, 0, dont,     0xffffffff),
++  GENH(R_AVR32_GOTCALL,   2, 2, 21, FALSE, 0, signed, 0x1e10ffff),
++  GENH(R_AVR32_LDA_GOT,         2, 2, 21, FALSE, 0, signed,   0x1e10ffff),
++  GENH(R_AVR32_GOT21S,          0, 2, 21, FALSE, 0, signed,   0x1e10ffff),
++  GENH(R_AVR32_GOT18SW,         2, 2, 16, FALSE, 0, signed,   0x0000ffff),
++  GENH(R_AVR32_GOT16S,          0, 2, 16, FALSE, 0, signed,   0x0000ffff),
++  GENH(R_AVR32_GOT7UW,          2, 1,  5, FALSE, 4, unsigned, 0x000001f0),
++
++  GENH(R_AVR32_32_CPENT,  0, 2, 32, FALSE, 0, dont,   0xffffffff),
++  GENH(R_AVR32_CPCALL,          2, 2, 16, TRUE,  0, signed,   0x0000ffff),
++  GENH(R_AVR32_16_CP,   0, 2, 16, TRUE,  0, signed,   0x0000ffff),
++  GENH(R_AVR32_9W_CP,   2, 1,  7, TRUE,  4, unsigned, 0x000007f0),
++
++  GENH(R_AVR32_RELATIVE,  0, 2, 32, FALSE, 0, signed, 0xffffffff),
++  GENH(R_AVR32_GLOB_DAT,  0, 2, 32, FALSE, 0, dont,   0xffffffff),
++  GENH(R_AVR32_JMP_SLOT,  0, 2, 32, FALSE, 0, dont,   0xffffffff),
++
++  GENH(R_AVR32_ALIGN,  0,  1, 0,  FALSE, 0, unsigned, 0x00000000),
++};
++
++struct elf_reloc_map
++{
++  bfd_reloc_code_real_type bfd_reloc_val;
++  unsigned char elf_reloc_val;
++};
++
++static const struct elf_reloc_map avr32_reloc_map[] =
++{
++  { BFD_RELOC_NONE,                   R_AVR32_NONE },
++
++  { BFD_RELOC_32,                     R_AVR32_32 },
++  { BFD_RELOC_16,                     R_AVR32_16 },
++  { BFD_RELOC_8,                      R_AVR32_8 },
++  { BFD_RELOC_32_PCREL,                       R_AVR32_32_PCREL },
++  { BFD_RELOC_16_PCREL,                       R_AVR32_16_PCREL },
++  { BFD_RELOC_8_PCREL,                        R_AVR32_8_PCREL },
++  { BFD_RELOC_AVR32_DIFF32,           R_AVR32_DIFF32 },
++  { BFD_RELOC_AVR32_DIFF16,           R_AVR32_DIFF16 },
++  { BFD_RELOC_AVR32_DIFF8,            R_AVR32_DIFF8 },
++  { BFD_RELOC_AVR32_GOT32,            R_AVR32_GOT32 },
++  { BFD_RELOC_AVR32_GOT16,            R_AVR32_GOT16 },
++  { BFD_RELOC_AVR32_GOT8,             R_AVR32_GOT8 },
++
++  { BFD_RELOC_AVR32_21S,              R_AVR32_21S },
++  { BFD_RELOC_AVR32_16U,              R_AVR32_16U },
++  { BFD_RELOC_AVR32_16S,              R_AVR32_16S },
++  { BFD_RELOC_AVR32_SUB5,             R_AVR32_16S },
++  { BFD_RELOC_AVR32_8S_EXT,           R_AVR32_8S_EXT },
++  { BFD_RELOC_AVR32_8S,                       R_AVR32_8S },
++
++  { BFD_RELOC_AVR32_22H_PCREL,                R_AVR32_22H_PCREL },
++  { BFD_RELOC_AVR32_18W_PCREL,                R_AVR32_18W_PCREL },
++  { BFD_RELOC_AVR32_16B_PCREL,                R_AVR32_16B_PCREL },
++  { BFD_RELOC_AVR32_16N_PCREL,                R_AVR32_16N_PCREL },
++  { BFD_RELOC_AVR32_11H_PCREL,                R_AVR32_11H_PCREL },
++  { BFD_RELOC_AVR32_10UW_PCREL,               R_AVR32_10UW_PCREL },
++  { BFD_RELOC_AVR32_9H_PCREL,         R_AVR32_9H_PCREL },
++  { BFD_RELOC_AVR32_9UW_PCREL,                R_AVR32_9UW_PCREL },
++
++  { BFD_RELOC_HI16,                   R_AVR32_HI16 },
++  { BFD_RELOC_LO16,                   R_AVR32_LO16 },
++
++  { BFD_RELOC_AVR32_GOTPC,            R_AVR32_GOTPC },
++  { BFD_RELOC_AVR32_GOTCALL,          R_AVR32_GOTCALL },
++  { BFD_RELOC_AVR32_LDA_GOT,          R_AVR32_LDA_GOT },
++  { BFD_RELOC_AVR32_GOT21S,           R_AVR32_GOT21S },
++  { BFD_RELOC_AVR32_GOT18SW,          R_AVR32_GOT18SW },
++  { BFD_RELOC_AVR32_GOT16S,           R_AVR32_GOT16S },
++  /* GOT7UW should never be generated by the assembler */
++
++  { BFD_RELOC_AVR32_32_CPENT,         R_AVR32_32_CPENT },
++  { BFD_RELOC_AVR32_CPCALL,           R_AVR32_CPCALL },
++  { BFD_RELOC_AVR32_16_CP,            R_AVR32_16_CP },
++  { BFD_RELOC_AVR32_9W_CP,            R_AVR32_9W_CP },
++
++  { BFD_RELOC_AVR32_ALIGN,            R_AVR32_ALIGN },
++};
++
++static reloc_howto_type *
++bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
++                               bfd_reloc_code_real_type code)
++{
++  unsigned int i;
++
++  for (i = 0; i < sizeof(avr32_reloc_map) / sizeof(struct elf_reloc_map); i++)
++    {
++      if (avr32_reloc_map[i].bfd_reloc_val == code)
++      return &elf_avr32_howto_table[avr32_reloc_map[i].elf_reloc_val];
++    }
++
++  return NULL;
++}
++
++static void
++avr32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
++                   arelent *cache_ptr,
++                   Elf_Internal_Rela *dst)
++{
++  unsigned int r_type;
++
++  r_type = ELF32_R_TYPE (dst->r_info);
++  BFD_ASSERT (r_type < (unsigned int) R_AVR32_max);
++  cache_ptr->howto = &elf_avr32_howto_table[r_type];
++}
++
++\f
++/* AVR32 ELF linker hash table and associated hash entries. */
++
++static struct bfd_hash_entry *
++avr32_elf_link_hash_newfunc(struct bfd_hash_entry *entry,
++                          struct bfd_hash_table *table,
++                          const char *string);
++static void
++avr32_elf_copy_indirect_symbol(struct bfd_link_info *info,
++                             struct elf_link_hash_entry *dir,
++                             struct elf_link_hash_entry *ind);
++static struct bfd_link_hash_table *
++avr32_elf_link_hash_table_create(bfd *abfd);
++
++/*
++  Try to limit memory usage to something reasonable when sorting the
++  GOT.  If we ever get more than this many references to the same
++  symbol, we may need to do something special.
++*/
++#define MAX_NR_GOT_HOLES      8192
++
++/*
++  AVR32 GOT entry.  We need to keep track of refcounts and offsets
++  simultaneously, since we need the offsets during relaxation, and we
++  also want to be able to drop GOT entries during relaxation. In
++  addition to this, we want to keep the list of GOT entries sorted so
++  that we can keep the most-used entries at the lowest offsets.
++*/
++struct got_entry
++{
++  struct got_entry *next;
++  struct got_entry **pprev;
++  int refcount;
++  bfd_signed_vma offset;
++};
++
++struct elf_avr32_link_hash_entry
++{
++  struct elf_link_hash_entry root;
++
++  /* Number of runtime relocations against this symbol.  */
++  unsigned int possibly_dynamic_relocs;
++
++  /* If there are anything but R_AVR32_GOT18 relocations against this
++     symbol, it means that someone may be taking the address of the
++     function, and we should therefore not create a stub.  */
++  bfd_boolean no_fn_stub;
++
++  /* If there is a R_AVR32_32 relocation in a read-only section
++     against this symbol, we could be in trouble. If we're linking a
++     shared library or this symbol is defined in one, it means we must
++     emit a run-time reloc for it and that's not allowed in read-only
++     sections.  */
++  asection *readonly_reloc_sec;
++  bfd_vma readonly_reloc_offset;
++
++  /* Record which frag (if any) contains the symbol.  This is used
++     during relaxation in order to avoid having to update all symbols
++     whenever we move something.  For local symbols, this information
++     is in the local_sym_frag member of struct elf_obj_tdata.  */
++  struct fragment *sym_frag;
++};
++#define avr32_elf_hash_entry(ent) ((struct elf_avr32_link_hash_entry *)(ent))
++
++struct elf_avr32_link_hash_table
++{
++  struct elf_link_hash_table root;
++
++  /* Shortcuts to get to dynamic linker sections.  */
++  asection *sgot;
++  asection *srelgot;
++  asection *sreldyn;
++  asection *sstub;
++
++  /* We use a variation of Pigeonhole Sort to sort the GOT.  After the
++     initial refcounts have been determined, we initialize
++     nr_got_holes to the highest refcount ever seen and allocate an
++     array of nr_got_holes entries for got_hole.  Each GOT entry is
++     then stored in this array at the index given by its refcount.
++
++     When a GOT entry has its refcount decremented during relaxation,
++     it is moved to a lower index in the got_hole array.
++   */
++  struct got_entry **got_hole;
++  int nr_got_holes;
++
++  /* Dynamic relocations to local symbols.  Only used when linking a
++     shared library and -Bsymbolic is not given.  */
++  unsigned int local_dynamic_relocs;
++
++  bfd_boolean relocations_analyzed;
++  bfd_boolean symbols_adjusted;
++  bfd_boolean repeat_pass;
++  unsigned int relax_iteration;
++  unsigned int relax_pass;
++};
++#define avr32_elf_hash_table(p)                               \
++  ((struct elf_avr32_link_hash_table *)((p)->hash))
++
++static struct bfd_hash_entry *
++avr32_elf_link_hash_newfunc(struct bfd_hash_entry *entry,
++                          struct bfd_hash_table *table,
++                          const char *string)
++{
++  struct elf_avr32_link_hash_entry *ret = avr32_elf_hash_entry(entry);
++
++  /* Allocate the structure if it hasn't already been allocated by a
++     subclass */
++  if (ret == NULL)
++    ret = (struct elf_avr32_link_hash_entry *)
++      bfd_hash_allocate(table, sizeof(struct elf_avr32_link_hash_entry));
++
++  if (ret == NULL)
++    return NULL;
++
++  memset(ret, 0, sizeof(struct elf_avr32_link_hash_entry));
++
++  /* Give the superclass a chance */
++  ret = (struct elf_avr32_link_hash_entry *)
++    _bfd_elf_link_hash_newfunc((struct bfd_hash_entry *)ret, table, string);
++
++  return (struct bfd_hash_entry *)ret;
++}
++
++/* Copy data from an indirect symbol to its direct symbol, hiding the
++   old indirect symbol.  Process additional relocation information.
++   Also called for weakdefs, in which case we just let
++   _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
++
++static void
++avr32_elf_copy_indirect_symbol(struct bfd_link_info *info,
++                             struct elf_link_hash_entry *dir,
++                             struct elf_link_hash_entry *ind)
++{
++  struct elf_avr32_link_hash_entry *edir, *eind;
++
++  _bfd_elf_link_hash_copy_indirect (info, dir, ind);
++
++  if (ind->root.type != bfd_link_hash_indirect)
++    return;
++
++  edir = (struct elf_avr32_link_hash_entry *)dir;
++  eind = (struct elf_avr32_link_hash_entry *)ind;
++
++  edir->possibly_dynamic_relocs += eind->possibly_dynamic_relocs;
++  edir->no_fn_stub = edir->no_fn_stub || eind->no_fn_stub;
++}
++
++static struct bfd_link_hash_table *
++avr32_elf_link_hash_table_create(bfd *abfd)
++{
++  struct elf_avr32_link_hash_table *ret;
++
++  ret = bfd_zmalloc(sizeof(*ret));
++  if (ret == NULL)
++    return NULL;
++
++  if (! _bfd_elf_link_hash_table_init(&ret->root, abfd,
++                                    avr32_elf_link_hash_newfunc,
++                      sizeof (struct elf_avr32_link_hash_entry)))
++    {
++      free(ret);
++      return NULL;
++    }
++
++  /* Prevent the BFD core from creating bogus got_entry pointers */
++  ret->root.init_got_refcount.glist = NULL;
++  ret->root.init_plt_refcount.glist = NULL;
++
++  return &ret->root.root;
++}
++
++\f
++/* Initial analysis and creation of dynamic sections and symbols */
++
++static asection *
++create_dynamic_section(bfd *dynobj, const char *name, flagword flags,
++                     unsigned int align_power);
++static struct elf_link_hash_entry *
++create_dynamic_symbol(bfd *dynobj, struct bfd_link_info *info,
++                    const char *name, asection *sec,
++                    bfd_vma offset);
++static bfd_boolean
++avr32_elf_create_got_section (bfd *dynobj, struct bfd_link_info *info);
++static bfd_boolean
++avr32_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info);
++static bfd_boolean
++avr32_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
++                  const Elf_Internal_Rela *relocs);
++static bfd_boolean
++avr32_elf_adjust_dynamic_symbol(struct bfd_link_info *info,
++                              struct elf_link_hash_entry *h);
++
++static asection *
++create_dynamic_section(bfd *dynobj, const char *name, flagword flags,
++                     unsigned int align_power)
++{
++  asection *sec;
++
++  sec = bfd_make_section(dynobj, name);
++  if (!sec
++      || !bfd_set_section_flags(dynobj, sec, flags)
++      || !bfd_set_section_alignment(dynobj, sec, align_power))
++    return NULL;
++
++  return sec;
++}
++
++static struct elf_link_hash_entry *
++create_dynamic_symbol(bfd *dynobj, struct bfd_link_info *info,
++                    const char *name, asection *sec,
++                    bfd_vma offset)
++{
++  struct bfd_link_hash_entry *bh = NULL;
++  struct elf_link_hash_entry *h;
++  const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
++
++  if (!(_bfd_generic_link_add_one_symbol
++      (info, dynobj, name, BSF_GLOBAL, sec, offset, NULL, FALSE,
++       bed->collect, &bh)))
++    return NULL;
++
++  h = (struct elf_link_hash_entry *)bh;
++  h->def_regular = 1;
++  h->type = STT_OBJECT;
++  h->other = STV_HIDDEN;
++
++  return h;
++}
++
++static bfd_boolean
++avr32_elf_create_got_section (bfd *dynobj, struct bfd_link_info *info)
++{
++  struct elf_avr32_link_hash_table *htab;
++  flagword flags;
++  const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
++
++  htab = avr32_elf_hash_table(info);
++  flags = bed->dynamic_sec_flags;
++
++  if (htab->sgot)
++    return TRUE;
++
++  htab->sgot = create_dynamic_section(dynobj, ".got", flags, 2);
++  htab->srelgot = create_dynamic_section(dynobj, ".rela.got",
++                                       flags | SEC_READONLY, 2);
++
++  if (!htab->sgot || !htab->srelgot)
++    return FALSE;
++
++  htab->root.hgot = create_dynamic_symbol(dynobj, info, "_GLOBAL_OFFSET_TABLE_",
++                                        htab->sgot, 0);
++  if (!htab->root.hgot)
++    return FALSE;
++
++  /* Make room for the GOT header */
++  htab->sgot->size += bed->got_header_size;
++
++  return TRUE;
++}
++
++/* (1) Create all dynamic (i.e. linker generated) sections that we may
++   need during the link */
++
++static bfd_boolean
++avr32_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
++{
++  struct elf_avr32_link_hash_table *htab;
++  flagword flags;
++  const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
++
++  pr_debug("(1) create dynamic sections\n");
++
++  htab = avr32_elf_hash_table(info);
++  flags = bed->dynamic_sec_flags;
++
++  if (!avr32_elf_create_got_section (dynobj, info))
++    return FALSE;
++
++  if (!htab->sreldyn)
++    htab->sreldyn = create_dynamic_section(dynobj, ".rela.dyn",
++                                         flags | SEC_READONLY, 2);
++  if (!htab->sstub)
++    htab->sstub = create_dynamic_section(dynobj, ".stub",
++                                       flags | SEC_READONLY | SEC_CODE, 2);
++
++  if (!htab->sreldyn || !htab->sstub)
++    return FALSE;
++
++  return TRUE;
++}
++
++/* (2) Go through all the relocs and count any potential GOT- or
++   PLT-references to each symbol */
++
++static bfd_boolean
++avr32_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
++                  const Elf_Internal_Rela *relocs)
++{
++  Elf_Internal_Shdr *symtab_hdr;
++  struct elf_avr32_link_hash_table *htab;
++  struct elf_link_hash_entry **sym_hashes;
++  const Elf_Internal_Rela *rel, *rel_end;
++  struct got_entry **local_got_ents;
++  struct got_entry *got;
++  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
++  asection *sgot;
++  bfd *dynobj;
++
++  pr_debug("(2) check relocs for %s:<%s> (size 0x%lx)\n",
++         abfd->filename, sec->name, sec->size);
++
++  if (info->relocatable)
++    return TRUE;
++
++  dynobj = elf_hash_table(info)->dynobj;
++  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
++  sym_hashes = elf_sym_hashes(abfd);
++  htab = avr32_elf_hash_table(info);
++  local_got_ents = elf_local_got_ents(abfd);
++  sgot = htab->sgot;
++
++  rel_end = relocs + sec->reloc_count;
++  for (rel = relocs; rel < rel_end; rel++)
++    {
++      unsigned long r_symndx, r_type;
++      struct elf_avr32_link_hash_entry *h;
++
++      r_symndx = ELF32_R_SYM(rel->r_info);
++      r_type = ELF32_R_TYPE(rel->r_info);
++
++      /* Local symbols use local_got_ents, while others store the same
++       information in the hash entry */
++      if (r_symndx < symtab_hdr->sh_info)
++      {
++        pr_debug("  (2a) processing local symbol %lu\n", r_symndx);
++        h = NULL;
++      }
++      else
++      {
++        h = (struct elf_avr32_link_hash_entry *)
++          sym_hashes[r_symndx - symtab_hdr->sh_info];
++        while (h->root.type == bfd_link_hash_indirect
++               || h->root.type == bfd_link_hash_warning)
++          h = (struct elf_avr32_link_hash_entry *)h->root.root.u.i.link;
++        pr_debug("  (2a) processing symbol %s\n", h->root.root.root.string);
++      }
++
++      /* Some relocs require special sections to be created.  */
++      switch (r_type)
++      {
++      case R_AVR32_GOT32:
++      case R_AVR32_GOT16:
++      case R_AVR32_GOT8:
++      case R_AVR32_GOT21S:
++      case R_AVR32_GOT18SW:
++      case R_AVR32_GOT16S:
++      case R_AVR32_GOT7UW:
++      case R_AVR32_LDA_GOT:
++      case R_AVR32_GOTCALL:
++        if (rel->r_addend)
++          {
++            if (info->callbacks->reloc_dangerous
++                (info, _("Non-zero addend on GOT-relative relocation"),
++                 abfd, sec, rel->r_offset) == FALSE)
++              return FALSE;
++          }
++        /* fall through */
++      case R_AVR32_GOTPC:
++        if (dynobj == NULL)
++          elf_hash_table(info)->dynobj = dynobj = abfd;
++        if (sgot == NULL && !avr32_elf_create_got_section(dynobj, info))
++          return FALSE;
++        break;
++      case R_AVR32_32:
++        /* We may need to create .rela.dyn later on.  */
++        if (dynobj == NULL
++            && (info->shared || h != NULL)
++            && (sec->flags & SEC_ALLOC))
++          elf_hash_table(info)->dynobj = dynobj = abfd;
++        break;
++      }
++
++      if (h != NULL && r_type != R_AVR32_GOT18SW)
++      h->no_fn_stub = TRUE;
++
++      switch (r_type)
++      {
++      case R_AVR32_GOT32:
++      case R_AVR32_GOT16:
++      case R_AVR32_GOT8:
++      case R_AVR32_GOT21S:
++      case R_AVR32_GOT18SW:
++      case R_AVR32_GOT16S:
++      case R_AVR32_GOT7UW:
++      case R_AVR32_LDA_GOT:
++      case R_AVR32_GOTCALL:
++        if (h != NULL)
++          {
++            got = h->root.got.glist;
++            if (!got)
++              {
++                got = bfd_zalloc(abfd, sizeof(struct got_entry));
++                if (!got)
++                  return FALSE;
++                h->root.got.glist = got;
++              }
++          }
++        else
++          {
++            if (!local_got_ents)
++              {
++                bfd_size_type size;
++                bfd_size_type i;
++                struct got_entry *tmp_entry;
++
++                size = symtab_hdr->sh_info;
++                size *= sizeof(struct got_entry *) + sizeof(struct got_entry);
++                local_got_ents = bfd_zalloc(abfd, size);
++                if (!local_got_ents)
++                  return FALSE;
++
++                elf_local_got_ents(abfd) = local_got_ents;
++
++                tmp_entry = (struct got_entry *)(local_got_ents
++                                                 + symtab_hdr->sh_info);
++                for (i = 0; i < symtab_hdr->sh_info; i++)
++                  local_got_ents[i] = &tmp_entry[i];
++              }
++
++            got = local_got_ents[r_symndx];
++          }
++
++        got->refcount++;
++        if (got->refcount > htab->nr_got_holes)
++          htab->nr_got_holes = got->refcount;
++        break;
++
++      case R_AVR32_32:
++        if ((info->shared || h != NULL)
++            && (sec->flags & SEC_ALLOC))
++          {
++            if (htab->sreldyn == NULL)
++              {
++                htab->sreldyn = create_dynamic_section(dynobj, ".rela.dyn",
++                                                       bed->dynamic_sec_flags
++                                                       | SEC_READONLY, 2);
++                if (htab->sreldyn == NULL)
++                  return FALSE;
++              }
++
++            if (sec->flags & SEC_READONLY
++                && !h->readonly_reloc_sec)
++              {
++                h->readonly_reloc_sec = sec;
++                h->readonly_reloc_offset = rel->r_offset;
++              }
++
++            if (h != NULL)
++              {
++                pr_debug("Non-GOT reference to symbol %s\n",
++                         h->root.root.root.string);
++                h->possibly_dynamic_relocs++;
++              }
++            else
++              {
++                pr_debug("Non-GOT reference to local symbol %lu\n",
++                         r_symndx);
++                htab->local_dynamic_relocs++;
++              }
++          }
++
++        break;
++
++        /* TODO: GNU_VTINHERIT and GNU_VTENTRY */
++      }
++    }
++
++  return TRUE;
++}
++
++/* (3) Adjust a symbol defined by a dynamic object and referenced by a
++   regular object.  The current definition is in some section of the
++   dynamic object, but we're not including those sections.  We have to
++   change the definition to something the rest of the link can
++   understand.  */
++
++static bfd_boolean
++avr32_elf_adjust_dynamic_symbol(struct bfd_link_info *info,
++                              struct elf_link_hash_entry *h)
++{
++  struct elf_avr32_link_hash_table *htab;
++  struct elf_avr32_link_hash_entry *havr;
++  bfd *dynobj;
++
++  pr_debug("(3) adjust dynamic symbol %s\n", h->root.root.string);
++
++  htab = avr32_elf_hash_table(info);
++  havr = (struct elf_avr32_link_hash_entry *)h;
++  dynobj = elf_hash_table(info)->dynobj;
++
++  /* Make sure we know what is going on here.  */
++  BFD_ASSERT (dynobj != NULL
++            && (h->u.weakdef != NULL
++                || (h->def_dynamic
++                    && h->ref_regular
++                    && !h->def_regular)));
++
++  /* We don't want dynamic relocations in read-only sections. */
++  if (havr->readonly_reloc_sec)
++    {
++      if (info->callbacks->reloc_dangerous
++        (info, _("dynamic relocation in read-only section"),
++         havr->readonly_reloc_sec->owner, havr->readonly_reloc_sec,
++         havr->readonly_reloc_offset) == FALSE)
++      return FALSE;
++    }
++
++  /* If this is a function, create a stub if possible and set the
++     symbol to the stub location.  */
++  if (0 && !havr->no_fn_stub)
++    {
++      if (!h->def_regular)
++      {
++        asection *s = htab->sstub;
++
++        BFD_ASSERT(s != NULL);
++
++        h->root.u.def.section = s;
++        h->root.u.def.value = s->size;
++        h->plt.offset = s->size;
++        s->size += AVR32_FUNCTION_STUB_SIZE;
++
++        return TRUE;
++      }
++    }
++  else if (h->type == STT_FUNC)
++    {
++      /* This will set the entry for this symbol in the GOT to 0, and
++       the dynamic linker will take care of this. */
++      h->root.u.def.value = 0;
++      return TRUE;
++    }
++
++  /* If this is a weak symbol, and there is a real definition, the
++     processor independent code will have arranged for us to see the
++     real definition first, and we can just use the same value.  */
++  if (h->u.weakdef != NULL)
++    {
++      BFD_ASSERT(h->u.weakdef->root.type == bfd_link_hash_defined
++               || h->u.weakdef->root.type == bfd_link_hash_defweak);
++      h->root.u.def.section = h->u.weakdef->root.u.def.section;
++      h->root.u.def.value = h->u.weakdef->root.u.def.value;
++      return TRUE;
++    }
++
++  /* This is a reference to a symbol defined by a dynamic object which
++     is not a function.  */
++
++  return TRUE;
++}
++
++\f
++/* Garbage-collection of unused sections */
++
++static asection *
++avr32_elf_gc_mark_hook(asection *sec,
++                     struct bfd_link_info *info ATTRIBUTE_UNUSED,
++                     Elf_Internal_Rela *rel,
++                     struct elf_link_hash_entry *h,
++                     Elf_Internal_Sym *sym)
++{
++  if (h)
++    {
++      switch (ELF32_R_TYPE(rel->r_info))
++      {
++        /* TODO: VTINHERIT/VTENTRY */
++      default:
++        switch (h->root.type)
++          {
++          case bfd_link_hash_defined:
++          case bfd_link_hash_defweak:
++            return h->root.u.def.section;
++
++          case bfd_link_hash_common:
++            return h->root.u.c.p->section;
++
++          default:
++            break;
++          }
++      }
++    }
++  else
++    return bfd_section_from_elf_index(sec->owner, sym->st_shndx);
++
++  return NULL;
++}
++
++/* Update the GOT entry reference counts for the section being removed. */
++static bfd_boolean
++avr32_elf_gc_sweep_hook(bfd *abfd,
++                      struct bfd_link_info *info ATTRIBUTE_UNUSED,
++                      asection *sec,
++                      const Elf_Internal_Rela *relocs)
++{
++  Elf_Internal_Shdr *symtab_hdr;
++  struct elf_avr32_link_hash_entry **sym_hashes;
++  struct got_entry **local_got_ents;
++  const Elf_Internal_Rela *rel, *relend;
++
++  if (!(sec->flags & SEC_ALLOC))
++    return TRUE;
++
++  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
++  sym_hashes = (struct elf_avr32_link_hash_entry **)elf_sym_hashes(abfd);
++  local_got_ents = elf_local_got_ents(abfd);
++
++  relend = relocs + sec->reloc_count;
++  for (rel = relocs; rel < relend; rel++)
++    {
++      unsigned long r_symndx;
++      unsigned int r_type;
++      struct elf_avr32_link_hash_entry *h = NULL;
++
++      r_symndx = ELF32_R_SYM(rel->r_info);
++      if (r_symndx >= symtab_hdr->sh_info)
++      {
++        h = sym_hashes[r_symndx - symtab_hdr->sh_info];
++        while (h->root.root.type == bfd_link_hash_indirect
++               || h->root.root.type == bfd_link_hash_warning)
++          h = (struct elf_avr32_link_hash_entry *)h->root.root.u.i.link;
++      }
++
++      r_type = ELF32_R_TYPE(rel->r_info);
++
++      switch (r_type)
++      {
++      case R_AVR32_GOT32:
++      case R_AVR32_GOT16:
++      case R_AVR32_GOT8:
++      case R_AVR32_GOT21S:
++      case R_AVR32_GOT18SW:
++      case R_AVR32_GOT16S:
++      case R_AVR32_GOT7UW:
++      case R_AVR32_LDA_GOT:
++      case R_AVR32_GOTCALL:
++        if (h)
++          h->root.got.glist->refcount--;
++        else
++          local_got_ents[r_symndx]->refcount--;
++        break;
++
++      case R_AVR32_32:
++        if (info->shared || h)
++          {
++            if (h)
++              h->possibly_dynamic_relocs--;
++            else
++              avr32_elf_hash_table(info)->local_dynamic_relocs--;
++          }
++
++      default:
++        break;
++      }
++    }
++
++  return TRUE;
++}
++\f
++/* Sizing and refcounting of dynamic sections */
++
++static void
++insert_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got);
++static void
++unref_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got);
++static void
++ref_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got);
++static bfd_boolean
++assign_got_offsets(struct elf_avr32_link_hash_table *htab);
++static bfd_boolean
++allocate_dynrelocs(struct elf_link_hash_entry *h, void *_info);
++static bfd_boolean
++avr32_elf_size_dynamic_sections (bfd *output_bfd,
++                               struct bfd_link_info *info);
++
++static void
++insert_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got)
++{
++  /* TODO: Support got_refcount > htab->nr_got_holes by using a
++     different sort algorithm for those.  */
++  BFD_ASSERT(got->refcount <= htab->nr_got_holes);
++
++  got->pprev = &htab->got_hole[got->refcount];
++  got->next = htab->got_hole[got->refcount];
++  if (got->next)
++    got->next->pprev = &got->next;
++
++  htab->got_hole[got->refcount] = got;
++}
++
++/* Decrement the refcount of a GOT entry and update its position in
++   the pigeonhole array.  */
++static void
++unref_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got)
++{
++  BFD_ASSERT(got->refcount <= htab->nr_got_holes);
++  BFD_ASSERT(got->refcount > 0);
++
++  if (got->next)
++    got->next->pprev = got->pprev;
++
++  *(got->pprev) = got->next;
++  got->refcount--;
++  insert_got_entry(htab, got);
++}
++
++static void
++ref_got_entry(struct elf_avr32_link_hash_table *htab, struct got_entry *got)
++{
++  if (got->next)
++    got->next->pprev = got->pprev;
++
++  *(got->pprev) = got->next;
++  got->refcount++;
++  insert_got_entry(htab, got);
++
++  BFD_ASSERT(got->refcount > 0);
++  BFD_ASSERT(got->refcount <= htab->nr_got_holes);
++}
++
++/* Assign offsets to all GOT entries we intend to keep.  The entries
++   that are referenced most often are placed at low offsets so that we
++   can use compact instructions as much as possible.
++
++   Returns TRUE if any offsets or the total size of the GOT changed.  */
++
++static bfd_boolean
++assign_got_offsets(struct elf_avr32_link_hash_table *htab)
++{
++  struct got_entry *got;
++  bfd_size_type got_size = 0;
++  bfd_boolean changed = FALSE;
++  bfd_signed_vma offset;
++  int i;
++
++  /* The GOT header provides the address of the DYNAMIC segment, so
++     we need that even if the GOT is otherwise empty.  */
++  if (htab->root.dynamic_sections_created)
++    got_size = AVR32_GOT_HEADER_SIZE;
++
++  for (i = htab->nr_got_holes; i > 0; i--)
++    {
++      got = htab->got_hole[i];
++      while (got)
++      {
++        if (got->refcount > 0)
++          {
++            offset = got_size;
++            if (got->offset != offset)
++              {
++                RDBG("GOT offset changed: %ld -> %ld\n",
++                     got->offset, offset);
++                changed = TRUE;
++              }
++            got->offset = offset;
++            got_size += 4;
++          }
++        got = got->next;
++      }
++    }
++
++  if (htab->sgot->size != got_size)
++    {
++      RDBG("GOT size changed: %lu -> %lu\n", htab->sgot->size,
++         got_size);
++      changed = TRUE;
++    }
++  htab->sgot->size = got_size;
++
++  RDBG("assign_got_offsets: total size %lu (%s)\n",
++       got_size, changed ? "changed" : "no change");
++
++  return changed;
++}
++
++static bfd_boolean
++allocate_dynrelocs(struct elf_link_hash_entry *h, void *_info)
++{
++  struct bfd_link_info *info = _info;
++  struct elf_avr32_link_hash_table *htab;
++  struct elf_avr32_link_hash_entry *havr;
++  struct got_entry *got;
++
++  pr_debug("  (4b) allocate_dynrelocs: %s\n", h->root.root.string);
++
++  if (h->root.type == bfd_link_hash_indirect)
++    return TRUE;
++
++  if (h->root.type == bfd_link_hash_warning)
++    /* When warning symbols are created, they **replace** the "real"
++       entry in the hash table, thus we never get to see the real
++       symbol in a hash traversal.  So look at it now.  */
++    h = (struct elf_link_hash_entry *) h->root.u.i.link;
++
++  htab = avr32_elf_hash_table(info);
++  havr = (struct elf_avr32_link_hash_entry *)h;
++
++  got = h->got.glist;
++
++  /* If got is NULL, the symbol is never referenced through the GOT */
++  if (got && got->refcount > 0)
++    {
++      insert_got_entry(htab, got);
++
++      /* Shared libraries need relocs for all GOT entries unless the
++       symbol is forced local or -Bsymbolic is used.  Others need
++       relocs for everything that is not guaranteed to be defined in
++       a regular object.  */
++      if ((info->shared
++         && !info->symbolic
++         && h->dynindx != -1)
++        || (htab->root.dynamic_sections_created
++            && h->def_dynamic
++            && !h->def_regular))
++      htab->srelgot->size += sizeof(Elf32_External_Rela);
++    }
++
++  if (havr->possibly_dynamic_relocs
++      && (info->shared
++        || (elf_hash_table(info)->dynamic_sections_created
++            && h->def_dynamic
++            && !h->def_regular)))
++    {
++      pr_debug("Allocating %d dynamic reloc against symbol %s...\n",
++             havr->possibly_dynamic_relocs, h->root.root.string);
++      htab->sreldyn->size += (havr->possibly_dynamic_relocs
++                            * sizeof(Elf32_External_Rela));
++    }
++
++  return TRUE;
++}
++
++/* (4) Calculate the sizes of the linker-generated sections and
++   allocate memory for them.  */
++
++static bfd_boolean
++avr32_elf_size_dynamic_sections (bfd *output_bfd,
++                               struct bfd_link_info *info)
++{
++  struct elf_avr32_link_hash_table *htab;
++  bfd *dynobj;
++  asection *s;
++  bfd *ibfd;
++  bfd_boolean relocs;
++
++  pr_debug("(4) size dynamic sections\n");
++
++  htab = avr32_elf_hash_table(info);
++  dynobj = htab->root.dynobj;
++  BFD_ASSERT(dynobj != NULL);
++
++  if (htab->root.dynamic_sections_created)
++    {
++      /* Initialize the contents of the .interp section to the name of
++       the dynamic loader */
++      if (info->executable)
++      {
++        s = bfd_get_section_by_name(dynobj, ".interp");
++        BFD_ASSERT(s != NULL);
++        s->size = sizeof(ELF_DYNAMIC_INTERPRETER);
++        s->contents = (unsigned char *)ELF_DYNAMIC_INTERPRETER;
++      }
++    }
++
++  if (htab->nr_got_holes > 0)
++    {
++      /* Allocate holes for the pigeonhole sort algorithm */
++      pr_debug("Highest GOT refcount: %d\n", htab->nr_got_holes);
++      if (htab->nr_got_holes >= MAX_NR_GOT_HOLES)
++      {
++        /* TODO: Do something clever (different sorting algorithm) */
++        _bfd_error_handler(_("Highest refcount %d too high (max %d)\n"),
++                           htab->nr_got_holes, MAX_NR_GOT_HOLES);
++        bfd_set_error(bfd_error_no_memory);
++        return FALSE;
++      }
++      htab->got_hole = bfd_zalloc(output_bfd,
++                                sizeof(struct got_entry *)
++                                * (htab->nr_got_holes + 1));
++      if (!htab->got_hole)
++      return FALSE;
++
++      /* Set up .got offsets for local syms.  */
++      for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
++      {
++        struct got_entry **local_got;
++        struct got_entry **end_local_got;
++        Elf_Internal_Shdr *symtab_hdr;
++        bfd_size_type locsymcount;
++
++        pr_debug("  (4a) processing file %s...\n", ibfd->filename);
++
++        BFD_ASSERT(bfd_get_flavour(ibfd) == bfd_target_elf_flavour);
++
++        local_got = elf_local_got_ents(ibfd);
++        if (!local_got)
++          continue;
++
++        symtab_hdr = &elf_tdata(ibfd)->symtab_hdr;
++        locsymcount = symtab_hdr->sh_info;
++        end_local_got = local_got + locsymcount;
++
++        for (; local_got < end_local_got; ++local_got)
++          insert_got_entry(htab, *local_got);
++      }
++    }
++
++  /* Allocate global sym .got entries and space for global sym
++     dynamic relocs */
++  elf_link_hash_traverse(&htab->root, allocate_dynrelocs, info);
++
++  /* Now that we have sorted the GOT entries, we are ready to
++     assign offsets and determine the initial size of the GOT. */
++  if (htab->sgot)
++    assign_got_offsets(htab);
++
++  /* Allocate space for local sym dynamic relocs */
++  BFD_ASSERT(htab->local_dynamic_relocs == 0 || info->shared);
++  if (htab->local_dynamic_relocs)
++    htab->sreldyn->size += (htab->local_dynamic_relocs
++                          * sizeof(Elf32_External_Rela));
++
++  /* We now have determined the sizes of the various dynamic
++     sections. Allocate memory for them. */
++  relocs = FALSE;
++  for (s = dynobj->sections; s; s = s->next)
++    {
++      if ((s->flags & SEC_LINKER_CREATED) == 0)
++      continue;
++
++      if (s == htab->sgot
++        || s == htab->sstub)
++      {
++        /* Strip this section if we don't need it */
++      }
++      else if (strncmp (bfd_get_section_name(dynobj, s), ".rela", 5) == 0)
++      {
++        if (s->size != 0)
++          relocs = TRUE;
++
++        s->reloc_count = 0;
++      }
++      else
++      {
++        /* It's not one of our sections */
++        continue;
++      }
++
++      if (s->size == 0)
++      {
++        /* Strip unneeded sections */
++        pr_debug("Stripping section %s from output...\n", s->name);
++        /* deleted function in 2.17
++      _bfd_strip_section_from_output(info, s);
++      */
++        continue;
++      }
++
++      s->contents = bfd_zalloc(dynobj, s->size);
++      if (s->contents == NULL)
++      return FALSE;
++    }
++
++  if (htab->root.dynamic_sections_created)
++    {
++      /* Add some entries to the .dynamic section.  We fill in the
++       values later, in sh_elf_finish_dynamic_sections, but we
++       must add the entries now so that we get the correct size for
++       the .dynamic section.  The DT_DEBUG entry is filled in by the
++       dynamic linker and used by the debugger.  */
++#define add_dynamic_entry(TAG, VAL) _bfd_elf_add_dynamic_entry(info, TAG, VAL)
++
++      if (!add_dynamic_entry(DT_PLTGOT, 0))
++      return FALSE;
++      if (!add_dynamic_entry(DT_AVR32_GOTSZ, 0))
++      return FALSE;
++
++      if (info->executable)
++      {
++        if (!add_dynamic_entry(DT_DEBUG, 0))
++          return FALSE;
++      }
++      if (relocs)
++      {
++        if (!add_dynamic_entry(DT_RELA, 0)
++            || !add_dynamic_entry(DT_RELASZ, 0)
++            || !add_dynamic_entry(DT_RELAENT,
++                                  sizeof(Elf32_External_Rela)))
++          return FALSE;
++      }
++    }
++#undef add_dynamic_entry
++
++  return TRUE;
++}
++
++\f
++/* Access to internal relocations, section contents and symbols.
++   (stolen from the xtensa port)  */
++
++static Elf_Internal_Rela *
++retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory);
++static void
++pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs);
++static void
++release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs);
++static bfd_byte *
++retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory);
++/*
++static void
++pin_contents (asection *sec, bfd_byte *contents);
++*/
++static void
++release_contents (asection *sec, bfd_byte *contents);
++static Elf_Internal_Sym *
++retrieve_local_syms (bfd *input_bfd, bfd_boolean keep_memory);
++/*
++static void
++pin_local_syms (bfd *input_bfd, Elf_Internal_Sym *isymbuf);
++*/
++static void
++release_local_syms (bfd *input_bfd, Elf_Internal_Sym *isymbuf);
++
++/* During relaxation, we need to modify relocations, section contents,
++   and symbol definitions, and we need to keep the original values from
++   being reloaded from the input files, i.e., we need to "pin" the
++   modified values in memory.  We also want to continue to observe the
++   setting of the "keep-memory" flag.  The following functions wrap the
++   standard BFD functions to take care of this for us.  */
++
++static Elf_Internal_Rela *
++retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
++{
++  /* _bfd_elf_link_read_relocs knows about caching, so no need for us
++     to be clever here.  */
++  return _bfd_elf_link_read_relocs(abfd, sec, NULL, NULL, keep_memory);
++}
++
++static void
++pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
++{
++  elf_section_data (sec)->relocs = internal_relocs;
++}
++
++static void
++release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
++{
++  if (internal_relocs
++      && elf_section_data (sec)->relocs != internal_relocs)
++    free (internal_relocs);
++}
++
++static bfd_byte *
++retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
++{
++  bfd_byte *contents;
++  bfd_size_type sec_size;
++
++  sec_size = bfd_get_section_limit (abfd, sec);
++  contents = elf_section_data (sec)->this_hdr.contents;
++
++  if (contents == NULL && sec_size != 0)
++    {
++      if (!bfd_malloc_and_get_section (abfd, sec, &contents))
++      {
++        if (contents)
++          free (contents);
++        return NULL;
++      }
++      if (keep_memory)
++      elf_section_data (sec)->this_hdr.contents = contents;
++    }
++  return contents;
++}
++
++/*
++static void
++pin_contents (asection *sec, bfd_byte *contents)
++{
++  elf_section_data (sec)->this_hdr.contents = contents;
++}
++*/
++static void
++release_contents (asection *sec, bfd_byte *contents)
++{
++  if (contents && elf_section_data (sec)->this_hdr.contents != contents)
++    free (contents);
++}
++
++static Elf_Internal_Sym *
++retrieve_local_syms (bfd *input_bfd, bfd_boolean keep_memory)
++{
++  Elf_Internal_Shdr *symtab_hdr;
++  Elf_Internal_Sym *isymbuf;
++  size_t locsymcount;
++
++  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
++  locsymcount = symtab_hdr->sh_info;
++
++  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
++  if (isymbuf == NULL && locsymcount != 0)
++    {
++      isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
++                                    NULL, NULL, NULL);
++      if (isymbuf && keep_memory)
++      symtab_hdr->contents = (unsigned char *) isymbuf;
++    }
++
++  return isymbuf;
++}
++
++/*
++static void
++pin_local_syms (bfd *input_bfd, Elf_Internal_Sym *isymbuf)
++{
++  elf_tdata (input_bfd)->symtab_hdr.contents = (unsigned char *)isymbuf;
++}
++
++*/
++static void
++release_local_syms (bfd *input_bfd, Elf_Internal_Sym *isymbuf)
++{
++  if (isymbuf && (elf_tdata (input_bfd)->symtab_hdr.contents
++                != (unsigned char *)isymbuf))
++    free (isymbuf);
++}
++
++\f/* Data structures used during relaxation. */
++
++enum relax_state_id {
++  RS_ERROR = -1,
++  RS_NONE = 0,
++  RS_ALIGN,
++  RS_CPENT,
++  RS_PIC_CALL,
++  RS_PIC_MCALL,
++  RS_PIC_RCALL2,
++  RS_PIC_RCALL1,
++  RS_PIC_LDA,
++  RS_PIC_LDW4,
++  RS_PIC_LDW3,
++  RS_PIC_SUB5,
++  RS_NOPIC_MCALL,
++  RS_NOPIC_RCALL2,
++  RS_NOPIC_RCALL1,
++  RS_NOPIC_LDW4,
++  RS_NOPIC_LDDPC,
++  RS_NOPIC_SUB5,
++  RS_RCALL2,
++  RS_RCALL1,
++  RS_BRC2,
++  RS_BRC1,
++  RS_BRAL,
++  RS_RJMP,
++  RS_MAX,
++};
++
++enum reference_type {
++  REF_ABSOLUTE,
++  REF_PCREL,
++  REF_CPOOL,
++  REF_GOT,
++};
++
++struct relax_state
++{
++  const char *name;
++  enum relax_state_id id;
++  enum relax_state_id direct;
++  enum relax_state_id next;
++  enum relax_state_id prev;
++
++  enum reference_type reftype;
++
++  unsigned int r_type;
++
++  bfd_vma opcode;
++  bfd_vma opcode_mask;
++
++  bfd_signed_vma range_min;
++  bfd_signed_vma range_max;
++
++  bfd_size_type size;
++};
++
++/*
++ * This is for relocs that
++ *   a) has an addend or is of type R_AVR32_DIFF32, and
++ *   b) references a different section than it's in, and
++ *   c) references a section that is relaxable
++ *
++ * as well as relocs that references the constant pool, in which case
++ * the add_frag member points to the frag containing the constant pool
++ * entry.
++ *
++ * Such relocs must be fixed up whenever we delete any code. Sections
++ * that don't have any relocs with all of the above properties don't
++ * have any additional reloc data, but sections that do will have
++ * additional data for all its relocs.
++ */
++struct avr32_reloc_data
++{
++  struct fragment *add_frag;
++  struct fragment *sub_frag;
++};
++
++/*
++ * A 'fragment' is a relaxable entity, that is, code may be added or
++ * deleted at the end of a fragment. When this happens, all subsequent
++ * fragments in the list will have their offsets updated.
++ */
++struct fragment
++{
++  enum relax_state_id state;
++  enum relax_state_id initial_state;
++
++  Elf_Internal_Rela *rela;
++  bfd_size_type size;
++  bfd_vma offset;
++  int size_adjust;
++  int offset_adjust;
++  bfd_boolean has_grown;
++
++  /* Only used by constant pool entries.  When this drops to zero, the
++     frag is discarded (i.e. size_adjust is set to -4.)  */
++  int refcount;
++};
++
++struct avr32_relax_data
++{
++  unsigned int frag_count;
++  struct fragment *frag;
++  struct avr32_reloc_data *reloc_data;
++
++  /* TRUE if this section has one or more relaxable relocations */
++  bfd_boolean is_relaxable;
++  unsigned int iteration;
++};
++
++struct avr32_section_data
++{
++  struct bfd_elf_section_data elf;
++  struct avr32_relax_data relax_data;
++};
++
++\f/* Relax state definitions */
++
++#define PIC_MOV2_OPCODE               0xe0600000
++#define PIC_MOV2_MASK         0xe1e00000
++#define PIC_MOV2_RANGE_MIN    (-1048576 * 4)
++#define PIC_MOV2_RANGE_MAX    (1048575 * 4)
++#define PIC_MCALL_OPCODE      0xf0160000
++#define PIC_MCALL_MASK                0xffff0000
++#define PIC_MCALL_RANGE_MIN   (-131072)
++#define PIC_MCALL_RANGE_MAX   (131068)
++#define RCALL2_OPCODE         0xe0a00000
++#define RCALL2_MASK           0xe1ef0000
++#define RCALL2_RANGE_MIN      (-2097152)
++#define RCALL2_RANGE_MAX      (2097150)
++#define RCALL1_OPCODE         0xc00c0000
++#define RCALL1_MASK           0xf00c0000
++#define RCALL1_RANGE_MIN      (-1024)
++#define RCALL1_RANGE_MAX      (1022)
++#define PIC_LDW4_OPCODE               0xecf00000
++#define PIC_LDW4_MASK         0xfff00000
++#define PIC_LDW4_RANGE_MIN    (-32768)
++#define PIC_LDW4_RANGE_MAX    (32767)
++#define PIC_LDW3_OPCODE               0x6c000000
++#define PIC_LDW3_MASK         0xfe000000
++#define PIC_LDW3_RANGE_MIN    (0)
++#define PIC_LDW3_RANGE_MAX    (124)
++#define SUB5_PC_OPCODE                0xfec00000
++#define SUB5_PC_MASK          0xfff00000
++#define SUB5_PC_RANGE_MIN     (-32768)
++#define SUB5_PC_RANGE_MAX     (32767)
++#define NOPIC_MCALL_OPCODE    0xf01f0000
++#define NOPIC_MCALL_MASK      0xffff0000
++#define NOPIC_MCALL_RANGE_MIN PIC_MCALL_RANGE_MIN
++#define NOPIC_MCALL_RANGE_MAX PIC_MCALL_RANGE_MAX
++#define NOPIC_LDW4_OPCODE     0xfef00000
++#define NOPIC_LDW4_MASK               0xfff00000
++#define NOPIC_LDW4_RANGE_MIN  PIC_LDW4_RANGE_MIN
++#define NOPIC_LDW4_RANGE_MAX  PIC_LDW4_RANGE_MAX
++#define LDDPC_OPCODE          0x48000000
++#define LDDPC_MASK            0xf8000000
++#define LDDPC_RANGE_MIN               0
++#define LDDPC_RANGE_MAX               508
++
++/* Only brc2 variants with cond[3] == 0 is considered, since the
++   others are not relaxable.  bral is a special case and is handled
++   separately.  */
++#define BRC2_OPCODE           0xe0800000
++#define BRC2_MASK             0xe1e80000
++#define BRC2_RANGE_MIN                (-2097152)
++#define BRC2_RANGE_MAX                (2097150)
++#define BRC1_OPCODE           0xc0000000
++#define BRC1_MASK             0xf0080000
++#define BRC1_RANGE_MIN                (-256)
++#define BRC1_RANGE_MAX                (254)
++#define BRAL_OPCODE           0xe08f0000
++#define BRAL_MASK             0xe1ef0000
++#define BRAL_RANGE_MIN                BRC2_RANGE_MIN
++#define BRAL_RANGE_MAX                BRC2_RANGE_MAX
++#define RJMP_OPCODE           0xc0080000
++#define RJMP_MASK             0xf00c0000
++#define RJMP_RANGE_MIN                (-1024)
++#define RJMP_RANGE_MAX                (1022)
++
++/* Define a relax state using the GOT  */
++#define RG(id, dir, next, prev, r_type, opc, size)                    \
++  { "RS_"#id, RS_##id, RS_##dir, RS_##next, RS_##prev, REF_GOT,               \
++      R_AVR32_##r_type,       opc##_OPCODE, opc##_MASK,                       \
++      opc##_RANGE_MIN, opc##_RANGE_MAX, size }
++/* Define a relax state using the Constant Pool  */
++#define RC(id, dir, next, prev, r_type, opc, size)                    \
++  { "RS_"#id, RS_##id, RS_##dir, RS_##next, RS_##prev, REF_CPOOL,     \
++      R_AVR32_##r_type,       opc##_OPCODE, opc##_MASK,                       \
++      opc##_RANGE_MIN, opc##_RANGE_MAX, size }
++
++/* Define a relax state using pc-relative direct reference  */
++#define RP(id, dir, next, prev, r_type, opc, size)                    \
++  { "RS_"#id, RS_##id, RS_##dir, RS_##next, RS_##prev, REF_PCREL,     \
++      R_AVR32_##r_type,       opc##_OPCODE, opc##_MASK,                       \
++      opc##_RANGE_MIN, opc##_RANGE_MAX, size }
++
++/* Define a relax state that will be handled specially  */
++#define RS(id, r_type, size)                                          \
++  { "RS_"#id, RS_##id, RS_NONE, RS_NONE, RS_NONE, REF_ABSOLUTE,               \
++      R_AVR32_##r_type, 0, 0, 0, 0, size }
++
++const struct relax_state relax_state[RS_MAX] = {
++  RS(NONE, NONE, 0),
++  RS(ALIGN, ALIGN, 0),
++  RS(CPENT, 32_CPENT, 4),
++
++  RG(PIC_CALL, PIC_RCALL1, PIC_MCALL, NONE, GOTCALL, PIC_MOV2, 10),
++  RG(PIC_MCALL, PIC_RCALL1, NONE, PIC_CALL, GOT18SW, PIC_MCALL, 4),
++  RP(PIC_RCALL2, NONE, PIC_RCALL1, PIC_MCALL, 22H_PCREL, RCALL2, 4),
++  RP(PIC_RCALL1, NONE, NONE, PIC_RCALL2, 11H_PCREL, RCALL1, 2),
++
++  RG(PIC_LDA, PIC_SUB5, PIC_LDW4, NONE, LDA_GOT, PIC_MOV2, 8),
++  RG(PIC_LDW4, PIC_SUB5, PIC_LDW3, PIC_LDA, GOT16S, PIC_LDW4, 4),
++  RG(PIC_LDW3, PIC_SUB5, NONE, PIC_LDW4, GOT7UW, PIC_LDW3, 2),
++  RP(PIC_SUB5, NONE, NONE, PIC_LDW3, 16N_PCREL, SUB5_PC, 4),
++
++  RC(NOPIC_MCALL, NOPIC_RCALL1, NONE, NONE, CPCALL, NOPIC_MCALL, 4),
++  RP(NOPIC_RCALL2, NONE, NOPIC_RCALL1, NOPIC_MCALL, 22H_PCREL, RCALL2, 4),
++  RP(NOPIC_RCALL1, NONE, NONE, NOPIC_RCALL2, 11H_PCREL, RCALL1, 2),
++
++  RC(NOPIC_LDW4, NOPIC_SUB5, NOPIC_LDDPC, NONE, 16_CP, NOPIC_LDW4, 4),
++  RC(NOPIC_LDDPC, NOPIC_SUB5, NONE, NOPIC_LDW4, 9W_CP, LDDPC, 2),
++  RP(NOPIC_SUB5, NONE, NONE, NOPIC_LDDPC, 16N_PCREL, SUB5_PC, 4),
++
++  RP(RCALL2, NONE, RCALL1, NONE, 22H_PCREL, RCALL2, 4),
++  RP(RCALL1, NONE, NONE, RCALL2, 11H_PCREL, RCALL1, 2),
++  RP(BRC2, NONE, BRC1, NONE, 22H_PCREL, BRC2, 4),
++  RP(BRC1, NONE, NONE, BRC2, 9H_PCREL, BRC1, 2),
++  RP(BRAL, NONE, RJMP, NONE, 22H_PCREL, BRAL, 4),
++  RP(RJMP, NONE, NONE, BRAL, 11H_PCREL, RJMP, 2),
++};
++
++static bfd_boolean
++avr32_elf_new_section_hook(bfd *abfd, asection *sec)
++{
++  struct avr32_section_data *sdata;
++
++  sdata = bfd_zalloc(abfd, sizeof(struct avr32_section_data));
++  if (!sdata)
++    return FALSE;
++
++  sec->used_by_bfd = sdata;
++  return _bfd_elf_new_section_hook(abfd, sec);
++}
++
++static struct avr32_relax_data *
++avr32_relax_data(asection *sec)
++{
++  struct avr32_section_data *sdata;
++
++  BFD_ASSERT(sec->used_by_bfd);
++
++  sdata = (struct avr32_section_data *)elf_section_data(sec);
++  return &sdata->relax_data;
++}
++
++\f/* Link-time relaxation */
++
++static bfd_boolean
++avr32_elf_relax_section(bfd *abfd, asection *sec,
++                      struct bfd_link_info *info, bfd_boolean *again);
++
++enum relax_pass_id {
++  RELAX_PASS_SIZE_FRAGS,
++  RELAX_PASS_MOVE_DATA,
++};
++
++/* Stolen from the xtensa port */
++static int
++internal_reloc_compare (const void *ap, const void *bp)
++{
++  const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
++  const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
++
++  if (a->r_offset != b->r_offset)
++    return (a->r_offset - b->r_offset);
++
++  /* We don't need to sort on these criteria for correctness,
++     but enforcing a more strict ordering prevents unstable qsort
++     from behaving differently with different implementations.
++     Without the code below we get correct but different results
++     on Solaris 2.7 and 2.8.  We would like to always produce the
++     same results no matter the host.  */
++
++  if (a->r_info != b->r_info)
++    return (a->r_info - b->r_info);
++
++  return (a->r_addend - b->r_addend);
++}
++
++static enum relax_state_id
++get_pcrel22_relax_state(bfd *abfd, asection *sec, struct bfd_link_info *info,
++                      const Elf_Internal_Rela *rela)
++{
++  bfd_byte *contents;
++  bfd_vma insn;
++  enum relax_state_id rs = RS_NONE;
++
++  contents = retrieve_contents(abfd, sec, info->keep_memory);
++  if (!contents)
++    return RS_ERROR;
++
++  insn = bfd_get_32(abfd, contents + rela->r_offset);
++  if ((insn & RCALL2_MASK) == RCALL2_OPCODE)
++    rs = RS_RCALL2;
++  else if ((insn & BRAL_MASK) == BRAL_OPCODE)
++    /* Optimizing bral -> rjmp gets us into all kinds of
++       trouble with jump tables. Better not do it.  */
++    rs = RS_NONE;
++  else if ((insn & BRC2_MASK) == BRC2_OPCODE)
++    rs = RS_BRC2;
++
++  release_contents(sec, contents);
++
++  return rs;
++}
++
++static enum relax_state_id
++get_initial_relax_state(bfd *abfd, asection *sec, struct bfd_link_info *info,
++                      const Elf_Internal_Rela *rela)
++{
++  switch (ELF_R_TYPE(rela->r_info))
++    {
++    case R_AVR32_GOTCALL:
++      return RS_PIC_CALL;
++    case R_AVR32_GOT18SW:
++      return RS_PIC_MCALL;
++    case R_AVR32_LDA_GOT:
++      return RS_PIC_LDA;
++    case R_AVR32_GOT16S:
++      return RS_PIC_LDW4;
++    case R_AVR32_CPCALL:
++      return RS_NOPIC_MCALL;
++    case R_AVR32_16_CP:
++      return RS_NOPIC_LDW4;
++    case R_AVR32_9W_CP:
++      return RS_NOPIC_LDDPC;
++    case R_AVR32_ALIGN:
++      return RS_ALIGN;
++    case R_AVR32_32_CPENT:
++      return RS_CPENT;
++    case R_AVR32_22H_PCREL:
++      return get_pcrel22_relax_state(abfd, sec, info, rela);
++    case R_AVR32_9H_PCREL:
++      return RS_BRC1;
++    default:
++      return RS_NONE;
++    }
++}
++
++static bfd_boolean
++reloc_is_cpool_ref(const Elf_Internal_Rela *rela)
++{
++  switch (ELF_R_TYPE(rela->r_info))
++    {
++    case R_AVR32_CPCALL:
++    case R_AVR32_16_CP:
++    case R_AVR32_9W_CP:
++      return TRUE;
++    default:
++      return FALSE;
++    }
++}
++
++static struct fragment *
++new_frag(bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
++       struct avr32_relax_data *rd, enum relax_state_id state,
++       Elf_Internal_Rela *rela)
++{
++  struct fragment *frag;
++  bfd_size_type r_size;
++  bfd_vma r_offset;
++  unsigned int i = rd->frag_count;
++
++  BFD_ASSERT(state >= RS_NONE && state < RS_MAX);
++
++  rd->frag_count++;
++  frag = bfd_realloc(rd->frag, sizeof(struct fragment) * rd->frag_count);
++  if (!frag)
++    return NULL;
++  rd->frag = frag;
++
++  frag += i;
++  memset(frag, 0, sizeof(struct fragment));
++
++  if (state == RS_ALIGN)
++    r_size = (((rela->r_offset + (1 << rela->r_addend) - 1)
++             & ~((1 << rela->r_addend) - 1)) - rela->r_offset);
++  else
++    r_size = relax_state[state].size;
++
++  if (rela)
++    r_offset = rela->r_offset;
++  else
++    r_offset = sec->size;
++
++  if (i == 0)
++    {
++      frag->offset = 0;
++      frag->size = r_offset + r_size;
++    }
++  else
++    {
++      frag->offset = rd->frag[i - 1].offset + rd->frag[i - 1].size;
++      frag->size = r_offset + r_size - frag->offset;
++    }
++
++  if (state != RS_CPENT)
++    /* Make sure we don't discard this frag */
++    frag->refcount = 1;
++
++  frag->initial_state = frag->state = state;
++  frag->rela = rela;
++
++  return frag;
++}
++
++static struct fragment *
++find_frag(asection *sec, bfd_vma offset)
++{
++  struct fragment *first, *last;
++  struct avr32_relax_data *rd = avr32_relax_data(sec);
++
++  if (rd->frag_count == 0)
++    return NULL;
++
++  first = &rd->frag[0];
++  last = &rd->frag[rd->frag_count - 1];
++
++  /* This may be a reloc referencing the end of a section.  The last
++     frag will never have a reloc associated with it, so its size will
++     never change, thus the offset adjustment of the last frag will
++     always be the same as the offset adjustment of the end of the
++     section.  */
++  if (offset == sec->size)
++    {
++      BFD_ASSERT(last->offset + last->size == sec->size);
++      BFD_ASSERT(!last->rela);
++      return last;
++    }
++
++  while (first <= last)
++    {
++      struct fragment *mid;
++
++      mid = (last - first) / 2 + first;
++      if ((mid->offset + mid->size) <= offset)
++      first = mid + 1;
++      else if (mid->offset > offset)
++      last = mid - 1;
++      else
++      return mid;
++    }
++
++  return NULL;
++}
++
++/* Look through all relocs in a section and determine if any relocs
++   may be affected by relaxation in other sections.  If so, allocate
++   an array of additional relocation data which links the affected
++   relocations to the frag(s) where the relaxation may occur.
++
++   This function also links cpool references to cpool entries and
++   increments the refcount of the latter when this happens.  */
++
++static bfd_boolean
++allocate_reloc_data(bfd *abfd, asection *sec, Elf_Internal_Rela *relocs,
++                  struct bfd_link_info *info)
++{
++  Elf_Internal_Shdr *symtab_hdr;
++  Elf_Internal_Sym *isymbuf = NULL;
++  struct avr32_relax_data *rd;
++  unsigned int i;
++  bfd_boolean ret = FALSE;
++
++  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
++  rd = avr32_relax_data(sec);
++
++  RDBG("%s<%s>: allocate_reloc_data\n", abfd->filename, sec->name);
++
++  for (i = 0; i < sec->reloc_count; i++)
++    {
++      Elf_Internal_Rela *rel = &relocs[i];
++      asection *sym_sec;
++      unsigned long r_symndx;
++      bfd_vma sym_value;
++
++      if (!rel->r_addend && ELF_R_TYPE(rel->r_info) != R_AVR32_DIFF32
++        && !reloc_is_cpool_ref(rel))
++      continue;
++
++      r_symndx = ELF_R_SYM(rel->r_info);
++
++      if (r_symndx < symtab_hdr->sh_info)
++      {
++        Elf_Internal_Sym *isym;
++
++        if (!isymbuf)
++          isymbuf = retrieve_local_syms(abfd, info->keep_memory);
++        if (!isymbuf)
++          return FALSE;
++
++        isym = &isymbuf[r_symndx];
++        sym_sec = bfd_section_from_elf_index(abfd, isym->st_shndx);
++        sym_value = isym->st_value;
++      }
++      else
++      {
++        struct elf_link_hash_entry *h;
++
++        h = elf_sym_hashes(abfd)[r_symndx - symtab_hdr->sh_info];
++
++        while (h->root.type == bfd_link_hash_indirect
++               || h->root.type == bfd_link_hash_warning)
++          h = (struct elf_link_hash_entry *)h->root.u.i.link;
++
++        if (h->root.type != bfd_link_hash_defined
++            && h->root.type != bfd_link_hash_defweak)
++          continue;
++
++        sym_sec = h->root.u.def.section;
++        sym_value = h->root.u.def.value;
++      }
++
++      if (sym_sec && avr32_relax_data(sym_sec)->is_relaxable)
++      {
++        bfd_size_type size;
++        struct fragment *frag;
++
++        if (!rd->reloc_data)
++          {
++            size = sizeof(struct avr32_reloc_data) * sec->reloc_count;
++            rd->reloc_data = bfd_zalloc(abfd, size);
++            if (!rd->reloc_data)
++              goto out;
++          }
++
++        RDBG("[%3d] 0x%04lx: target: 0x%lx + 0x%lx",
++             i, rel->r_offset, sym_value, rel->r_addend);
++
++        frag = find_frag(sym_sec, sym_value + rel->r_addend);
++        BFD_ASSERT(frag);
++        rd->reloc_data[i].add_frag = frag;
++
++        RDBG(" -> %s<%s>:%04lx\n", sym_sec->owner->filename, sym_sec->name,
++             frag->rela ? frag->rela->r_offset : sym_sec->size);
++
++        if (reloc_is_cpool_ref(rel))
++          {
++            BFD_ASSERT(ELF_R_TYPE(frag->rela->r_info) == R_AVR32_32_CPENT);
++            frag->refcount++;
++          }
++
++        if (ELF_R_TYPE(rel->r_info) == R_AVR32_DIFF32)
++          {
++            bfd_byte *contents;
++            bfd_signed_vma diff;
++
++            contents = retrieve_contents(abfd, sec, info->keep_memory);
++            if (!contents)
++              goto out;
++
++            diff = bfd_get_signed_32(abfd, contents + rel->r_offset);
++            frag = find_frag(sym_sec, sym_value + rel->r_addend + diff);
++            BFD_ASSERT(frag);
++            rd->reloc_data[i].sub_frag = frag;
++
++            release_contents(sec, contents);
++          }
++      }
++    }
++
++  ret = TRUE;
++
++ out:
++  release_local_syms(abfd, isymbuf);
++  return ret;
++}
++
++static bfd_boolean
++global_sym_set_frag(struct elf_avr32_link_hash_entry *havr,
++                  struct bfd_link_info *info ATTRIBUTE_UNUSED)
++{
++  struct fragment *frag;
++  asection *sec;
++
++  if (havr->root.root.type != bfd_link_hash_defined
++      && havr->root.root.type != bfd_link_hash_defweak)
++    return TRUE;
++
++  sec = havr->root.root.u.def.section;
++  if (bfd_is_const_section(sec)
++      || !avr32_relax_data(sec)->is_relaxable)
++    return TRUE;
++
++  frag = find_frag(sec, havr->root.root.u.def.value);
++  if (!frag)
++    {
++      unsigned int i;
++      struct avr32_relax_data *rd = avr32_relax_data(sec);
++
++      RDBG("In %s: No frag for %s <%s+%lu> (limit %lu)\n",
++         sec->owner->filename, havr->root.root.root.string,
++         sec->name, havr->root.root.u.def.value, sec->size);
++      for (i = 0; i < rd->frag_count; i++)
++      RDBG("    %8lu - %8lu\n", rd->frag[i].offset,
++           rd->frag[i].offset + rd->frag[i].size);
++    }
++  BFD_ASSERT(frag);
++
++  havr->sym_frag = frag;
++  return TRUE;
++}
++
++static bfd_boolean
++analyze_relocations(struct bfd_link_info *info)
++{
++  bfd *abfd;
++  asection *sec;
++
++  /* Divide all relaxable sections into fragments */
++  for (abfd = info->input_bfds; abfd; abfd = abfd->link_next)
++    {
++      if (!(elf_elfheader(abfd)->e_flags & EF_AVR32_LINKRELAX))
++      {
++        if (!(*info->callbacks->warning)
++            (info, _("input is not relaxable"), NULL, abfd, NULL, 0))
++          return FALSE;
++        continue;
++      }
++
++      for (sec = abfd->sections; sec; sec = sec->next)
++      {
++        struct avr32_relax_data *rd;
++        struct fragment *frag;
++        Elf_Internal_Rela *relocs;
++        unsigned int i;
++        bfd_boolean ret = TRUE;
++
++        if (!(sec->flags & SEC_RELOC) || sec->reloc_count == 0)
++          continue;
++
++        rd = avr32_relax_data(sec);
++
++        relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);
++        if (!relocs)
++          return FALSE;
++
++        qsort(relocs, sec->reloc_count, sizeof(Elf_Internal_Rela),
++              internal_reloc_compare);
++
++        for (i = 0; i < sec->reloc_count; i++)
++          {
++            enum relax_state_id state;
++
++            ret = FALSE;
++            state = get_initial_relax_state(abfd, sec, info, &relocs[i]);
++            if (state == RS_ERROR)
++              break;
++
++            if (state)
++              {
++                frag = new_frag(abfd, sec, rd, state, &relocs[i]);
++                if (!frag)
++                  break;
++
++                pin_internal_relocs(sec, relocs);
++                rd->is_relaxable = TRUE;
++              }
++
++            ret = TRUE;
++          }
++
++        release_internal_relocs(sec, relocs);
++        if (!ret)
++          return ret;
++
++        if (rd->is_relaxable)
++          {
++            frag = new_frag(abfd, sec, rd, RS_NONE, NULL);
++            if (!frag)
++              return FALSE;
++          }
++      }
++    }
++
++  /* Link each global symbol to the fragment where it's defined.  */
++  elf_link_hash_traverse(elf_hash_table(info), global_sym_set_frag, info);
++
++  /* Do the same for local symbols. */
++  for (abfd = info->input_bfds; abfd; abfd = abfd->link_next)
++    {
++      Elf_Internal_Sym *isymbuf, *isym;
++      struct fragment **local_sym_frag;
++      unsigned int i, sym_count;
++
++      sym_count = elf_tdata(abfd)->symtab_hdr.sh_info;
++      if (sym_count == 0)
++      continue;
++
++      local_sym_frag = bfd_zalloc(abfd, sym_count * sizeof(struct fragment *));
++      if (!local_sym_frag)
++      return FALSE;
++      elf_tdata(abfd)->local_sym_frag = local_sym_frag;
++
++      isymbuf = retrieve_local_syms(abfd, info->keep_memory);
++      if (!isymbuf)
++      return FALSE;
++
++      for (i = 0; i < sym_count; i++)
++      {
++        struct avr32_relax_data *rd;
++        struct fragment *frag;
++        asection *sec;
++
++        isym = &isymbuf[i];
++
++        sec = bfd_section_from_elf_index(abfd, isym->st_shndx);
++        if (!sec)
++          continue;
++
++        rd = avr32_relax_data(sec);
++        if (!rd->is_relaxable)
++          continue;
++
++        frag = find_frag(sec, isym->st_value);
++        BFD_ASSERT(frag);
++
++        local_sym_frag[i] = frag;
++      }
++
++      release_local_syms(abfd, isymbuf);
++    }
++
++  /* And again for relocs with addends and constant pool references */
++  for (abfd = info->input_bfds; abfd; abfd = abfd->link_next)
++    for (sec = abfd->sections; sec; sec = sec->next)
++      {
++      Elf_Internal_Rela *relocs;
++      bfd_boolean ret;
++
++      if (!(sec->flags & SEC_RELOC) || sec->reloc_count == 0)
++        continue;
++
++      relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);
++      if (!relocs)
++        return FALSE;
++
++      ret = allocate_reloc_data(abfd, sec, relocs, info);
++
++      release_internal_relocs(sec, relocs);
++      if (ret == FALSE)
++        return ret;
++      }
++
++  return TRUE;
++}
++
++static bfd_boolean
++rs_is_good_enough(const struct relax_state *rs, struct fragment *frag,
++                bfd_vma symval, bfd_vma addr, struct got_entry *got,
++                struct avr32_reloc_data *ind_data,
++                bfd_signed_vma offset_adjust)
++{
++  bfd_signed_vma target = 0;
++
++  switch (rs->reftype)
++    {
++    case REF_ABSOLUTE:
++      target = symval;
++      break;
++    case REF_PCREL:
++      target = symval - addr;
++      break;
++    case REF_CPOOL:
++      /* cpool frags are always in the same section and always after
++       all frags referring to it.  So it's always correct to add in
++       offset_adjust here.  */
++      target = (ind_data->add_frag->offset + ind_data->add_frag->offset_adjust
++              + offset_adjust - frag->offset - frag->offset_adjust);
++      break;
++    case REF_GOT:
++      target = got->offset;
++      break;
++    default:
++      abort();
++    }
++
++  if (target >= rs->range_min && target <= rs->range_max)
++    return TRUE;
++  else
++    return FALSE;
++}
++
++static bfd_boolean
++avr32_size_frags(bfd *abfd, asection *sec, struct bfd_link_info *info)
++{
++  struct elf_avr32_link_hash_table *htab;
++  struct avr32_relax_data *rd;
++  Elf_Internal_Shdr *symtab_hdr;
++  Elf_Internal_Rela *relocs = NULL;
++  Elf_Internal_Sym *isymbuf = NULL;
++  struct got_entry **local_got_ents;
++  struct fragment **local_sym_frag;
++  bfd_boolean ret = FALSE;
++  bfd_signed_vma delta = 0;
++  unsigned int i;
++
++  htab = avr32_elf_hash_table(info);
++  rd = avr32_relax_data(sec);
++
++  if (sec == htab->sgot)
++    {
++      RDBG("Relaxing GOT section (vma: 0x%lx)\n",
++         sec->output_section->vma + sec->output_offset);
++      if (assign_got_offsets(htab))
++      htab->repeat_pass = TRUE;
++      return TRUE;
++    }
++
++  if (!rd->is_relaxable)
++    return TRUE;
++
++  if (!sec->rawsize)
++    sec->rawsize = sec->size;
++
++  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
++  relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);
++  if (!relocs)
++    goto out;
++
++  isymbuf = retrieve_local_syms(abfd, info->keep_memory);
++  if (!isymbuf)
++    goto out;
++
++  local_got_ents = elf_local_got_ents(abfd);
++  local_sym_frag = elf_tdata(abfd)->local_sym_frag;
++
++  RDBG("size_frags: %s<%s>\n  vma: 0x%08lx, size: 0x%08lx\n",
++       abfd->filename, sec->name,
++       sec->output_section->vma + sec->output_offset, sec->size);
++
++  for (i = 0; i < rd->frag_count; i++)
++    {
++      struct fragment *frag = &rd->frag[i];
++      struct avr32_reloc_data *r_data = NULL, *ind_data = NULL;
++      const struct relax_state *state, *next_state;
++      struct fragment *target_frag = NULL;
++      asection *sym_sec = NULL;
++      Elf_Internal_Rela *rela;
++      struct got_entry *got;
++      bfd_vma symval, r_offset, addend, addr;
++      bfd_signed_vma size_adjust = 0, distance;
++      unsigned long r_symndx;
++      bfd_boolean defined = TRUE, dynamic = FALSE;
++      unsigned char sym_type;
++
++      frag->offset_adjust += delta;
++      state = next_state = &relax_state[frag->state];
++      rela = frag->rela;
++
++      BFD_ASSERT(state->id == frag->state);
++
++      RDBG("  0x%04lx%c%d: %s [size %ld]", rela ? rela->r_offset : sec->rawsize,
++         (frag->offset_adjust < 0)?'-':'+',
++         abs(frag->offset_adjust), state->name, state->size);
++
++      if (!rela)
++      {
++        RDBG(": no reloc, ignoring\n");
++        continue;
++      }
++
++      BFD_ASSERT((unsigned int)(rela - relocs) < sec->reloc_count);
++      BFD_ASSERT(state != RS_NONE);
++
++      r_offset = rela->r_offset + frag->offset_adjust;
++      addr = sec->output_section->vma + sec->output_offset + r_offset;
++
++      switch (frag->state)
++      {
++      case RS_ALIGN:
++        size_adjust = ((addr + (1 << rela->r_addend) - 1)
++                       & ~((1 << rela->r_addend) - 1));
++        size_adjust -= (sec->output_section->vma + sec->output_offset
++                        + frag->offset + frag->offset_adjust
++                        + frag->size + frag->size_adjust);
++
++        RDBG(": adjusting size %lu -> %lu\n", frag->size + frag->size_adjust,
++             frag->size + frag->size_adjust + size_adjust);
++        break;
++
++      case RS_CPENT:
++        if (frag->refcount == 0 && frag->size_adjust == 0)
++          {
++            RDBG(": discarding frag\n");
++            size_adjust = -4;
++          }
++        else if (frag->refcount > 0 && frag->size_adjust < 0)
++          {
++            RDBG(": un-discarding frag\n");
++            size_adjust = 4;
++          }
++        break;
++
++      default:
++        if (rd->reloc_data)
++          r_data = &rd->reloc_data[frag->rela - relocs];
++
++        /* If this is a cpool reference, we want the symbol that the
++           cpool entry refers to, not the symbol for the cpool entry
++           itself, as we already know what frag it's in.  */
++        if (relax_state[frag->initial_state].reftype == REF_CPOOL)
++          {
++            Elf_Internal_Rela *irela = r_data->add_frag->rela;
++
++            r_symndx = ELF_R_SYM(irela->r_info);
++            addend = irela->r_addend;
++
++            /* The constant pool must be in the same section as the
++               reloc referring to it.  */
++            BFD_ASSERT((unsigned long)(irela - relocs) < sec->reloc_count);
++
++            ind_data = r_data;
++            r_data = &rd->reloc_data[irela - relocs];
++          }
++        else
++          {
++            r_symndx = ELF_R_SYM(rela->r_info);
++            addend = rela->r_addend;
++          }
++
++        /* Get the value of the symbol referred to by the reloc.  */
++        if (r_symndx < symtab_hdr->sh_info)
++          {
++            Elf_Internal_Sym *isym;
++
++            isym = isymbuf + r_symndx;
++            symval = 0;
++
++            RDBG(" local sym %lu: ", r_symndx);
++
++            if (isym->st_shndx == SHN_UNDEF)
++              defined = FALSE;
++            else if (isym->st_shndx == SHN_ABS)
++              sym_sec = bfd_abs_section_ptr;
++            else if (isym->st_shndx == SHN_COMMON)
++              sym_sec = bfd_com_section_ptr;
++            else
++              sym_sec = bfd_section_from_elf_index(abfd, isym->st_shndx);
++
++            symval = isym->st_value;
++            sym_type = ELF_ST_TYPE(isym->st_info);
++            target_frag = local_sym_frag[r_symndx];
++
++            if (local_got_ents)
++              got = local_got_ents[r_symndx];
++            else
++              got = NULL;
++          }
++        else
++          {
++            /* Global symbol */
++            unsigned long index;
++            struct elf_link_hash_entry *h;
++            struct elf_avr32_link_hash_entry *havr;
++
++            index = r_symndx - symtab_hdr->sh_info;
++            h = elf_sym_hashes(abfd)[index];
++            BFD_ASSERT(h != NULL);
++
++            while (h->root.type == bfd_link_hash_indirect
++                   || h->root.type == bfd_link_hash_warning)
++              h = (struct elf_link_hash_entry *)h->root.u.i.link;
++
++            havr = (struct elf_avr32_link_hash_entry *)h;
++            got = h->got.glist;
++
++            symval = 0;
++
++            RDBG(" %s: ", h->root.root.string);
++
++            if (h->root.type != bfd_link_hash_defined
++                && h->root.type != bfd_link_hash_defweak)
++              {
++                RDBG("(undef)");
++                defined = FALSE;
++              }
++            else if ((info->shared && !info->symbolic && h->dynindx != -1)
++                     || (htab->root.dynamic_sections_created
++                         && h->def_dynamic && !h->def_regular))
++              {
++                RDBG("(dynamic)");
++                dynamic = TRUE;
++                sym_sec = h->root.u.def.section;
++              }
++            else
++              {
++                sym_sec = h->root.u.def.section;
++                symval = h->root.u.def.value;
++                target_frag = havr->sym_frag;
++              }
++
++            sym_type = h->type;
++          }
++
++        /* Thanks to elf32-ppc for this one.  */
++        if (sym_sec && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
++          {
++            /* At this stage in linking, no SEC_MERGE symbol has been
++               adjusted, so all references to such symbols need to be
++               passed through _bfd_merged_section_offset.  (Later, in
++               relocate_section, all SEC_MERGE symbols *except* for
++               section symbols have been adjusted.)
++
++               SEC_MERGE sections are not relaxed by us, as they
++               shouldn't contain any code.  */
++
++            BFD_ASSERT(!target_frag && !(r_data && r_data->add_frag));
++
++            /* gas may reduce relocations against symbols in SEC_MERGE
++               sections to a relocation against the section symbol when
++               the original addend was zero.  When the reloc is against
++               a section symbol we should include the addend in the
++               offset passed to _bfd_merged_section_offset, since the
++               location of interest is the original symbol.  On the
++               other hand, an access to "sym+addend" where "sym" is not
++               a section symbol should not include the addend;  Such an
++               access is presumed to be an offset from "sym";  The
++               location of interest is just "sym".  */
++            RDBG("\n    MERGE: %s: 0x%lx+0x%lx+0x%lx -> ",
++                 (sym_type == STT_SECTION)?"section":"not section",
++                 sym_sec->output_section->vma + sym_sec->output_offset,
++                 symval, addend);
++
++            if (sym_type == STT_SECTION)
++              symval += addend;
++
++            symval = (_bfd_merged_section_offset
++                      (abfd, &sym_sec,
++                       elf_section_data(sym_sec)->sec_info, symval));
++
++            if (sym_type != STT_SECTION)
++              symval += addend;
++          }
++        else
++          symval += addend;
++
++        if (defined && !dynamic)
++          {
++            RDBG("0x%lx+0x%lx",
++                 sym_sec->output_section->vma + sym_sec->output_offset,
++                 symval);
++            symval += sym_sec->output_section->vma + sym_sec->output_offset;
++          }
++
++        if (r_data && r_data->add_frag)
++          /* If the add_frag pointer is set, it means that this reloc
++             has an addend that may be affected by relaxation.  */
++          target_frag = r_data->add_frag;
++
++        if (target_frag)
++          {
++            symval += target_frag->offset_adjust;
++
++            /* If target_frag comes after this frag in the same
++               section, we should assume that it will be moved by
++               the same amount we are.  */
++            if ((target_frag - rd->frag) < (int)rd->frag_count
++                && target_frag > frag)
++              symval += delta;
++          }
++
++        distance = symval - addr;
++
++        /* First, try to make a direct reference.  If the symbol is
++           dynamic or undefined, we must take care not to change its
++           reference type, that is, we can't make it direct.
++
++           Also, it seems like some sections may actually be resized
++           after the relaxation code is done, so we can't really
++           trust that our "distance" is correct.  There's really no
++           easy solution to this problem, so we'll just disallow
++           direct references to SEC_DATA sections.  */
++        if (!dynamic && defined
++            && !(sym_sec->flags & SEC_DATA)
++            && next_state->direct)
++          {
++            next_state = &relax_state[next_state->direct];
++            RDBG(" D-> %s", next_state->name);
++          }
++
++        /* Iterate backwards until we find a state that fits.  */
++        while (next_state->prev
++               && !rs_is_good_enough(next_state, frag, symval, addr,
++                                     got, ind_data, delta))
++          {
++            next_state = &relax_state[next_state->prev];
++            RDBG(" P-> %s", next_state->name);
++          }
++
++        /* Then try to find the best possible state.  */
++        while (next_state->next)
++          {
++            const struct relax_state *candidate;
++
++            candidate = &relax_state[next_state->next];
++            if (!rs_is_good_enough(candidate, frag, symval, addr, got,
++                                   ind_data, delta))
++              break;
++
++            next_state = candidate;
++            RDBG(" N-> %s", next_state->name);
++          }
++
++        RDBG(" [size %ld]\n", next_state->size);
++
++        BFD_ASSERT(next_state->id);
++        BFD_ASSERT(!dynamic || next_state->reftype == REF_GOT);
++
++        size_adjust = next_state->size - state->size;
++
++        /* There's a theoretical possibility that shrinking one frag
++           may cause another to grow, which may cause the first one to
++           grow as well, and we're back where we started.  Avoid this
++           scenario by disallowing a frag that has grown to ever
++           shrink again.  */
++        if (state->reftype == REF_GOT && next_state->reftype != REF_GOT)
++          {
++            if (frag->has_grown)
++              next_state = state;
++            else
++              unref_got_entry(htab, got);
++          }
++        else if (state->reftype != REF_GOT && next_state->reftype == REF_GOT)
++          {
++            ref_got_entry(htab, got);
++            frag->has_grown = TRUE;
++          }
++        else if (state->reftype == REF_CPOOL
++                 && next_state->reftype != REF_CPOOL)
++          {
++            if (frag->has_grown)
++              next_state = state;
++            else
++              ind_data->add_frag->refcount--;
++          }
++        else if (state->reftype != REF_CPOOL
++                 && next_state->reftype == REF_CPOOL)
++          {
++            ind_data->add_frag->refcount++;
++            frag->has_grown = TRUE;
++          }
++        else
++          {
++            if (frag->has_grown && size_adjust < 0)
++              next_state = state;
++            else if (size_adjust > 0)
++              frag->has_grown = TRUE;
++          }
++
++        size_adjust = next_state->size - state->size;
++        frag->state = next_state->id;
++
++        break;
++      }
++
++      if (size_adjust)
++      htab->repeat_pass = TRUE;
++
++      frag->size_adjust += size_adjust;
++      sec->size += size_adjust;
++      delta += size_adjust;
++
++      BFD_ASSERT((frag->offset + frag->offset_adjust
++                + frag->size + frag->size_adjust)
++               == (frag[1].offset + frag[1].offset_adjust + delta));
++    }
++
++  ret = TRUE;
++
++ out:
++  release_local_syms(abfd, isymbuf);
++  release_internal_relocs(sec, relocs);
++  return ret;
++}
++
++static bfd_boolean
++adjust_global_symbol(struct elf_avr32_link_hash_entry *havr,
++                   struct bfd_link_info *info ATTRIBUTE_UNUSED)
++{
++  struct elf_link_hash_entry *h = &havr->root;
++
++  if (havr->sym_frag && (h->root.type == bfd_link_hash_defined
++                       || h->root.type == bfd_link_hash_defweak))
++    {
++      RDBG("adjust_global_symbol: %s 0x%08lx -> 0x%08lx\n",
++         h->root.root.string, h->root.u.def.value,
++         h->root.u.def.value + havr->sym_frag->offset_adjust);
++      h->root.u.def.value += havr->sym_frag->offset_adjust;
++    }
++  return TRUE;
++}
++
++static bfd_boolean
++adjust_syms(struct bfd_link_info *info)
++{
++  struct elf_avr32_link_hash_table *htab;
++  bfd *abfd;
++
++  htab = avr32_elf_hash_table(info);
++  elf_link_hash_traverse(&htab->root, adjust_global_symbol, info);
++
++  for (abfd = info->input_bfds; abfd; abfd = abfd->link_next)
++    {
++      Elf_Internal_Sym *isymbuf;
++      struct fragment **local_sym_frag, *frag;
++      unsigned int i, sym_count;
++
++      sym_count = elf_tdata(abfd)->symtab_hdr.sh_info;
++      if (sym_count == 0)
++      continue;
++
++      isymbuf = retrieve_local_syms(abfd, info->keep_memory);
++      if (!isymbuf)
++      return FALSE;
++
++      local_sym_frag = elf_tdata(abfd)->local_sym_frag;
++
++      for (i = 0; i < sym_count; i++)
++      {
++        frag = local_sym_frag[i];
++        if (frag)
++          {
++            RDBG("adjust_local_symbol: %s[%u] 0x%08lx -> 0x%08lx\n",
++                 abfd->filename, i, isymbuf[i].st_value,
++                 isymbuf[i].st_value + frag->offset_adjust);
++            isymbuf[i].st_value += frag->offset_adjust;
++          }
++      }
++
++      release_local_syms(abfd, isymbuf);
++    }
++
++  htab->symbols_adjusted = TRUE;
++  return TRUE;
++}
++
++static bfd_boolean
++adjust_relocs(bfd *abfd, asection *sec, struct bfd_link_info *info)
++{
++  struct avr32_relax_data *rd;
++  Elf_Internal_Rela *relocs;
++  Elf_Internal_Shdr *symtab_hdr;
++  unsigned int i;
++  bfd_boolean ret = FALSE;
++
++  rd = avr32_relax_data(sec);
++  if (!rd->reloc_data)
++    return TRUE;
++
++  RDBG("adjust_relocs: %s<%s> (count: %u)\n", abfd->filename, sec->name,
++       sec->reloc_count);
++
++  relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);
++  if (!relocs)
++    return FALSE;
++
++  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
++
++  for (i = 0; i < sec->reloc_count; i++)
++    {
++      Elf_Internal_Rela *rela = &relocs[i];
++      struct avr32_reloc_data *r_data = &rd->reloc_data[i];
++      struct fragment *sym_frag;
++      unsigned long r_symndx;
++
++      if (r_data->add_frag)
++      {
++        r_symndx = ELF_R_SYM(rela->r_info);
++
++        if (r_symndx < symtab_hdr->sh_info)
++          sym_frag = elf_tdata(abfd)->local_sym_frag[r_symndx];
++        else
++          {
++            struct elf_link_hash_entry *h;
++
++            h = elf_sym_hashes(abfd)[r_symndx - symtab_hdr->sh_info];
++
++            while (h->root.type == bfd_link_hash_indirect
++                   || h->root.type == bfd_link_hash_warning)
++              h = (struct elf_link_hash_entry *)h->root.u.i.link;
++
++            BFD_ASSERT(h->root.type == bfd_link_hash_defined
++                       || h->root.type == bfd_link_hash_defweak);
++
++            sym_frag = ((struct elf_avr32_link_hash_entry *)h)->sym_frag;
++          }
++
++        RDBG("    addend: 0x%08lx -> 0x%08lx\n",
++             rela->r_addend,
++             rela->r_addend + r_data->add_frag->offset_adjust
++             - (sym_frag ? sym_frag->offset_adjust : 0));
++
++        /* If this is against a section symbol, we won't find any
++           sym_frag, so we'll just adjust the addend.  */
++        rela->r_addend += r_data->add_frag->offset_adjust;
++        if (sym_frag)
++          rela->r_addend -= sym_frag->offset_adjust;
++
++        if (r_data->sub_frag)
++          {
++            bfd_byte *contents;
++            bfd_signed_vma diff;
++
++            contents = retrieve_contents(abfd, sec, info->keep_memory);
++            if (!contents)
++              goto out;
++
++            /* I realize now that sub_frag is misnamed.  It's
++               actually add_frag which is subtracted in this
++               case...  */
++            diff = bfd_get_signed_32(abfd, contents + rela->r_offset);
++            diff += (r_data->sub_frag->offset_adjust
++                     - r_data->add_frag->offset_adjust);
++            bfd_put_32(abfd, diff, contents + rela->r_offset);
++
++            RDBG("   0x%lx: DIFF32 updated: 0x%lx\n", rela->r_offset, diff);
++
++            release_contents(sec, contents);
++          }
++      }
++      else
++      BFD_ASSERT(!r_data->sub_frag);
++    }
++
++  ret = TRUE;
++
++ out:
++  release_internal_relocs(sec, relocs);
++  return ret;
++}
++
++static bfd_boolean
++avr32_move_data(bfd *abfd, asection *sec, struct bfd_link_info *info)
++{
++  struct elf_avr32_link_hash_table *htab;
++  struct avr32_relax_data *rd;
++  struct fragment *frag, *fragend;
++  Elf_Internal_Rela *relocs = NULL;
++  bfd_byte *contents = NULL;
++  unsigned int i;
++  bfd_boolean ret = FALSE;
++
++  htab = avr32_elf_hash_table(info);
++  rd = avr32_relax_data(sec);
++
++  if (!htab->symbols_adjusted)
++    if (!adjust_syms(info))
++      return FALSE;
++
++  if (rd->is_relaxable)
++    {
++      /* Resize the section first, so that we can be sure that enough
++       memory is allocated in case the section has grown.  */
++      if (sec->size > sec->rawsize
++        && elf_section_data(sec)->this_hdr.contents)
++      {
++        /* We must not use cached data if the section has grown.  */
++        free(elf_section_data(sec)->this_hdr.contents);
++        elf_section_data(sec)->this_hdr.contents = NULL;
++      }
++
++      relocs = retrieve_internal_relocs(abfd, sec, info->keep_memory);
++      if (!relocs)
++      goto out;
++      contents = retrieve_contents(abfd, sec, info->keep_memory);
++      if (!contents)
++      goto out;
++
++      fragend = rd->frag + rd->frag_count;
++
++      RDBG("move_data: %s<%s>: relocs=%p, contents=%p\n",
++         abfd->filename, sec->name, relocs, contents);
++
++      /* First, move the data into place. We must take care to move
++       frags in the right order so that we don't accidentally
++       overwrite parts of the next frag.  */
++      for (frag = rd->frag; frag < fragend; frag++)
++      {
++        RDBG("    0x%08lx%c0x%x: size 0x%lx%c0x%x\n",
++             frag->offset, frag->offset_adjust >= 0 ? '+' : '-',
++             abs(frag->offset_adjust),
++             frag->size, frag->size_adjust >= 0 ? '+' : '-',
++             abs(frag->size_adjust));
++        if (frag->offset_adjust > 0)
++          {
++            struct fragment *prev = frag - 1;
++            struct fragment *last;
++
++            for (last = frag; last < fragend && last->offset_adjust > 0;
++                 last++) ;
++
++            if (last == fragend)
++              last--;
++
++            for (frag = last; frag != prev; frag--)
++              {
++                if (frag->offset_adjust
++                    && frag->size + frag->size_adjust > 0)
++                  {
++                    RDBG("memmove 0x%lx -> 0x%lx (size %lu)\n",
++                         frag->offset, frag->offset + frag->offset_adjust,
++                         frag->size + frag->size_adjust);
++                    memmove(contents + frag->offset + frag->offset_adjust,
++                            contents + frag->offset,
++                            frag->size + frag->size_adjust);
++                  }
++              }
++            frag = last;
++          }
++        else if (frag->offset_adjust && frag->size + frag->size_adjust > 0)
++          {
++            RDBG("memmove 0x%lx -> 0x%lx (size %lu)\n",
++                 frag->offset, frag->offset + frag->offset_adjust,
++                 frag->size + frag->size_adjust);
++            memmove(contents + frag->offset + frag->offset_adjust,
++                    contents + frag->offset,
++                    frag->size + frag->size_adjust);
++          }
++      }
++
++      i = 0;
++
++      for (frag = rd->frag; frag < fragend; frag++)
++      {
++        const struct relax_state *state, *istate;
++        struct avr32_reloc_data *r_data = NULL;
++
++        istate = &relax_state[frag->initial_state];
++        state = &relax_state[frag->state];
++
++        if (rd->reloc_data)
++          r_data = &rd->reloc_data[frag->rela - relocs];
++
++        BFD_ASSERT((long)(frag->size + frag->size_adjust) >= 0);
++        BFD_ASSERT(state->reftype != REF_CPOOL
++                   || r_data->add_frag->refcount > 0);
++
++        if (istate->reftype == REF_CPOOL && state->reftype != REF_CPOOL)
++          {
++            struct fragment *ifrag;
++
++            /* An indirect reference through the cpool has been
++               converted to a direct reference.  We must update the
++               reloc to point to the symbol itself instead of the
++               constant pool entry.  The reloc type will be updated
++               later.  */
++            ifrag = r_data->add_frag;
++            frag->rela->r_info = ifrag->rela->r_info;
++            frag->rela->r_addend = ifrag->rela->r_addend;
++
++            /* Copy the reloc data so the addend will be adjusted
++               correctly later.  */
++            *r_data = rd->reloc_data[ifrag->rela - relocs];
++          }
++
++        /* Move all relocs covered by this frag.  */
++        if (frag->rela)
++          BFD_ASSERT(&relocs[i] <= frag->rela);
++        else
++          BFD_ASSERT((frag + 1) == fragend && frag->state == RS_NONE);
++
++        if (frag == rd->frag)
++          BFD_ASSERT(i == 0);
++        else
++          BFD_ASSERT(&relocs[i] > frag[-1].rela);
++
++        /* If non-null, frag->rela is the last relocation in the
++           fragment.  frag->rela can only be null in the last
++           fragment, so in that case, we'll just do the rest.  */
++        for (; (i < sec->reloc_count
++                && (!frag->rela || &relocs[i] <= frag->rela)); i++)
++          {
++            RDBG("[%4u] r_offset 0x%08lx -> 0x%08lx\n", i, relocs[i].r_offset,
++                 relocs[i].r_offset + frag->offset_adjust);
++            relocs[i].r_offset += frag->offset_adjust;
++          }
++
++        if (frag->refcount == 0)
++          {
++            /* If this frag is to be discarded, make sure we won't
++               relocate it later on.  */
++            BFD_ASSERT(frag->state == RS_CPENT);
++            frag->rela->r_info = ELF_R_INFO(ELF_R_SYM(frag->rela->r_info),
++                                          R_AVR32_NONE);
++          }
++        else if (frag->state == RS_ALIGN)
++          {
++            bfd_vma addr, addr_end;
++
++            addr = frag->rela->r_offset;
++            addr_end = (frag->offset + frag->offset_adjust
++                        + frag->size + frag->size_adjust);
++
++            /* If the section is executable, insert NOPs.
++               Otherwise, insert zeroes.  */
++            if (sec->flags & SEC_CODE)
++              {
++                if (addr & 1)
++                  {
++                    bfd_put_8(abfd, 0, contents + addr);
++                    addr++;
++                  }
++
++                BFD_ASSERT(!((addr_end - addr) & 1));
++
++                while (addr < addr_end)
++                  {
++                    bfd_put_16(abfd, NOP_OPCODE, contents + addr);
++                    addr += 2;
++                  }
++              }
++            else
++              memset(contents + addr, 0, addr_end - addr);
++          }
++        else if (state->opcode_mask)
++          {
++            bfd_vma insn;
++
++            /* Update the opcode and the relocation type unless it's a
++               "special" relax state (i.e. RS_NONE, RS_ALIGN or
++               RS_CPENT.), in which case the opcode mask is zero.  */
++            insn = bfd_get_32(abfd, contents + frag->rela->r_offset);
++            insn &= ~state->opcode_mask;
++            insn |= state->opcode;
++            RDBG("    0x%lx: inserting insn %08lx\n",
++                 frag->rela->r_offset, insn);
++            bfd_put_32(abfd, insn, contents + frag->rela->r_offset);
++
++            frag->rela->r_info = ELF_R_INFO(ELF_R_SYM(frag->rela->r_info),
++                                            state->r_type);
++          }
++
++        if ((frag + 1) == fragend)
++          BFD_ASSERT((frag->offset + frag->size + frag->offset_adjust
++                      + frag->size_adjust) == sec->size);
++        else
++          BFD_ASSERT((frag->offset + frag->size + frag->offset_adjust
++                      + frag->size_adjust)
++                     == (frag[1].offset + frag[1].offset_adjust));
++      }
++    }
++
++  /* Adjust reloc addends and DIFF32 differences */
++  if (!adjust_relocs(abfd, sec, info))
++    return FALSE;
++
++  ret = TRUE;
++
++ out:
++  release_contents(sec, contents);
++  release_internal_relocs(sec, relocs);
++  return ret;
++}
++
++static bfd_boolean
++avr32_elf_relax_section(bfd *abfd, asection *sec,
++                      struct bfd_link_info *info, bfd_boolean *again)
++{
++  struct elf_avr32_link_hash_table *htab;
++  struct avr32_relax_data *rd;
++
++  *again = FALSE;
++  if (info->relocatable)
++    return TRUE;
++
++  htab = avr32_elf_hash_table(info);
++  if ((!(sec->flags & SEC_RELOC) || sec->reloc_count == 0)
++      && sec != htab->sgot)
++    return TRUE;
++
++  if (!htab->relocations_analyzed)
++    {
++      if (!analyze_relocations(info))
++      return FALSE;
++      htab->relocations_analyzed = TRUE;
++    }
++
++  rd = avr32_relax_data(sec);
++
++  if (rd->iteration != htab->relax_iteration)
++    {
++      if (!htab->repeat_pass)
++      htab->relax_pass++;
++      htab->relax_iteration++;
++      htab->repeat_pass = FALSE;
++    }
++
++  rd->iteration++;
++
++  switch (htab->relax_pass)
++    {
++    case RELAX_PASS_SIZE_FRAGS:
++      if (!avr32_size_frags(abfd, sec, info))
++      return FALSE;
++      *again = TRUE;
++      break;
++    case RELAX_PASS_MOVE_DATA:
++      if (!avr32_move_data(abfd, sec, info))
++      return FALSE;
++      break;
++  }
++
++  return TRUE;
++}
++
++\f
++/* Relocation */
++
++static bfd_reloc_status_type
++avr32_check_reloc_value(asection *sec, Elf_Internal_Rela *rela,
++                      bfd_signed_vma relocation, reloc_howto_type *howto);
++static bfd_reloc_status_type
++avr32_final_link_relocate(reloc_howto_type *howto, bfd *input_bfd,
++                        asection *input_section, bfd_byte *contents,
++                        Elf_Internal_Rela *rel, bfd_vma value);
++static bfd_boolean
++avr32_elf_relocate_section(bfd *output_bfd, struct bfd_link_info *info,
++                         bfd *input_bfd, asection *input_section,
++                         bfd_byte *contents, Elf_Internal_Rela *relocs,
++                         Elf_Internal_Sym *local_syms,
++                         asection **local_sections);
++
++
++#define symbol_address(symbol) \
++  symbol->value + symbol->section->output_section->vma \
++  + symbol->section->output_offset
++
++#define avr32_elf_insert_field(size, field, abfd, reloc_entry, data)  \
++  do                                                                  \
++    {                                                                 \
++      unsigned long x;                                                        \
++      x = bfd_get_##size (abfd, data + reloc_entry->address);         \
++      x &= ~reloc_entry->howto->dst_mask;                             \
++      x |= field & reloc_entry->howto->dst_mask;                      \
++      bfd_put_##size (abfd, (bfd_vma) x, data + reloc_entry->address);        \
++    }                                                                 \
++  while(0)
++
++static bfd_reloc_status_type
++avr32_check_reloc_value(asection *sec ATTRIBUTE_UNUSED,
++                      Elf_Internal_Rela *rela ATTRIBUTE_UNUSED,
++                      bfd_signed_vma relocation,
++                      reloc_howto_type *howto)
++{
++  bfd_vma reloc_u;
++
++  /* We take "complain_overflow_dont" to mean "don't complain on
++     alignment either". This way, we don't have to special-case
++     R_AVR32_HI16 */
++  if (howto->complain_on_overflow == complain_overflow_dont)
++    return bfd_reloc_ok;
++
++  /* Check if the value is correctly aligned */
++  if (relocation & ((1 << howto->rightshift) - 1))
++    {
++      RDBG("misaligned: %s<%s+%lx>: %s: 0x%lx (align %u)\n",
++         sec->owner->filename, sec->name, rela->r_offset,
++         howto->name, relocation, howto->rightshift);
++      return bfd_reloc_overflow;
++    }
++
++  /* Now, get rid of the unnecessary bits */
++  relocation >>= howto->rightshift;
++  reloc_u = (bfd_vma)relocation;
++
++  switch (howto->complain_on_overflow)
++    {
++    case complain_overflow_unsigned:
++    case complain_overflow_bitfield:
++      if (reloc_u > (unsigned long)((1 << howto->bitsize) - 1))
++      {
++        RDBG("unsigned overflow: %s<%s+%lx>: %s: 0x%lx (size %u)\n",
++             sec->owner->filename, sec->name, rela->r_offset,
++             howto->name, reloc_u, howto->bitsize);
++        RDBG("reloc vma: 0x%lx\n",
++             sec->output_section->vma + sec->output_offset + rela->r_offset);
++
++        return bfd_reloc_overflow;
++      }
++      break;
++    case complain_overflow_signed:
++      if (relocation > (1 << (howto->bitsize - 1)) - 1)
++      {
++        RDBG("signed overflow: %s<%s+%lx>: %s: 0x%lx (size %u)\n",
++             sec->owner->filename, sec->name, rela->r_offset,
++             howto->name, reloc_u, howto->bitsize);
++        RDBG("reloc vma: 0x%lx\n",
++             sec->output_section->vma + sec->output_offset + rela->r_offset);
++
++        return bfd_reloc_overflow;
++      }
++      if (relocation < -(1 << (howto->bitsize - 1)))
++      {
++        RDBG("signed overflow: %s<%s+%lx>: %s: -0x%lx (size %u)\n",
++             sec->owner->filename, sec->name, rela->r_offset,
++             howto->name, -relocation, howto->bitsize);
++        RDBG("reloc vma: 0x%lx\n",
++             sec->output_section->vma + sec->output_offset + rela->r_offset);
++
++        return bfd_reloc_overflow;
++      }
++      break;
++    default:
++      abort();
++    }
++
++  return bfd_reloc_ok;
++}
++
++
++static bfd_reloc_status_type
++avr32_final_link_relocate(reloc_howto_type *howto,
++                        bfd *input_bfd,
++                        asection *input_section,
++                        bfd_byte *contents,
++                        Elf_Internal_Rela *rel,
++                        bfd_vma value)
++{
++  bfd_vma field;
++  bfd_vma relocation;
++  bfd_reloc_status_type status;
++  bfd_byte *p = contents + rel->r_offset;
++  unsigned long x;
++
++  pr_debug("  (6b) final link relocate\n");
++
++  /* Sanity check the address */
++  if (rel->r_offset > input_section->size)
++    {
++      (*_bfd_error_handler)
++      ("%B: %A+0x%lx: offset out of range (section size: 0x%lx)",
++       input_bfd, input_section, rel->r_offset, input_section->size);
++      return bfd_reloc_outofrange;
++    }
++
++  relocation = value + rel->r_addend;
++
++  if (howto->pc_relative)
++    {
++      bfd_vma addr;
++
++      addr = input_section->output_section->vma
++      + input_section->output_offset + rel->r_offset;
++      addr &= ~0UL << howto->rightshift;
++      relocation -= addr;
++    }
++
++  switch (ELF32_R_TYPE(rel->r_info))
++    {
++    case R_AVR32_16N_PCREL:
++      /* sub reg, pc, . - (sym + addend) */
++      relocation = -relocation;
++      break;
++    }
++
++  status = avr32_check_reloc_value(input_section, rel, relocation, howto);
++
++  relocation >>= howto->rightshift;
++  if (howto->bitsize == 21)
++    field = (relocation & 0xffff)
++      | ((relocation & 0x10000) << 4)
++      | ((relocation & 0x1e0000) << 8);
++  else if (howto->bitsize == 12)
++    field = (relocation & 0xff) | ((relocation & 0xf00) << 4);
++  else if (howto->bitsize == 10)
++    field = ((relocation & 0xff) << 4)
++      | ((relocation & 0x300) >> 8);
++  else
++    field = relocation << howto->bitpos;
++
++  switch (howto->size)
++    {
++    case 0:
++      x = bfd_get_8 (input_bfd, p);
++      x &= ~howto->dst_mask;
++      x |= field & howto->dst_mask;
++      bfd_put_8 (input_bfd, (bfd_vma) x, p);
++      break;
++    case 1:
++      x = bfd_get_16 (input_bfd, p);
++      x &= ~howto->dst_mask;
++      x |= field & howto->dst_mask;
++      bfd_put_16 (input_bfd, (bfd_vma) x, p);
++      break;
++    case 2:
++      x = bfd_get_32 (input_bfd, p);
++      x &= ~howto->dst_mask;
++      x |= field & howto->dst_mask;
++      bfd_put_32 (input_bfd, (bfd_vma) x, p);
++      break;
++    default:
++      abort();
++    }
++
++  return status;
++}
++
++/* (6) Apply relocations to the normal (non-dynamic) sections */
++
++static bfd_boolean
++avr32_elf_relocate_section(bfd *output_bfd, struct bfd_link_info *info,
++                         bfd *input_bfd, asection *input_section,
++                         bfd_byte *contents, Elf_Internal_Rela *relocs,
++                         Elf_Internal_Sym *local_syms,
++                         asection **local_sections)
++{
++  struct elf_avr32_link_hash_table *htab;
++  Elf_Internal_Shdr *symtab_hdr;
++  Elf_Internal_Rela *rel, *relend;
++  struct elf_link_hash_entry **sym_hashes;
++  struct got_entry **local_got_ents;
++  asection *sgot;
++  asection *srelgot;
++  asection *sreldyn;
++
++  pr_debug("(6) relocate section %s:<%s> (size 0x%lx)\n",
++         input_bfd->filename, input_section->name, input_section->size);
++
++  /* If we're doing a partial link, we don't have to do anything since
++     we're using RELA relocations */
++  if (info->relocatable)
++    return TRUE;
++
++  htab = avr32_elf_hash_table(info);
++  symtab_hdr = &elf_tdata(input_bfd)->symtab_hdr;
++  sym_hashes = elf_sym_hashes(input_bfd);
++  local_got_ents = elf_local_got_ents(input_bfd);
++  sgot = htab->sgot;
++  srelgot = htab->srelgot;
++  sreldyn = htab->sreldyn;
++
++  relend = relocs + input_section->reloc_count;
++  for (rel = relocs; rel < relend; rel++)
++    {
++      unsigned long r_type, r_symndx;
++      reloc_howto_type *howto;
++      Elf_Internal_Sym *sym = NULL;
++      struct elf_link_hash_entry *h = NULL;
++      asection *sec = NULL;
++      bfd_vma value;
++      bfd_vma offset;
++      bfd_reloc_status_type status;
++
++      r_type = ELF32_R_TYPE(rel->r_info);
++      r_symndx = ELF32_R_SYM(rel->r_info);
++
++      if (r_type == R_AVR32_NONE
++        || r_type == R_AVR32_ALIGN
++        || r_type == R_AVR32_DIFF32
++        || r_type == R_AVR32_DIFF16
++        || r_type == R_AVR32_DIFF8)
++      continue;
++
++      /* Sanity check */
++      if (r_type > R_AVR32_max)
++      {
++        bfd_set_error(bfd_error_bad_value);
++        return FALSE;
++      }
++
++      howto = &elf_avr32_howto_table[r_type];
++
++      if (r_symndx < symtab_hdr->sh_info)
++      {
++        sym = local_syms + r_symndx;
++        sec = local_sections[r_symndx];
++
++        pr_debug("  (6a) processing %s against local symbol %lu\n",
++                 howto->name, r_symndx);
++
++        /* The following function changes rel->r_addend behind our back. */
++        value = _bfd_elf_rela_local_sym(output_bfd, sym, &sec, rel);
++        pr_debug("    => value: %lx, addend: %lx\n", value, rel->r_addend);
++      }
++      else
++      {
++        if (sym_hashes == NULL)
++          return FALSE;
++
++        h = sym_hashes[r_symndx - symtab_hdr->sh_info];
++        while (h->root.type == bfd_link_hash_indirect
++               || h->root.type == bfd_link_hash_warning)
++          h = (struct elf_link_hash_entry *)h->root.u.i.link;
++
++        pr_debug("  (6a) processing %s against symbol %s\n",
++                 howto->name, h->root.root.string);
++
++        if (h->root.type == bfd_link_hash_defined
++            || h->root.type == bfd_link_hash_defweak)
++          {
++            bfd_boolean dyn;
++
++            dyn = htab->root.dynamic_sections_created;
++            sec = h->root.u.def.section;
++
++            if (sec->output_section)
++              value = (h->root.u.def.value
++                       + sec->output_section->vma
++                       + sec->output_offset);
++            else
++              value = h->root.u.def.value;
++          }
++        else if (h->root.type == bfd_link_hash_undefweak)
++          value = 0;
++        else if (info->unresolved_syms_in_objects == RM_IGNORE
++                 && ELF_ST_VISIBILITY(h->other) == STV_DEFAULT)
++          value = 0;
++        else
++          {
++            bfd_boolean err;
++            err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
++                   || ELF_ST_VISIBILITY(h->other) != STV_DEFAULT);
++            if (!info->callbacks->undefined_symbol
++                (info, h->root.root.string, input_bfd,
++                 input_section, rel->r_offset, err))
++              return FALSE;
++            value = 0;
++          }
++
++        pr_debug("    => value: %lx, addend: %lx\n", value, rel->r_addend);
++      }
++
++      switch (r_type)
++      {
++      case R_AVR32_GOT32:
++      case R_AVR32_GOT16:
++      case R_AVR32_GOT8:
++      case R_AVR32_GOT21S:
++      case R_AVR32_GOT18SW:
++      case R_AVR32_GOT16S:
++      case R_AVR32_GOT7UW:
++      case R_AVR32_LDA_GOT:
++      case R_AVR32_GOTCALL:
++        BFD_ASSERT(sgot != NULL);
++
++        if (h != NULL)
++          {
++            BFD_ASSERT(h->got.glist->refcount > 0);
++            offset = h->got.glist->offset;
++
++            BFD_ASSERT(offset < sgot->size);
++            if (!elf_hash_table(info)->dynamic_sections_created
++                || (h->def_regular
++                    && (!info->shared
++                        || info->symbolic
++                        || h->dynindx == -1)))
++              {
++                /* This is actually a static link, or it is a
++                   -Bsymbolic link and the symbol is defined
++                   locally, or the symbol was forced to be local.  */
++                bfd_put_32(output_bfd, value, sgot->contents + offset);
++              }
++          }
++        else
++          {
++            BFD_ASSERT(local_got_ents &&
++                       local_got_ents[r_symndx]->refcount > 0);
++            offset = local_got_ents[r_symndx]->offset;
++
++            /* Local GOT entries don't have relocs.  If this is a
++               shared library, the dynamic linker will add the load
++               address to the initial value at startup.  */
++            BFD_ASSERT(offset < sgot->size);
++            pr_debug("Initializing GOT entry at offset %lu: 0x%lx\n",
++                     offset, value);
++            bfd_put_32 (output_bfd, value, sgot->contents + offset);
++          }
++
++        value = sgot->output_offset + offset;
++        pr_debug("GOT reference: New value %lx\n", value);
++        break;
++
++      case R_AVR32_GOTPC:
++        /* This relocation type is for constant pool entries used in
++           the calculation "Rd = PC - (PC - GOT)", where the
++           constant pool supplies the constant (PC - GOT)
++           offset. The symbol value + addend indicates where the
++           value of PC is taken. */
++        value -= sgot->output_section->vma;
++        break;
++
++      case R_AVR32_32_PCREL:
++        /* We must adjust r_offset to account for discarded data in
++           the .eh_frame section.  This is probably not the right
++           way to do this, since AFAICS all other architectures do
++           it some other way.  I just can't figure out how...  */
++        {
++          bfd_vma r_offset;
++
++          r_offset = _bfd_elf_section_offset(output_bfd, info,
++                                             input_section,
++                                             rel->r_offset);
++          if (r_offset == (bfd_vma)-1
++              || r_offset == (bfd_vma)-2)
++            continue;
++          rel->r_offset = r_offset;
++        }
++        break;
++
++      case R_AVR32_32:
++        /* We need to emit a run-time relocation in the following cases:
++             - we're creating a shared library
++             - the symbol is not defined in any regular objects
++
++           Of course, sections that aren't going to be part of the
++           run-time image will not get any relocs, and undefined
++           symbols won't have any either (only weak undefined
++           symbols should get this far).  */
++        if ((info->shared
++             || (elf_hash_table(info)->dynamic_sections_created
++                 && h != NULL
++                 && h->def_dynamic
++                 && !h->def_regular))
++            && r_symndx != 0
++            && (input_section->flags & SEC_ALLOC))
++          {
++            Elf_Internal_Rela outrel;
++            bfd_byte *loc;
++            bfd_boolean skip, relocate;
++            struct elf_avr32_link_hash_entry *avrh;
++
++            pr_debug("Going to generate dynamic reloc...\n");
++
++            skip = FALSE;
++            relocate = FALSE;
++
++            outrel.r_offset = _bfd_elf_section_offset(output_bfd, info,
++                                                      input_section,
++                                                      rel->r_offset);
++            if (outrel.r_offset == (bfd_vma)-1)
++              skip = TRUE;
++            else if (outrel.r_offset == (bfd_vma)-2)
++              skip = TRUE, relocate = TRUE;
++
++            outrel.r_offset += (input_section->output_section->vma
++                                + input_section->output_offset);
++
++            pr_debug("    ... offset %lx, dynindx %ld\n",
++                     outrel.r_offset, h ? h->dynindx : -1);
++
++            if (skip)
++              memset(&outrel, 0, sizeof(outrel));
++            else
++              {
++                avrh = (struct elf_avr32_link_hash_entry *)h;
++                /* h->dynindx may be -1 if this symbol was marked to
++                   become local.  */
++                if (h == NULL
++                    || ((info->symbolic || h->dynindx == -1)
++                        && h->def_regular))
++                  {
++                    relocate = TRUE;
++                    outrel.r_info = ELF32_R_INFO(0, R_AVR32_RELATIVE);
++                    outrel.r_addend = value + rel->r_addend;
++                    pr_debug("    ... R_AVR32_RELATIVE\n");
++                  }
++                else
++                  {
++                    BFD_ASSERT(h->dynindx != -1);
++                    relocate = TRUE;
++                    outrel.r_info = ELF32_R_INFO(h->dynindx, R_AVR32_GLOB_DAT);
++                    outrel.r_addend = rel->r_addend;
++                    pr_debug("    ... R_AVR32_GLOB_DAT\n");
++                  }
++              }
++
++            pr_debug("sreldyn reloc_count: %d, size %lu\n",
++                     sreldyn->reloc_count, sreldyn->size);
++
++            loc = sreldyn->contents;
++            loc += sreldyn->reloc_count++ * sizeof(Elf32_External_Rela);
++            bfd_elf32_swap_reloca_out(output_bfd, &outrel, loc);
++
++            BFD_ASSERT(sreldyn->reloc_count * sizeof(Elf32_External_Rela)
++                       <= sreldyn->size);
++
++            if (!relocate)
++              continue;
++          }
++        break;
++      }
++
++      status = avr32_final_link_relocate(howto, input_bfd, input_section,
++                                       contents, rel, value);
++
++      switch (status)
++      {
++      case bfd_reloc_ok:
++        break;
++
++      case bfd_reloc_overflow:
++        {
++          const char *name;
++
++          if (h != NULL)
++            name = h->root.root.string;
++          else
++            {
++              name = bfd_elf_string_from_elf_section(input_bfd,
++                                                     symtab_hdr->sh_link,
++                                                     sym->st_name);
++              if (name == NULL)
++                return FALSE;
++              if (*name == '\0')
++                name = bfd_section_name(input_bfd, sec);
++            }
++          if (!((*info->callbacks->reloc_overflow)
++                (info, (h ? &h->root : NULL), name, howto->name,
++                 rel->r_addend, input_bfd, input_section, rel->r_offset)))
++            return FALSE;
++        }
++        break;
++
++      case bfd_reloc_outofrange:
++      default:
++        abort();
++      }
++    }
++
++  return TRUE;
++}
++
++\f
++/* Additional processing of dynamic sections after relocation */
++
++static bfd_boolean
++avr32_elf_finish_dynamic_symbol(bfd *output_bfd, struct bfd_link_info *info,
++                              struct elf_link_hash_entry *h,
++                              Elf_Internal_Sym *sym);
++static bfd_boolean
++avr32_elf_finish_dynamic_sections(bfd *output_bfd, struct bfd_link_info *info);
++
++
++/* (7) Initialize the contents of a dynamic symbol and/or emit
++   relocations for it */
++
++static bfd_boolean
++avr32_elf_finish_dynamic_symbol(bfd *output_bfd, struct bfd_link_info *info,
++                              struct elf_link_hash_entry *h,
++                              Elf_Internal_Sym *sym)
++{
++  struct elf_avr32_link_hash_table *htab;
++  struct got_entry *got;
++
++  pr_debug("(7) finish dynamic symbol: %s\n", h->root.root.string);
++
++  htab = avr32_elf_hash_table(info);
++  got = h->got.glist;
++
++  if (got && got->refcount > 0)
++    {
++      asection *sgot;
++      asection *srelgot;
++      Elf_Internal_Rela rel;
++      bfd_byte *loc;
++
++      /* This symbol has an entry in the GOT. Set it up. */
++      sgot = htab->sgot;
++      srelgot = htab->srelgot;
++      BFD_ASSERT(sgot && srelgot);
++
++      rel.r_offset = (sgot->output_section->vma
++                    + sgot->output_offset
++                    + got->offset);
++
++      /* If this is a static link, or it is a -Bsymbolic link and the
++       symbol is defined locally or was forced to be local because
++       of a version file, we just want to emit a RELATIVE reloc. The
++       entry in the global offset table will already have been
++       initialized in the relocate_section function. */
++      if ((info->shared
++         && !info->symbolic
++         && h->dynindx != -1)
++        || (htab->root.dynamic_sections_created
++            && h->def_dynamic
++            && !h->def_regular))
++      {
++        bfd_put_32(output_bfd, 0, sgot->contents + got->offset);
++        rel.r_info = ELF32_R_INFO(h->dynindx, R_AVR32_GLOB_DAT);
++        rel.r_addend = 0;
++
++        pr_debug("GOT reloc R_AVR32_GLOB_DAT, dynindx: %ld\n", h->dynindx);
++        pr_debug("    srelgot reloc_count: %d, size: %lu\n",
++                 srelgot->reloc_count, srelgot->size);
++
++        loc = (srelgot->contents
++               + srelgot->reloc_count++ * sizeof(Elf32_External_Rela));
++        bfd_elf32_swap_reloca_out(output_bfd, &rel, loc);
++
++        BFD_ASSERT(srelgot->reloc_count * sizeof(Elf32_External_Rela)
++                   <= srelgot->size);
++      }
++    }
++
++  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute */
++  if (strcmp(h->root.root.string, "_DYNAMIC") == 0
++      || strcmp(h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
++    sym->st_shndx = SHN_ABS;
++
++  return TRUE;
++}
++
++/* (8) Do any remaining initialization of the dynamic sections */
++
++static bfd_boolean
++avr32_elf_finish_dynamic_sections(bfd *output_bfd, struct bfd_link_info *info)
++{
++  struct elf_avr32_link_hash_table *htab;
++  asection *sgot, *sdyn;
++
++  pr_debug("(8) finish dynamic sections\n");
++
++  htab = avr32_elf_hash_table(info);
++  sgot = htab->sgot;
++  sdyn = bfd_get_section_by_name(htab->root.dynobj, ".dynamic");
++
++  if (htab->root.dynamic_sections_created)
++    {
++      Elf32_External_Dyn *dyncon, *dynconend;
++
++      BFD_ASSERT(sdyn && sgot && sgot->size >= AVR32_GOT_HEADER_SIZE);
++
++      dyncon = (Elf32_External_Dyn *)sdyn->contents;
++      dynconend = (Elf32_External_Dyn *)(sdyn->contents + sdyn->size);
++      for (; dyncon < dynconend; dyncon++)
++      {
++        Elf_Internal_Dyn dyn;
++        asection *s;
++
++        bfd_elf32_swap_dyn_in(htab->root.dynobj, dyncon, &dyn);
++
++        switch (dyn.d_tag)
++          {
++          default:
++            break;
++
++          case DT_PLTGOT:
++            s = sgot->output_section;
++            BFD_ASSERT(s != NULL);
++            dyn.d_un.d_ptr = s->vma;
++            bfd_elf32_swap_dyn_out(output_bfd, &dyn, dyncon);
++            break;
++
++          case DT_AVR32_GOTSZ:
++            s = sgot->output_section;
++            BFD_ASSERT(s != NULL);
++            dyn.d_un.d_val = s->size;
++            bfd_elf32_swap_dyn_out(output_bfd, &dyn, dyncon);
++            break;
++          }
++      }
++
++      /* Fill in the first two entries in the global offset table */
++      bfd_put_32(output_bfd,
++               sdyn->output_section->vma + sdyn->output_offset,
++               sgot->contents);
++
++      /* The runtime linker will fill this one in with the address of
++       the run-time link map */
++      bfd_put_32(output_bfd, 0, sgot->contents + 4);
++    }
++
++  if (sgot)
++    elf_section_data(sgot->output_section)->this_hdr.sh_entsize = 4;
++
++  return TRUE;
++}
++
++\f
++/* AVR32-specific private ELF data */
++
++static bfd_boolean
++avr32_elf_set_private_flags(bfd *abfd, flagword flags);
++static bfd_boolean
++avr32_elf_copy_private_bfd_data(bfd *ibfd, bfd *obfd);
++static bfd_boolean
++avr32_elf_merge_private_bfd_data(bfd *ibfd, bfd *obfd);
++static bfd_boolean
++avr32_elf_print_private_bfd_data(bfd *abfd, void *ptr);
++
++static bfd_boolean
++avr32_elf_set_private_flags(bfd *abfd, flagword flags)
++{
++  elf_elfheader(abfd)->e_flags = flags;
++  elf_flags_init(abfd) = TRUE;
++
++  return TRUE;
++}
++
++/* Copy backend specific data from one object module to another.  */
++
++static bfd_boolean
++avr32_elf_copy_private_bfd_data(bfd *ibfd, bfd *obfd)
++{
++  elf_elfheader(obfd)->e_flags = elf_elfheader(ibfd)->e_flags;
++  return TRUE;
++}
++
++/* Merge backend specific data from an object file to the output
++   object file when linking.  */
++
++static bfd_boolean
++avr32_elf_merge_private_bfd_data(bfd *ibfd, bfd *obfd)
++{
++  flagword out_flags, in_flags;
++
++  pr_debug("(0) merge_private_bfd_data: %s -> %s\n",
++         ibfd->filename, obfd->filename);
++
++  in_flags = elf_elfheader(ibfd)->e_flags;
++  out_flags = elf_elfheader(obfd)->e_flags;
++
++  if (elf_flags_init(obfd))
++    {
++      /* If one of the inputs are non-PIC, the output must be
++       considered non-PIC.  The same applies to linkrelax.  */
++      if (!(in_flags & EF_AVR32_PIC))
++      out_flags &= ~EF_AVR32_PIC;
++      if (!(in_flags & EF_AVR32_LINKRELAX))
++      out_flags &= ~EF_AVR32_LINKRELAX;
++    }
++  else
++    {
++      elf_flags_init(obfd) = TRUE;
++      out_flags = in_flags;
++    }
++
++  elf_elfheader(obfd)->e_flags = out_flags;
++
++  return TRUE;
++}
++
++static bfd_boolean
++avr32_elf_print_private_bfd_data(bfd *abfd, void *ptr)
++{
++  FILE *file = (FILE *)ptr;
++  unsigned long flags;
++
++  BFD_ASSERT(abfd != NULL && ptr != NULL);
++
++  _bfd_elf_print_private_bfd_data(abfd, ptr);
++
++  flags = elf_elfheader(abfd)->e_flags;
++
++  fprintf(file, _("private flags = %lx:"), elf_elfheader(abfd)->e_flags);
++
++  if (flags & EF_AVR32_PIC)
++    fprintf(file, " [PIC]");
++  if (flags & EF_AVR32_LINKRELAX)
++    fprintf(file, " [linker relaxable]");
++
++  flags &= ~(EF_AVR32_PIC | EF_AVR32_LINKRELAX);
++
++  if (flags)
++    fprintf(file, _("<Unrecognized flag bits set>"));
++
++  fputc('\n', file);
++
++  return TRUE;
++}
++
++\f
++/* Understanding core dumps */
++
++static bfd_boolean
++avr32_elf_grok_prstatus(bfd *abfd, Elf_Internal_Note *note);
++static bfd_boolean
++avr32_elf_grok_psinfo(bfd *abfd, Elf_Internal_Note *note);
++
++static bfd_boolean
++avr32_elf_grok_prstatus(bfd *abfd, Elf_Internal_Note *note)
++{
++  /* Linux/AVR32B elf_prstatus */
++  if (note->descsz != 148)
++    return FALSE;
++
++  /* pr_cursig */
++  elf_tdata(abfd)->core_signal = bfd_get_16(abfd, note->descdata + 12);
++
++  /* pr_pid */
++  elf_tdata(abfd)->core_pid = bfd_get_32(abfd, note->descdata + 24);
++
++  /* Make a ".reg/999" section for pr_reg. The size is for 16
++     general-purpose registers, SR and r12_orig (18 * 4 = 72).  */
++  return _bfd_elfcore_make_pseudosection(abfd, ".reg", 72,
++                                       note->descpos + 72);
++}
++
++static bfd_boolean
++avr32_elf_grok_psinfo(bfd *abfd, Elf_Internal_Note *note)
++{
++  /* Linux/AVR32B elf_prpsinfo */
++  if (note->descsz != 128)
++    return FALSE;
++
++  elf_tdata(abfd)->core_program
++    = _bfd_elfcore_strndup(abfd, note->descdata + 32, 16);
++  elf_tdata(abfd)->core_command
++    = _bfd_elfcore_strndup(abfd, note->descdata + 48, 80);
++
++  /* Note that for some reason, a spurious space is tacked
++     onto the end of the args in some (at least one anyway)
++     implementations, so strip it off if it exists.  */
++
++  {
++    char *command = elf_tdata (abfd)->core_command;
++    int n = strlen (command);
++
++    if (0 < n && command[n - 1] == ' ')
++      command[n - 1] = '\0';
++  }
++
++  return TRUE;
++}
++
++\f
++#define ELF_ARCH                      bfd_arch_avr32
++#define ELF_MACHINE_CODE              EM_AVR32
++#define ELF_MAXPAGESIZE                       0x1000
++
++#define TARGET_BIG_SYM                        bfd_elf32_avr32_vec
++#define TARGET_BIG_NAME                       "elf32-avr32"
++
++#define elf_backend_grok_prstatus     avr32_elf_grok_prstatus
++#define elf_backend_grok_psinfo               avr32_elf_grok_psinfo
++
++/* Only RELA relocations are used */
++#define elf_backend_may_use_rel_p     0
++#define elf_backend_may_use_rela_p    1
++#define elf_backend_default_use_rela_p        1
++#define elf_backend_rela_normal               1
++#define elf_info_to_howto_rel         NULL
++#define elf_info_to_howto             avr32_info_to_howto
++
++#define bfd_elf32_bfd_copy_private_bfd_data   avr32_elf_copy_private_bfd_data
++#define bfd_elf32_bfd_merge_private_bfd_data  avr32_elf_merge_private_bfd_data
++#define bfd_elf32_bfd_set_private_flags               avr32_elf_set_private_flags
++#define bfd_elf32_bfd_print_private_bfd_data  avr32_elf_print_private_bfd_data
++#define bfd_elf32_new_section_hook            avr32_elf_new_section_hook
++
++#define elf_backend_gc_mark_hook              avr32_elf_gc_mark_hook
++#define elf_backend_gc_sweep_hook             avr32_elf_gc_sweep_hook
++#define elf_backend_relocate_section  avr32_elf_relocate_section
++#define elf_backend_copy_indirect_symbol avr32_elf_copy_indirect_symbol
++#define elf_backend_create_dynamic_sections avr32_elf_create_dynamic_sections
++#define bfd_elf32_bfd_link_hash_table_create avr32_elf_link_hash_table_create
++#define elf_backend_adjust_dynamic_symbol avr32_elf_adjust_dynamic_symbol
++#define elf_backend_size_dynamic_sections avr32_elf_size_dynamic_sections
++#define elf_backend_finish_dynamic_symbol avr32_elf_finish_dynamic_symbol
++#define elf_backend_finish_dynamic_sections avr32_elf_finish_dynamic_sections
++
++#define bfd_elf32_bfd_relax_section   avr32_elf_relax_section
++
++/* Find out which symbols need an entry in .got. */
++#define elf_backend_check_relocs      avr32_check_relocs
++#define elf_backend_can_refcount      1
++#define elf_backend_can_gc_sections   1
++#define elf_backend_plt_readonly      1
++#define elf_backend_plt_not_loaded    1
++#define elf_backend_want_plt_sym      0
++#define elf_backend_plt_alignment     2
++#define elf_backend_want_dynbss               0
++#define elf_backend_want_got_plt      0
++#define elf_backend_want_got_sym      1
++#define elf_backend_got_header_size   AVR32_GOT_HEADER_SIZE
++
++#include "elf32-target.h"
+diff -Nrup binutils-2.17/bfd/elf-bfd.h binutils-2.17-atmel/bfd/elf-bfd.h
+--- binutils-2.17/bfd/elf-bfd.h        2006-03-16 13:20:15.000000000 +0100
++++ binutils-2.17-atmel/bfd/elf-bfd.h  2007-02-12 15:37:09.000000000 +0100
+@@ -1307,6 +1307,10 @@ struct elf_obj_tdata
+      find_nearest_line.  */
+   struct mips_elf_find_line *find_line_info;
++  /* Used by AVR32 ELF relaxation code.  Contains an array of pointers
++     for each local symbol to the fragment where it is defined.  */
++  struct fragment **local_sym_frag;
++
+   /* A place to stash dwarf1 info for this bfd.  */
+   struct dwarf1_debug *dwarf1_find_line_info;
+diff -Nrup binutils-2.17/bfd/libbfd.h binutils-2.17-atmel/bfd/libbfd.h
+--- binutils-2.17/bfd/libbfd.h 2006-03-26 01:38:42.000000000 +0100
++++ binutils-2.17-atmel/bfd/libbfd.h   2007-02-20 16:08:43.000000000 +0100
+@@ -1518,6 +1518,47 @@ static const char *const bfd_reloc_code_
+   "BFD_RELOC_AVR_LDI",
+   "BFD_RELOC_AVR_6",
+   "BFD_RELOC_AVR_6_ADIW",
++  "BFD_RELOC_AVR32_DIFF32",
++  "BFD_RELOC_AVR32_DIFF16",
++  "BFD_RELOC_AVR32_DIFF8",
++  "BFD_RELOC_AVR32_GOT32",
++  "BFD_RELOC_AVR32_GOT16",
++  "BFD_RELOC_AVR32_GOT8",
++  "BFD_RELOC_AVR32_21S",
++  "BFD_RELOC_AVR32_16U",
++  "BFD_RELOC_AVR32_16S",
++  "BFD_RELOC_AVR32_SUB5",
++  "BFD_RELOC_AVR32_8S_EXT",
++  "BFD_RELOC_AVR32_8S",
++  "BFD_RELOC_AVR32_22H_PCREL",
++  "BFD_RELOC_AVR32_18W_PCREL",
++  "BFD_RELOC_AVR32_16B_PCREL",
++  "BFD_RELOC_AVR32_16N_PCREL",
++  "BFD_RELOC_AVR32_14UW_PCREL",
++  "BFD_RELOC_AVR32_11H_PCREL",
++  "BFD_RELOC_AVR32_10UW_PCREL",
++  "BFD_RELOC_AVR32_9H_PCREL",
++  "BFD_RELOC_AVR32_9UW_PCREL",
++  "BFD_RELOC_AVR32_GOTPC",
++  "BFD_RELOC_AVR32_GOTCALL",
++  "BFD_RELOC_AVR32_LDA_GOT",
++  "BFD_RELOC_AVR32_GOT21S",
++  "BFD_RELOC_AVR32_GOT18SW",
++  "BFD_RELOC_AVR32_GOT16S",
++  "BFD_RELOC_AVR32_32_CPENT",
++  "BFD_RELOC_AVR32_CPCALL",
++  "BFD_RELOC_AVR32_16_CP",
++  "BFD_RELOC_AVR32_9W_CP",
++  "BFD_RELOC_AVR32_ALIGN",
++  "BFD_RELOC_AVR32_14UW",
++  "BFD_RELOC_AVR32_10UW",
++  "BFD_RELOC_AVR32_10SW",
++  "BFD_RELOC_AVR32_STHH_W",
++  "BFD_RELOC_AVR32_7UW",
++  "BFD_RELOC_AVR32_6S",
++  "BFD_RELOC_AVR32_6UW",
++  "BFD_RELOC_AVR32_4UH",
++  "BFD_RELOC_AVR32_3U",
+   "BFD_RELOC_390_12",
+   "BFD_RELOC_390_GOT12",
+   "BFD_RELOC_390_PLT32",
+diff -Nrup binutils-2.17/bfd/Makefile.am binutils-2.17-atmel/bfd/Makefile.am
+--- binutils-2.17/bfd/Makefile.am      2006-06-23 20:17:17.000000000 +0200
++++ binutils-2.17-atmel/bfd/Makefile.am        2007-02-12 15:37:09.000000000 +0100
+@@ -3,7 +3,7 @@
+ AUTOMAKE_OPTIONS = 1.9 cygnus
+ # Uncomment the following line when doing a release.
+-RELEASE=y
++# RELEASE=y
+ INCDIR = $(srcdir)/../include
+ CSEARCH = -I. -I$(srcdir) -I$(INCDIR)
+@@ -62,6 +62,7 @@ ALL_MACHINES = \
+       cpu-arc.lo \
+       cpu-arm.lo \
+       cpu-avr.lo \
++      cpu-avr32.lo \
+       cpu-bfin.lo \
+       cpu-cr16c.lo \
+       cpu-cris.lo \
+@@ -234,6 +235,7 @@ BFD32_BACKENDS = \
+       elf32-arc.lo \
+       elf32-arm.lo \
+       elf32-avr.lo \
++      elf32-avr32.lo \
+       elf32-bfin.lo \
+       elf32-cr16c.lo \
+       elf32-cris.lo \
+@@ -1265,6 +1267,10 @@ elf32-bfin.lo: elf32-bfin.c $(INCDIR)/fi
+   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
+   $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(INCDIR)/elf/bfin.h \
+   $(INCDIR)/elf/reloc-macros.h elf32-target.h
++elf32-avr32.lo: elf32-avr32.c $(INCDIR)/filenames.h elf-bfd.h \
++  $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
++  $(INCDIR)/bfdlink.h $(INCDIR)/elf/avr32.h $(INCDIR)/elf/reloc-macros.h \
++  elf32-target.h
+ elf32-cr16c.lo: elf32-cr16c.c $(INCDIR)/filenames.h \
+   $(INCDIR)/hashtab.h $(INCDIR)/bfdlink.h $(INCDIR)/elf/cr16c.h \
+   $(INCDIR)/elf/reloc-macros.h elf-bfd.h $(INCDIR)/elf/common.h \
+diff -Nrup binutils-2.17/bfd/Makefile.in binutils-2.17-atmel/bfd/Makefile.in
+--- binutils-2.17/bfd/Makefile.in      2006-06-23 20:17:19.000000000 +0200
++++ binutils-2.17-atmel/bfd/Makefile.in        2007-02-20 16:07:07.000000000 +0100
+@@ -1,4 +1,4 @@
+-# Makefile.in generated by automake 1.9.5 from Makefile.am.
++# Makefile.in generated by automake 1.9.6 from Makefile.am.
+ # @configure_input@
+ # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+@@ -15,8 +15,6 @@
+ @SET_MAKE@
+-SOURCES = $(libbfd_a_SOURCES) $(libbfd_la_SOURCES)
+-
+ srcdir = @srcdir@
+ top_srcdir = @top_srcdir@
+ VPATH = @srcdir@
+@@ -141,6 +139,7 @@ EXEEXT = @EXEEXT@
+ EXEEXT_FOR_BUILD = @EXEEXT_FOR_BUILD@
+ GMOFILES = @GMOFILES@
+ GMSGFMT = @GMSGFMT@
++GREP = @GREP@
+ GT_NO = @GT_NO@
+ GT_YES = @GT_YES@
+ HDEFINES = @HDEFINES@
+@@ -190,10 +189,7 @@ WARN_CFLAGS = @WARN_CFLAGS@
+ WIN32LDFLAGS = @WIN32LDFLAGS@
+ WIN32LIBADD = @WIN32LIBADD@
+ XGETTEXT = @XGETTEXT@
+-ac_ct_AR = @ac_ct_AR@
+ ac_ct_CC = @ac_ct_CC@
+-ac_ct_RANLIB = @ac_ct_RANLIB@
+-ac_ct_STRIP = @ac_ct_STRIP@
+ all_backends = @all_backends@
+ am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+ am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+@@ -219,6 +215,7 @@ build_vendor = @build_vendor@
+ datadir = @datadir@
+ datarootdir = @datarootdir@
+ docdir = @docdir@
++dvidir = @dvidir@
+ exec_prefix = @exec_prefix@
+ host = @host@
+ host_alias = @host_alias@
+@@ -233,12 +230,15 @@ install_sh = @install_sh@
+ l = @l@
+ libdir = @libdir@
+ libexecdir = @libexecdir@
++localedir = @localedir@
+ localstatedir = @localstatedir@
+ mandir = @mandir@
+ mkdir_p = @mkdir_p@
+ oldincludedir = @oldincludedir@
++pdfdir = @pdfdir@
+ prefix = @prefix@
+ program_transform_name = @program_transform_name@
++psdir = @psdir@
+ sbindir = @sbindir@
+ sharedstatedir = @sharedstatedir@
+ sysconfdir = @sysconfdir@
+@@ -253,7 +253,7 @@ wordsize = @wordsize@
+ AUTOMAKE_OPTIONS = 1.9 cygnus
+ # Uncomment the following line when doing a release.
+-RELEASE=y
++# RELEASE=y
+ INCDIR = $(srcdir)/../include
+ CSEARCH = -I. -I$(srcdir) -I$(INCDIR)
+ MKDEP = gcc -MM
+@@ -298,6 +298,7 @@ ALL_MACHINES = \
+       cpu-arc.lo \
+       cpu-arm.lo \
+       cpu-avr.lo \
++      cpu-avr32.lo \
+       cpu-bfin.lo \
+       cpu-cr16c.lo \
+       cpu-cris.lo \
+@@ -471,6 +472,7 @@ BFD32_BACKENDS = \
+       elf32-arc.lo \
+       elf32-arm.lo \
+       elf32-avr.lo \
++      elf32-avr32.lo \
+       elf32-bfin.lo \
+       elf32-cr16c.lo \
+       elf32-cris.lo \
+@@ -1831,6 +1833,10 @@ elf32-bfin.lo: elf32-bfin.c $(INCDIR)/fi
+   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
+   $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(INCDIR)/elf/bfin.h \
+   $(INCDIR)/elf/reloc-macros.h elf32-target.h
++elf32-avr32.lo: elf32-avr32.c $(INCDIR)/filenames.h elf-bfd.h \
++  $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
++  $(INCDIR)/bfdlink.h $(INCDIR)/elf/avr32.h $(INCDIR)/elf/reloc-macros.h \
++  elf32-target.h
+ elf32-cr16c.lo: elf32-cr16c.c $(INCDIR)/filenames.h \
+   $(INCDIR)/hashtab.h $(INCDIR)/bfdlink.h $(INCDIR)/elf/cr16c.h \
+   $(INCDIR)/elf/reloc-macros.h elf-bfd.h $(INCDIR)/elf/common.h \
+diff -Nrup binutils-2.17/bfd/reloc.c binutils-2.17-atmel/bfd/reloc.c
+--- binutils-2.17/bfd/reloc.c  2006-03-26 01:38:42.000000000 +0100
++++ binutils-2.17-atmel/bfd/reloc.c    2007-02-12 15:37:09.000000000 +0100
+@@ -3714,6 +3714,129 @@ ENUMDOC
+   instructions
+ ENUM
++  BFD_RELOC_AVR32_DIFF32
++ENUMX
++  BFD_RELOC_AVR32_DIFF16
++ENUMX
++  BFD_RELOC_AVR32_DIFF8
++ENUMDOC
++  Difference between two labels: L2 - L1. The value of L1 is encoded
++  as sym + addend, while the initial difference after assembly is
++  inserted into the object file by the assembler.
++ENUM
++  BFD_RELOC_AVR32_GOT32
++ENUMX
++  BFD_RELOC_AVR32_GOT16
++ENUMX
++  BFD_RELOC_AVR32_GOT8
++ENUMDOC
++  Reference to a symbol through the Global Offset Table. The linker
++  will allocate an entry for symbol in the GOT and insert the offset
++  of this entry as the relocation value.
++ENUM
++  BFD_RELOC_AVR32_21S
++ENUMX
++  BFD_RELOC_AVR32_16U
++ENUMX
++  BFD_RELOC_AVR32_16S
++ENUMX
++  BFD_RELOC_AVR32_SUB5
++ENUMX
++  BFD_RELOC_AVR32_8S_EXT
++ENUMX
++  BFD_RELOC_AVR32_8S
++ENUMDOC
++  Normal (non-pc-relative) code relocations. Alignment and signedness
++  is indicated by the suffixes. S means signed, U means unsigned. W
++  means word-aligned, H means halfword-aligned, neither means
++  byte-aligned (no alignment.) SUB5 is the same relocation as 16S.
++ENUM
++  BFD_RELOC_AVR32_22H_PCREL
++ENUMX
++  BFD_RELOC_AVR32_18W_PCREL
++ENUMX
++  BFD_RELOC_AVR32_16B_PCREL
++ENUMX
++  BFD_RELOC_AVR32_16N_PCREL
++ENUMX
++  BFD_RELOC_AVR32_14UW_PCREL
++ENUMX
++  BFD_RELOC_AVR32_11H_PCREL
++ENUMX
++  BFD_RELOC_AVR32_10UW_PCREL
++ENUMX
++  BFD_RELOC_AVR32_9H_PCREL
++ENUMX
++  BFD_RELOC_AVR32_9UW_PCREL
++ENUMDOC
++  PC-relative relocations are signed if neither 'U' nor 'S' is
++  specified. However, we explicitly tack on a 'B' to indicate no
++  alignment, to avoid confusion with data relocs. All of these resolve
++  to sym + addend - offset, except the one with 'N' (negated) suffix.
++  This particular one resolves to offset - sym - addend.
++ENUM
++  BFD_RELOC_AVR32_GOTPC
++ENUMDOC
++  Subtract the link-time address of the GOT from (symbol + addend)
++  and insert the result.
++ENUM
++  BFD_RELOC_AVR32_GOTCALL
++ENUMX
++  BFD_RELOC_AVR32_LDA_GOT
++ENUMX
++  BFD_RELOC_AVR32_GOT21S
++ENUMX
++  BFD_RELOC_AVR32_GOT18SW
++ENUMX
++  BFD_RELOC_AVR32_GOT16S
++ENUMDOC
++  Reference to a symbol through the GOT. The linker will allocate an
++  entry for symbol in the GOT and insert the offset of this entry as
++  the relocation value. addend must be zero. As usual, 'S' means
++  signed, 'W' means word-aligned, etc.
++ENUM
++  BFD_RELOC_AVR32_32_CPENT
++ENUMDOC
++  32-bit constant pool entry. I don't think 8- and 16-bit entries make
++  a whole lot of sense.
++ENUM
++  BFD_RELOC_AVR32_CPCALL
++ENUMX
++  BFD_RELOC_AVR32_16_CP
++ENUMX
++  BFD_RELOC_AVR32_9W_CP
++ENUMDOC
++  Constant pool references. Some of these relocations are signed,
++  others are unsigned. It doesn't really matter, since the constant
++  pool always comes after the code that references it.
++ENUM
++  BFD_RELOC_AVR32_ALIGN
++ENUMDOC
++  sym must be the absolute symbol. The addend specifies the alignment
++  order, e.g. if addend is 2, the linker must add padding so that the
++  next address is aligned to a 4-byte boundary.
++ENUM
++  BFD_RELOC_AVR32_14UW
++ENUMX
++  BFD_RELOC_AVR32_10UW
++ENUMX
++  BFD_RELOC_AVR32_10SW
++ENUMX
++  BFD_RELOC_AVR32_STHH_W
++ENUMX
++  BFD_RELOC_AVR32_7UW
++ENUMX
++  BFD_RELOC_AVR32_6S
++ENUMX
++  BFD_RELOC_AVR32_6UW
++ENUMX
++  BFD_RELOC_AVR32_4UH
++ENUMX
++  BFD_RELOC_AVR32_3U
++ENUMDOC
++  Code relocations that will never make it to the output file.
++
++ENUM
+   BFD_RELOC_390_12
+ ENUMDOC
+    Direct 12 bit.
+diff -Nrup binutils-2.17/bfd/targets.c binutils-2.17-atmel/bfd/targets.c
+--- binutils-2.17/bfd/targets.c        2006-04-05 14:41:57.000000000 +0200
++++ binutils-2.17-atmel/bfd/targets.c  2007-02-12 15:37:09.000000000 +0100
+@@ -553,6 +553,7 @@ extern const bfd_target b_out_vec_little
+ extern const bfd_target bfd_efi_app_ia32_vec;
+ extern const bfd_target bfd_efi_app_ia64_vec;
+ extern const bfd_target bfd_elf32_avr_vec;
++extern const bfd_target bfd_elf32_avr32_vec;
+ extern const bfd_target bfd_elf32_bfin_vec;
+ extern const bfd_target bfd_elf32_bfinfdpic_vec;
+ extern const bfd_target bfd_elf32_big_generic_vec;
+@@ -855,6 +856,7 @@ static const bfd_target * const _bfd_tar
+       &bfd_efi_app_ia64_vec,
+ #endif
+       &bfd_elf32_avr_vec,
++      &bfd_elf32_avr32_vec,
+       &bfd_elf32_bfin_vec,
+       &bfd_elf32_bfinfdpic_vec,
+diff -Nrup binutils-2.17/binutils/config.in binutils-2.17-atmel/binutils/config.in
+--- binutils-2.17/binutils/config.in   2006-02-14 09:59:10.000000000 +0100
++++ binutils-2.17-atmel/binutils/config.in     2007-02-20 16:07:22.000000000 +0100
+@@ -218,7 +218,7 @@
+ /* If using the C implementation of alloca, define if you know the
+    direction of stack growth for your system; otherwise it will be
+-   automatically deduced at run-time.
++   automatically deduced at runtime.
+       STACK_DIRECTION > 0 => grows toward higher addresses
+       STACK_DIRECTION < 0 => grows toward lower addresses
+       STACK_DIRECTION = 0 => direction of growth unknown */
+@@ -260,8 +260,8 @@
+ #undef inline
+ #endif
+-/* Define to `long' if <sys/types.h> does not define. */
++/* Define to `long int' if <sys/types.h> does not define. */
+ #undef off_t
+-/* Define to `unsigned' if <sys/types.h> does not define. */
++/* Define to `unsigned int' if <sys/types.h> does not define. */
+ #undef size_t
+diff -Nrup binutils-2.17/binutils/configure binutils-2.17-atmel/binutils/configure
+--- binutils-2.17/binutils/configure   2006-04-06 23:49:29.000000000 +0200
++++ binutils-2.17-atmel/binutils/configure     2007-02-20 16:07:20.000000000 +0100
+@@ -1,25 +1,54 @@
+ #! /bin/sh
+ # Guess values for system-dependent variables and create Makefiles.
+-# Generated by GNU Autoconf 2.59.
++# Generated by GNU Autoconf 2.61.
+ #
+-# Copyright (C) 2003 Free Software Foundation, Inc.
++# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ # This configure script is free software; the Free Software Foundation
+ # gives unlimited permission to copy, distribute and modify it.
+ ## --------------------- ##
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -29,8 +58,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -44,18 +108,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -63,157 +128,388 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++# CDPATH.
++$as_unset CDPATH
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
++if test "x$CONFIG_SHELL" = x; then
++  if (eval ":") 2>/dev/null; then
++  as_have_required=yes
++else
++  as_have_required=no
++fi
++
++  if test $as_have_required = yes &&   (eval ":
++(as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
+ fi
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0) || { (exit 1); exit 1; }
++
++(
++  as_lineno_1=\$LINENO
++  as_lineno_2=\$LINENO
++  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
++  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
++") 2> /dev/null; then
++  :
++else
++  as_candidate_shells=
+     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
++  case $as_dir in
+        /*)
+-         if ("$as_dir/$as_base" -c '
++         for as_base in sh bash ksh sh5; do
++           as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
++         done;;
++       esac
++done
++IFS=$as_save_IFS
++
++
++      for as_shell in $as_candidate_shells $SHELL; do
++       # Try only shells that exist, to save several forks.
++       if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
++              { ("$as_shell") 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++_ASEOF
++}; then
++  CONFIG_SHELL=$as_shell
++             as_have_required=yes
++             if { "$as_shell" 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++(as_func_return () {
++  (exit $1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = "$1" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test $exitcode = 0) || { (exit 1); exit 1; }
++
++(
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
++
++_ASEOF
++}; then
++  break
++fi
++
++fi
++
++      done
++
++      if test "x$CONFIG_SHELL" != x; then
++  for as_var in BASH_ENV ENV
++        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++        done
++        export CONFIG_SHELL
++        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
++fi
++
++
++    if test $as_have_required = no; then
++  echo This script requires a shell more modern than all the
++      echo shells that I found on your system.  Please install a
++      echo modern shell, or manually run the script under such a
++      echo shell if you do have one.
++      { (exit 1); exit 1; }
++fi
++
++
++fi
++
++fi
++
++
++
++(eval "as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0") || {
++  echo No shell found that supports shell functions.
++  echo Please tell autoconf@gnu.org about your system,
++  echo including any error possibly output before this
++  echo message
++}
++
++
++
++  as_lineno_1=$LINENO
++  as_lineno_2=$LINENO
++  test "x$as_lineno_1" != "x$as_lineno_2" &&
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
++  chmod +x "$as_me.lineno" ||
+     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -222,7 +518,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -231,39 +548,27 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
++exec 7<&0 </dev/null 6>&1
+ # Name of the host.
+ # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+ # so uname gets run too.
+ ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+-exec 6>&1
+-
+ #
+ # Initializations.
+ #
+ ac_default_prefix=/usr/local
++ac_clean_files=
+ ac_config_libobj_dir=.
++LIBOBJS=
+ cross_compiling=no
+ subdirs=
+ MFLAGS=
+ MAKEFLAGS=
+ SHELL=${CONFIG_SHELL-/bin/sh}
+-# Maximum number of lines to put in a shell here document.
+-# This variable seems obsolete.  It should probably be removed, and
+-# only ac_max_sed_lines should be used.
+-: ${ac_max_here_lines=38}
+-
+ # Identity of this package.
+ PACKAGE_NAME=
+ PACKAGE_TARNAME=
+@@ -275,42 +580,193 @@ ac_unique_file="ar.c"
+ # Factoring default headers for most tests.
+ ac_includes_default="\
+ #include <stdio.h>
+-#if HAVE_SYS_TYPES_H
++#ifdef HAVE_SYS_TYPES_H
+ # include <sys/types.h>
+ #endif
+-#if HAVE_SYS_STAT_H
++#ifdef HAVE_SYS_STAT_H
+ # include <sys/stat.h>
+ #endif
+-#if STDC_HEADERS
++#ifdef STDC_HEADERS
+ # include <stdlib.h>
+ # include <stddef.h>
+ #else
+-# if HAVE_STDLIB_H
++# ifdef HAVE_STDLIB_H
+ #  include <stdlib.h>
+ # endif
+ #endif
+-#if HAVE_STRING_H
+-# if !STDC_HEADERS && HAVE_MEMORY_H
++#ifdef HAVE_STRING_H
++# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+ #  include <memory.h>
+ # endif
+ # include <string.h>
+ #endif
+-#if HAVE_STRINGS_H
++#ifdef HAVE_STRINGS_H
+ # include <strings.h>
+ #endif
+-#if HAVE_INTTYPES_H
++#ifdef HAVE_INTTYPES_H
+ # include <inttypes.h>
+-#else
+-# if HAVE_STDINT_H
+-#  include <stdint.h>
+-# endif
+ #endif
+-#if HAVE_UNISTD_H
++#ifdef HAVE_STDINT_H
++# include <stdint.h>
++#endif
++#ifdef HAVE_UNISTD_H
+ # include <unistd.h>
+ #endif"
+-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE LN_S RANLIB ac_ct_RANLIB LIBTOOL WARN_CFLAGS NO_WERROR YACC LEX LEXLIB LEX_OUTPUT_ROOT CPP EGREP ALLOCA USE_NLS MSGFMT GMSGFMT XGETTEXT USE_INCLUDED_LIBINTL CATALOGS CATOBJEXT DATADIRNAME GMOFILES INSTOBJEXT INTLDEPS INTLLIBS INTLOBJS POFILES POSUB INCLUDE_LOCALE_H GT_NO GT_YES MKINSTALLDIRS l MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT HDEFINES AR CC_FOR_BUILD EXEEXT_FOR_BUILD DEMANGLER_NAME NLMCONV_DEFS BUILD_NLMCONV BUILD_SRCONV BUILD_DLLTOOL DLLTOOL_DEFS BUILD_WINDRES BUILD_DLLWRAP BUILD_MISC OBJDUMP_DEFS EMULATION EMULATION_VECTOR datarootdir docdir htmldir LIBOBJS LTLIBOBJS'
++ac_subst_vars='SHELL
++PATH_SEPARATOR
++PACKAGE_NAME
++PACKAGE_TARNAME
++PACKAGE_VERSION
++PACKAGE_STRING
++PACKAGE_BUGREPORT
++exec_prefix
++prefix
++program_transform_name
++bindir
++sbindir
++libexecdir
++datarootdir
++datadir
++sysconfdir
++sharedstatedir
++localstatedir
++includedir
++oldincludedir
++docdir
++infodir
++htmldir
++dvidir
++pdfdir
++psdir
++libdir
++localedir
++mandir
++DEFS
++ECHO_C
++ECHO_N
++ECHO_T
++LIBS
++build_alias
++host_alias
++target_alias
++build
++build_cpu
++build_vendor
++build_os
++host
++host_cpu
++host_vendor
++host_os
++target
++target_cpu
++target_vendor
++target_os
++CC
++CFLAGS
++LDFLAGS
++CPPFLAGS
++ac_ct_CC
++EXEEXT
++OBJEXT
++INSTALL_PROGRAM
++INSTALL_SCRIPT
++INSTALL_DATA
++CYGPATH_W
++PACKAGE
++VERSION
++ACLOCAL
++AUTOCONF
++AUTOMAKE
++AUTOHEADER
++MAKEINFO
++install_sh
++STRIP
++INSTALL_STRIP_PROGRAM
++mkdir_p
++AWK
++SET_MAKE
++am__leading_dot
++AMTAR
++am__tar
++am__untar
++DEPDIR
++am__include
++am__quote
++AMDEP_TRUE
++AMDEP_FALSE
++AMDEPBACKSLASH
++CCDEPMODE
++am__fastdepCC_TRUE
++am__fastdepCC_FALSE
++LN_S
++RANLIB
++LIBTOOL
++WARN_CFLAGS
++NO_WERROR
++YACC
++YFLAGS
++LEX
++LEX_OUTPUT_ROOT
++LEXLIB
++CPP
++GREP
++EGREP
++ALLOCA
++USE_NLS
++MSGFMT
++GMSGFMT
++XGETTEXT
++USE_INCLUDED_LIBINTL
++CATALOGS
++CATOBJEXT
++DATADIRNAME
++GMOFILES
++INSTOBJEXT
++INTLDEPS
++INTLLIBS
++INTLOBJS
++POFILES
++POSUB
++INCLUDE_LOCALE_H
++GT_NO
++GT_YES
++MKINSTALLDIRS
++l
++MAINTAINER_MODE_TRUE
++MAINTAINER_MODE_FALSE
++MAINT
++HDEFINES
++AR
++CC_FOR_BUILD
++EXEEXT_FOR_BUILD
++DEMANGLER_NAME
++NLMCONV_DEFS
++BUILD_NLMCONV
++BUILD_SRCONV
++BUILD_DLLTOOL
++DLLTOOL_DEFS
++BUILD_WINDRES
++BUILD_DLLWRAP
++BUILD_MISC
++OBJDUMP_DEFS
++EMULATION
++EMULATION_VECTOR
++LIBOBJS
++LTLIBOBJS'
+ ac_subst_files=''
++      ac_precious_vars='build_alias
++host_alias
++target_alias
++CC
++CFLAGS
++LDFLAGS
++LIBS
++CPPFLAGS
++YACC
++YFLAGS
++CPP'
++
+ # Initialize some variables set by options.
+ ac_init_help=
+@@ -337,34 +793,48 @@ x_libraries=NONE
+ # and all the variables that are supposed to be based on exec_prefix
+ # by default will actually change.
+ # Use braces instead of parens because sh, perl, etc. also accept them.
++# (The list follows the same order as the GNU Coding Standards.)
+ bindir='${exec_prefix}/bin'
+ sbindir='${exec_prefix}/sbin'
+ libexecdir='${exec_prefix}/libexec'
+-datadir='${prefix}/share'
++datarootdir='${prefix}/share'
++datadir='${datarootdir}'
+ sysconfdir='${prefix}/etc'
+ sharedstatedir='${prefix}/com'
+ localstatedir='${prefix}/var'
+-libdir='${exec_prefix}/lib'
+ includedir='${prefix}/include'
+ oldincludedir='/usr/include'
+-infodir='${prefix}/info'
+-mandir='${prefix}/man'
++docdir='${datarootdir}/doc/${PACKAGE}'
++infodir='${datarootdir}/info'
++htmldir='${docdir}'
++dvidir='${docdir}'
++pdfdir='${docdir}'
++psdir='${docdir}'
++libdir='${exec_prefix}/lib'
++localedir='${datarootdir}/locale'
++mandir='${datarootdir}/man'
+ ac_prev=
++ac_dashdash=
+ for ac_option
+ do
+   # If the previous option needs an argument, assign it.
+   if test -n "$ac_prev"; then
+-    eval "$ac_prev=\$ac_option"
++    eval $ac_prev=\$ac_option
+     ac_prev=
+     continue
+   fi
+-  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
++  case $ac_option in
++  *=*)        ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
++  *)  ac_optarg=yes ;;
++  esac
+   # Accept the important Cygnus configure options, so we can diagnose typos.
+-  case $ac_option in
++  case $ac_dashdash$ac_option in
++  --)
++    ac_dashdash=yes ;;
+   -bindir | --bindir | --bindi | --bind | --bin | --bi)
+     ac_prev=bindir ;;
+@@ -386,33 +856,45 @@ do
+   --config-cache | -C)
+     cache_file=config.cache ;;
+-  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
++  -datadir | --datadir | --datadi | --datad)
+     ac_prev=datadir ;;
+-  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+-  | --da=*)
++  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+     datadir=$ac_optarg ;;
++  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
++  | --dataroo | --dataro | --datar)
++    ac_prev=datarootdir ;;
++  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
++  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
++    datarootdir=$ac_optarg ;;
++
+   -disable-* | --disable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    eval "enable_$ac_feature=no" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=no ;;
++
++  -docdir | --docdir | --docdi | --doc | --do)
++    ac_prev=docdir ;;
++  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
++    docdir=$ac_optarg ;;
++
++  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
++    ac_prev=dvidir ;;
++  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
++    dvidir=$ac_optarg ;;
+   -enable-* | --enable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "enable_$ac_feature='$ac_optarg'" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=\$ac_optarg ;;
+   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+@@ -439,6 +921,12 @@ do
+   -host=* | --host=* | --hos=* | --ho=*)
+     host_alias=$ac_optarg ;;
++  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
++    ac_prev=htmldir ;;
++  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
++  | --ht=*)
++    htmldir=$ac_optarg ;;
++
+   -includedir | --includedir | --includedi | --included | --include \
+   | --includ | --inclu | --incl | --inc)
+     ac_prev=includedir ;;
+@@ -463,13 +951,16 @@ do
+   | --libexe=* | --libex=* | --libe=*)
+     libexecdir=$ac_optarg ;;
++  -localedir | --localedir | --localedi | --localed | --locale)
++    ac_prev=localedir ;;
++  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
++    localedir=$ac_optarg ;;
++
+   -localstatedir | --localstatedir | --localstatedi | --localstated \
+-  | --localstate | --localstat | --localsta | --localst \
+-  | --locals | --local | --loca | --loc | --lo)
++  | --localstate | --localstat | --localsta | --localst | --locals)
+     ac_prev=localstatedir ;;
+   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+-  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+-  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
++  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+     localstatedir=$ac_optarg ;;
+   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+@@ -534,6 +1025,16 @@ do
+   | --progr-tra=* | --program-tr=* | --program-t=*)
+     program_transform_name=$ac_optarg ;;
++  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
++    ac_prev=pdfdir ;;
++  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
++    pdfdir=$ac_optarg ;;
++
++  -psdir | --psdir | --psdi | --psd | --ps)
++    ac_prev=psdir ;;
++  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
++    psdir=$ac_optarg ;;
++
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil)
+     silent=yes ;;
+@@ -586,24 +1087,20 @@ do
+   -with-* | --with-*)
+     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package| sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "with_$ac_package='$ac_optarg'" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=\$ac_optarg ;;
+   -without-* | --without-*)
+     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package | sed 's/-/_/g'`
+-    eval "with_$ac_package=no" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=no ;;
+   --x)
+     # Obsolete; use --with-x.
+@@ -634,8 +1131,7 @@ Try \`$0 --help' for more information." 
+     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
+    { (exit 1); exit 1; }; }
+-    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
+-    eval "$ac_envvar='$ac_optarg'"
++    eval $ac_envvar=\$ac_optarg
+     export $ac_envvar ;;
+   *)
+@@ -655,27 +1151,19 @@ if test -n "$ac_prev"; then
+    { (exit 1); exit 1; }; }
+ fi
+-# Be sure to have absolute paths.
+-for ac_var in exec_prefix prefix
+-do
+-  eval ac_val=$`echo $ac_var`
+-  case $ac_val in
+-    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
+-  esac
+-done
+-
+-# Be sure to have absolute paths.
+-for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
+-            localstatedir libdir includedir oldincludedir infodir mandir
++# Be sure to have absolute directory names.
++for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
++              datadir sysconfdir sharedstatedir localstatedir includedir \
++              oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
++              libdir localedir mandir
+ do
+-  eval ac_val=$`echo $ac_var`
++  eval ac_val=\$$ac_var
+   case $ac_val in
+-    [\\/$]* | ?:[\\/]* ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
++    [\\/$]* | ?:[\\/]* )  continue;;
++    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+   esac
++  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
++   { (exit 1); exit 1; }; }
+ done
+ # There might be people who depend on the old broken behavior: `$host'
+@@ -702,74 +1190,76 @@ test -n "$host_alias" && ac_tool_prefix=
+ test "$silent" = yes && exec 6>/dev/null
++ac_pwd=`pwd` && test -n "$ac_pwd" &&
++ac_ls_di=`ls -di .` &&
++ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
++  { echo "$as_me: error: Working directory cannot be determined" >&2
++   { (exit 1); exit 1; }; }
++test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
++  { echo "$as_me: error: pwd does not report name of working directory" >&2
++   { (exit 1); exit 1; }; }
++
++
+ # Find the source files, if location was not specified.
+ if test -z "$srcdir"; then
+   ac_srcdir_defaulted=yes
+-  # Try the directory containing this script, then its parent.
+-  ac_confdir=`(dirname "$0") 2>/dev/null ||
++  # Try the directory containing this script, then the parent directory.
++  ac_confdir=`$as_dirname -- "$0" ||
+ $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$0" : 'X\(//\)[^/]' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$0" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   srcdir=$ac_confdir
+-  if test ! -r $srcdir/$ac_unique_file; then
++  if test ! -r "$srcdir/$ac_unique_file"; then
+     srcdir=..
+   fi
+ else
+   ac_srcdir_defaulted=no
+ fi
+-if test ! -r $srcdir/$ac_unique_file; then
+-  if test "$ac_srcdir_defaulted" = yes; then
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
+-   { (exit 1); exit 1; }; }
+-  else
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-fi
+-(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
+-  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
+-   { (exit 1); exit 1; }; }
+-srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
+-ac_env_build_alias_set=${build_alias+set}
+-ac_env_build_alias_value=$build_alias
+-ac_cv_env_build_alias_set=${build_alias+set}
+-ac_cv_env_build_alias_value=$build_alias
+-ac_env_host_alias_set=${host_alias+set}
+-ac_env_host_alias_value=$host_alias
+-ac_cv_env_host_alias_set=${host_alias+set}
+-ac_cv_env_host_alias_value=$host_alias
+-ac_env_target_alias_set=${target_alias+set}
+-ac_env_target_alias_value=$target_alias
+-ac_cv_env_target_alias_set=${target_alias+set}
+-ac_cv_env_target_alias_value=$target_alias
+-ac_env_CC_set=${CC+set}
+-ac_env_CC_value=$CC
+-ac_cv_env_CC_set=${CC+set}
+-ac_cv_env_CC_value=$CC
+-ac_env_CFLAGS_set=${CFLAGS+set}
+-ac_env_CFLAGS_value=$CFLAGS
+-ac_cv_env_CFLAGS_set=${CFLAGS+set}
+-ac_cv_env_CFLAGS_value=$CFLAGS
+-ac_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_env_LDFLAGS_value=$LDFLAGS
+-ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_cv_env_LDFLAGS_value=$LDFLAGS
+-ac_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_env_CPPFLAGS_value=$CPPFLAGS
+-ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_cv_env_CPPFLAGS_value=$CPPFLAGS
+-ac_env_CPP_set=${CPP+set}
+-ac_env_CPP_value=$CPP
+-ac_cv_env_CPP_set=${CPP+set}
+-ac_cv_env_CPP_value=$CPP
++if test ! -r "$srcdir/$ac_unique_file"; then
++  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
++  { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
++   { (exit 1); exit 1; }; }
++fi
++ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
++ac_abs_confdir=`(
++      cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2
++   { (exit 1); exit 1; }; }
++      pwd)`
++# When building in place, set srcdir=.
++if test "$ac_abs_confdir" = "$ac_pwd"; then
++  srcdir=.
++fi
++# Remove unnecessary trailing slashes from srcdir.
++# Double slashes in file names in object file debugging info
++# mess up M-x gdb in Emacs.
++case $srcdir in
++*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
++esac
++for ac_var in $ac_precious_vars; do
++  eval ac_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_env_${ac_var}_value=\$${ac_var}
++  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_cv_env_${ac_var}_value=\$${ac_var}
++done
+ #
+ # Report the --help message.
+@@ -798,9 +1288,6 @@ Configuration:
+   -n, --no-create         do not create output files
+       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+-_ACEOF
+-
+-  cat <<_ACEOF
+ Installation directories:
+   --prefix=PREFIX         install architecture-independent files in PREFIX
+                         [$ac_default_prefix]
+@@ -818,15 +1305,22 @@ Fine tuning of the installation director
+   --bindir=DIR           user executables [EPREFIX/bin]
+   --sbindir=DIR          system admin executables [EPREFIX/sbin]
+   --libexecdir=DIR       program executables [EPREFIX/libexec]
+-  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
+   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
+   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
+   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
+   --libdir=DIR           object code libraries [EPREFIX/lib]
+   --includedir=DIR       C header files [PREFIX/include]
+   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
+-  --infodir=DIR          info documentation [PREFIX/info]
+-  --mandir=DIR           man documentation [PREFIX/man]
++  --datarootdir=DIR      read-only arch.-independent data root [PREFIX/share]
++  --datadir=DIR          read-only architecture-independent data [DATAROOTDIR]
++  --infodir=DIR          info documentation [DATAROOTDIR/info]
++  --localedir=DIR        locale-dependent data [DATAROOTDIR/locale]
++  --mandir=DIR           man documentation [DATAROOTDIR/man]
++  --docdir=DIR           documentation root [DATAROOTDIR/doc/PACKAGE]
++  --htmldir=DIR          html documentation [DOCDIR]
++  --dvidir=DIR           dvi documentation [DOCDIR]
++  --pdfdir=DIR           pdf documentation [DOCDIR]
++  --psdir=DIR            ps documentation [DOCDIR]
+ _ACEOF
+   cat <<\_ACEOF
+@@ -876,126 +1370,100 @@ Some influential environment variables:
+   CFLAGS      C compiler flags
+   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+               nonstandard directory <lib dir>
+-  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
+-              headers in a nonstandard directory <include dir>
++  LIBS        libraries to pass to the linker, e.g. -l<library>
++  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
++              you have headers in a nonstandard directory <include dir>
++  YACC        The `Yet Another C Compiler' implementation to use. Defaults to
++              the first program found out of: `bison -y', `byacc', `yacc'.
++  YFLAGS      The list of arguments that will be passed by default to $YACC.
++              This script will default YFLAGS to the empty string to avoid a
++              default value of `-d' given by some make applications.
+   CPP         C preprocessor
+ Use these variables to override the choices made by `configure' or to help
+ it to find libraries and programs with nonstandard names/locations.
+ _ACEOF
++ac_status=$?
+ fi
+ if test "$ac_init_help" = "recursive"; then
+   # If there are subdirs, report their specific --help.
+-  ac_popdir=`pwd`
+   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+-    test -d $ac_dir || continue
++    test -d "$ac_dir" || continue
+     ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
+-
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
+-
+-    cd $ac_dir
+-    # Check for guested configure; otherwise get Cygnus style configure.
+-    if test -f $ac_srcdir/configure.gnu; then
+-      echo
+-      $SHELL $ac_srcdir/configure.gnu  --help=recursive
+-    elif test -f $ac_srcdir/configure; then
+-      echo
+-      $SHELL $ac_srcdir/configure  --help=recursive
+-    elif test -f $ac_srcdir/configure.ac ||
+-         test -f $ac_srcdir/configure.in; then
+-      echo
+-      $ac_configure --help
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
++
++    cd "$ac_dir" || { ac_status=$?; continue; }
++    # Check for guested configure.
++    if test -f "$ac_srcdir/configure.gnu"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
++    elif test -f "$ac_srcdir/configure"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure" --help=recursive
+     else
+       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+-    fi
+-    cd $ac_popdir
++    fi || ac_status=$?
++    cd "$ac_pwd" || { ac_status=$?; break; }
+   done
+ fi
+-test -n "$ac_init_help" && exit 0
++test -n "$ac_init_help" && exit $ac_status
+ if $ac_init_version; then
+   cat <<\_ACEOF
++configure
++generated by GNU Autoconf 2.61
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ This configure script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it.
+ _ACEOF
+-  exit 0
++  exit
+ fi
+-exec 5>config.log
+-cat >&5 <<_ACEOF
++cat >config.log <<_ACEOF
+ This file contains any messages produced by compilers while
+ running configure, to aid debugging if configure makes a mistake.
+ It was created by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   $ $0 $@
+ _ACEOF
++exec 5>>config.log
+ {
+ cat <<_ASUNAME
+ ## --------- ##
+@@ -1014,7 +1482,7 @@ uname -v = `(uname -v) 2>/dev/null || ec
+ /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+ /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+ /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+-hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
++/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+ /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+ /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+ /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+@@ -1028,6 +1496,7 @@ do
+   test -z "$as_dir" && as_dir=.
+   echo "PATH: $as_dir"
+ done
++IFS=$as_save_IFS
+ } >&5
+@@ -1049,7 +1518,6 @@ _ACEOF
+ ac_configure_args=
+ ac_configure_args0=
+ ac_configure_args1=
+-ac_sep=
+ ac_must_keep_next=false
+ for ac_pass in 1 2
+ do
+@@ -1060,7 +1528,7 @@ do
+     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+     | -silent | --silent | --silen | --sile | --sil)
+       continue ;;
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
++    *\'*)
+       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+     esac
+     case $ac_pass in
+@@ -1082,9 +1550,7 @@ do
+         -* ) ac_must_keep_next=true ;;
+       esac
+       fi
+-      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
+-      # Get rid of the leading space.
+-      ac_sep=" "
++      ac_configure_args="$ac_configure_args '$ac_arg'"
+       ;;
+     esac
+   done
+@@ -1095,8 +1561,8 @@ $as_unset ac_configure_args1 || test "${
+ # When interrupted or exit'd, cleanup temporary files, and complete
+ # config.log.  We remove comments because anyway the quotes in there
+ # would cause problems or look ugly.
+-# WARNING: Be sure not to use single quotes in there, as some shells,
+-# such as our DU 5.0 friend, will then `close' the trap.
++# WARNING: Use '\'' to represent an apostrophe within the trap.
++# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+ trap 'exit_status=$?
+   # Save into config.log some information that might help in debugging.
+   {
+@@ -1109,20 +1575,34 @@ trap 'exit_status=$?
+ _ASBOX
+     echo
+     # The following way of writing the cache mishandles newlines in values,
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
+   (set) 2>&1 |
+-    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       sed -n \
+-      "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
+-        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
+-      ;;
++      "s/'\''/'\''\\\\'\'''\''/g;
++        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
++      ;; #(
+     *)
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-}
++    esac |
++    sort
++)
+     echo
+     cat <<\_ASBOX
+@@ -1133,22 +1613,28 @@ _ASBOX
+     echo
+     for ac_var in $ac_subst_vars
+     do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+     done | sort
+     echo
+     if test -n "$ac_subst_files"; then
+       cat <<\_ASBOX
+-## ------------- ##
+-## Output files. ##
+-## ------------- ##
++## ------------------- ##
++## File substitutions. ##
++## ------------------- ##
+ _ASBOX
+       echo
+       for ac_var in $ac_subst_files
+       do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+       done | sort
+       echo
+     fi
+@@ -1160,26 +1646,24 @@ _ASBOX
+ ## ----------- ##
+ _ASBOX
+       echo
+-      sed "/^$/d" confdefs.h | sort
++      cat confdefs.h
+       echo
+     fi
+     test "$ac_signal" != 0 &&
+       echo "$as_me: caught signal $ac_signal"
+     echo "$as_me: exit $exit_status"
+   } >&5
+-  rm -f core *.core &&
+-  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
++  rm -f core *.core core.conftest.* &&
++    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+     exit $exit_status
+-     ' 0
++' 0
+ for ac_signal in 1 2 13 15; do
+   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+ done
+ ac_signal=0
+ # confdefs.h avoids OS command line length limits that DEFS can exceed.
+-rm -rf conftest* confdefs.h
+-# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+-echo >confdefs.h
++rm -f -r conftest* confdefs.h
+ # Predefined preprocessor variables.
+@@ -1210,14 +1694,17 @@ _ACEOF
+ # Let the site file select an alternate cache file if it wants to.
+ # Prefer explicitly selected file to automatically selected ones.
+-if test -z "$CONFIG_SITE"; then
+-  if test "x$prefix" != xNONE; then
+-    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+-  else
+-    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+-  fi
++if test -n "$CONFIG_SITE"; then
++  set x "$CONFIG_SITE"
++elif test "x$prefix" != xNONE; then
++  set x "$prefix/share/config.site" "$prefix/etc/config.site"
++else
++  set x "$ac_default_prefix/share/config.site" \
++      "$ac_default_prefix/etc/config.site"
+ fi
+-for ac_site_file in $CONFIG_SITE; do
++shift
++for ac_site_file
++do
+   if test -r "$ac_site_file"; then
+     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
+ echo "$as_me: loading site script $ac_site_file" >&6;}
+@@ -1233,8 +1720,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -1246,12 +1733,11 @@ fi
+ # Check that the precious variables saved in the cache have kept the same
+ # value.
+ ac_cache_corrupted=false
+-for ac_var in `(set) 2>&1 |
+-             sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
++for ac_var in $ac_precious_vars; do
+   eval ac_old_set=\$ac_cv_env_${ac_var}_set
+   eval ac_new_set=\$ac_env_${ac_var}_set
+-  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
+-  eval ac_new_val="\$ac_env_${ac_var}_value"
++  eval ac_old_val=\$ac_cv_env_${ac_var}_value
++  eval ac_new_val=\$ac_env_${ac_var}_value
+   case $ac_old_set,$ac_new_set in
+     set,)
+       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+@@ -1276,8 +1762,7 @@ echo "$as_me:   current value: $ac_new_v
+   # Pass precious variables to config.status.
+   if test "$ac_new_set" = set; then
+     case $ac_new_val in
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+-      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
++    *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+     *) ac_arg=$ac_var=$ac_new_val ;;
+     esac
+     case " $ac_configure_args " in
+@@ -1294,12 +1779,6 @@ echo "$as_me: error: run \`make distclea
+    { (exit 1); exit 1; }; }
+ fi
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+@@ -1316,108 +1795,163 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ ac_aux_dir=
+-for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
+-  if test -f $ac_dir/install-sh; then
++for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
++  if test -f "$ac_dir/install-sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install-sh -c"
+     break
+-  elif test -f $ac_dir/install.sh; then
++  elif test -f "$ac_dir/install.sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install.sh -c"
+     break
+-  elif test -f $ac_dir/shtool; then
++  elif test -f "$ac_dir/shtool"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/shtool install -c"
+     break
+   fi
+ done
+ if test -z "$ac_aux_dir"; then
+-  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
+-echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
++  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&5
++echo "$as_me: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-ac_config_guess="$SHELL $ac_aux_dir/config.guess"
+-ac_config_sub="$SHELL $ac_aux_dir/config.sub"
+-ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
++
++# These three variables are undocumented and unsupported,
++# and are intended to be withdrawn in a future Autoconf release.
++# They can cause serious problems if a builder's source tree is in a directory
++# whose full name contains unusual characters.
++ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
++ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
++ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
++
+ # Make sure we can run config.sub.
+-$ac_config_sub sun4 >/dev/null 2>&1 ||
+-  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
+-echo "$as_me: error: cannot run $ac_config_sub" >&2;}
++$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
++  { { echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
++echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking build system type" >&5
+-echo $ECHO_N "checking build system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking build system type" >&5
++echo $ECHO_N "checking build system type... $ECHO_C" >&6; }
+ if test "${ac_cv_build+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_build_alias=$build_alias
+-test -z "$ac_cv_build_alias" &&
+-  ac_cv_build_alias=`$ac_config_guess`
+-test -z "$ac_cv_build_alias" &&
++  ac_build_alias=$build_alias
++test "x$ac_build_alias" = x &&
++  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
++test "x$ac_build_alias" = x &&
+   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
+ echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
+    { (exit 1); exit 1; }; }
+-ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
++ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
++  { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_build" >&5
+-echo "${ECHO_T}$ac_cv_build" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_build" >&5
++echo "${ECHO_T}$ac_cv_build" >&6; }
++case $ac_cv_build in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
++echo "$as_me: error: invalid value of canonical build" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ build=$ac_cv_build
+-build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_build
++shift
++build_cpu=$1
++build_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++build_os=$*
++IFS=$ac_save_IFS
++case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking host system type" >&5
+-echo $ECHO_N "checking host system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking host system type" >&5
++echo $ECHO_N "checking host system type... $ECHO_C" >&6; }
+ if test "${ac_cv_host+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_host_alias=$host_alias
+-test -z "$ac_cv_host_alias" &&
+-  ac_cv_host_alias=$ac_cv_build_alias
+-ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
++  if test "x$host_alias" = x; then
++  ac_cv_host=$ac_cv_build
++else
++  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_host" >&5
+-echo "${ECHO_T}$ac_cv_host" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_host" >&5
++echo "${ECHO_T}$ac_cv_host" >&6; }
++case $ac_cv_host in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
++echo "$as_me: error: invalid value of canonical host" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ host=$ac_cv_host
+-host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_host
++shift
++host_cpu=$1
++host_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++host_os=$*
++IFS=$ac_save_IFS
++case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking target system type" >&5
+-echo $ECHO_N "checking target system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking target system type" >&5
++echo $ECHO_N "checking target system type... $ECHO_C" >&6; }
+ if test "${ac_cv_target+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_target_alias=$target_alias
+-test "x$ac_cv_target_alias" = "x" &&
+-  ac_cv_target_alias=$ac_cv_host_alias
+-ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
++  if test "x$target_alias" = x; then
++  ac_cv_target=$ac_cv_host
++else
++  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_target" >&5
+-echo "${ECHO_T}$ac_cv_target" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_target" >&5
++echo "${ECHO_T}$ac_cv_target" >&6; }
++case $ac_cv_target in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical target" >&5
++echo "$as_me: error: invalid value of canonical target" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ target=$ac_cv_target
+-target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_target
++shift
++target_cpu=$1
++target_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++target_os=$*
++IFS=$ac_save_IFS
++case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
+ # The aliases save the names the user supplied, while $host etc.
+@@ -1434,8 +1968,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1448,32 +1982,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_CC"; then
+   ac_ct_CC=$CC
+   # Extract the first word of "gcc", so it can be a program name with args.
+ set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1486,36 +2022,51 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ else
+   CC="$ac_cv_prog_CC"
+ fi
+ if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1528,74 +2079,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}cc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
+-
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++  fi
+ fi
+ if test -z "$CC"; then
+   # Extract the first word of "cc", so it can be a program name with args.
+ set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1609,7 +2120,7 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+        continue
+@@ -1620,6 +2131,7 @@ do
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ if test $ac_prog_rejected = yes; then
+   # We found a bogon in the path, so make sure we never use it.
+@@ -1637,22 +2149,23 @@ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$CC"; then
+   if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1665,36 +2178,38 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+     test -n "$CC" && break
+   done
+ fi
+ if test -z "$CC"; then
+   ac_ct_CC=$CC
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1707,29 +2222,45 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$ac_ct_CC" && break
+ done
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ fi
+ fi
+@@ -1742,21 +2273,35 @@ See \`config.log' for more details." >&2
+    { (exit 1); exit 1; }; }
+ # Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
++echo "$as_me:$LINENO: checking for C compiler version" >&5
+ ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+@@ -1781,47 +2326,77 @@ ac_clean_files="$ac_clean_files a.out a.
+ # Try to create an executable without -o first, disregard a.out.
+ # It will help us diagnose broken compilers, and finding out an intuition
+ # of exeext.
+-echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
+-echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
++echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6; }
+ ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+-if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
+-  (eval $ac_link_default) 2>&5
++#
++# List of possible output files, starting from the most likely.
++# The algorithm is not robust to junk in `.', hence go to wildcards (a.*)
++# only as a last resort.  b.out is created by i960 compilers.
++ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'
++#
++# The IRIX 6 linker writes into existing files which may not be
++# executable, retaining their permissions.  Remove them first so a
++# subsequent execution test works.
++ac_rmfiles=
++for ac_file in $ac_files
++do
++  case $ac_file in
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
++    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
++  esac
++done
++rm -f $ac_rmfiles
++
++if { (ac_try="$ac_link_default"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link_default") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  # Find the output, starting from the most likely.  This scheme is
+-# not robust to junk in `.', hence go to wildcards (a.*) only as a last
+-# resort.
+-
+-# Be careful to initialize this variable, since it used to be cached.
+-# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
+-ac_cv_exeext=
+-# b.out is created by i960 compilers.
+-for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
++  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
++# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
++# in a Makefile.  We should not override ac_cv_exeext if it was cached,
++# so that the user can short-circuit this test for compilers unknown to
++# Autoconf.
++for ac_file in $ac_files ''
+ do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
+-      ;;
+-    conftest.$ac_ext )
+-      # This is the source file.
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )
+       ;;
+     [ab].out )
+       # We found the default executable, but exeext='' is most
+       # certainly right.
+       break;;
+     *.* )
+-      ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-      # FIXME: I believe we export ac_cv_exeext for Libtool,
+-      # but it would be cool to find out if it's true.  Does anybody
+-      # maintain Libtool? --akim.
+-      export ac_cv_exeext
++        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
++      then :; else
++         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
++      fi
++      # We set ac_cv_exeext here because the later test for it is not
++      # safe: cross compilers may not add the suffix if given an `-o'
++      # argument, so we may need to know it at that point already.
++      # Even if this section looks crufty: it has the advantage of
++      # actually working.
+       break;;
+     * )
+       break;;
+   esac
+ done
++test "$ac_cv_exeext" = no && ac_cv_exeext=
++
+ else
++  ac_file=''
++fi
++
++{ echo "$as_me:$LINENO: result: $ac_file" >&5
++echo "${ECHO_T}$ac_file" >&6; }
++if test -z "$ac_file"; then
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+@@ -1833,19 +2408,21 @@ See \`config.log' for more details." >&2
+ fi
+ ac_exeext=$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_file" >&5
+-echo "${ECHO_T}$ac_file" >&6
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether the C compiler works" >&5
+-echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether the C compiler works" >&5
++echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6; }
+ # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
+ # If not cross compiling, check that we can run a simple program.
+ if test "$cross_compiling" != yes; then
+   if { ac_try='./$ac_file'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -1864,22 +2441,27 @@ See \`config.log' for more details." >&2
+     fi
+   fi
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ rm -f a.out a.exe conftest$ac_cv_exeext b.out
+ ac_clean_files=$ac_clean_files_save
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
+-echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
+-echo "$as_me:$LINENO: result: $cross_compiling" >&5
+-echo "${ECHO_T}$cross_compiling" >&6
+-
+-echo "$as_me:$LINENO: checking for suffix of executables" >&5
+-echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
++echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }
++{ echo "$as_me:$LINENO: result: $cross_compiling" >&5
++echo "${ECHO_T}$cross_compiling" >&6; }
++
++{ echo "$as_me:$LINENO: checking for suffix of executables" >&5
++echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+@@ -1890,9 +2472,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_l
+ for ac_file in conftest.exe conftest conftest.*; do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
+     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-        export ac_cv_exeext
+         break;;
+     * ) break;;
+   esac
+@@ -1906,14 +2487,14 @@ See \`config.log' for more details." >&2
+ fi
+ rm -f conftest$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
+-echo "${ECHO_T}$ac_cv_exeext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
++echo "${ECHO_T}$ac_cv_exeext" >&6; }
+ rm -f conftest.$ac_ext
+ EXEEXT=$ac_cv_exeext
+ ac_exeext=$EXEEXT
+-echo "$as_me:$LINENO: checking for suffix of object files" >&5
+-echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for suffix of object files" >&5
++echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }
+ if test "${ac_cv_objext+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1933,14 +2514,20 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.o conftest.obj
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>&5
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
++  for ac_file in conftest.o conftest.obj conftest.*; do
++  test -f "$ac_file" || continue;
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;
+     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+        break;;
+   esac
+@@ -1958,12 +2545,12 @@ fi
+ rm -f conftest.$ac_cv_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
+-echo "${ECHO_T}$ac_cv_objext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
++echo "${ECHO_T}$ac_cv_objext" >&6; }
+ OBJEXT=$ac_cv_objext
+ ac_objext=$OBJEXT
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+ if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1986,50 +2573,49 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+ GCC=`test $ac_compiler_gnu = yes && echo yes`
+ ac_test_CFLAGS=${CFLAGS+set}
+ ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -2045,38 +2631,118 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
++
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
+ if test "$ac_test_CFLAGS" = set; then
+   CFLAGS=$ac_save_CFLAGS
+ elif test $ac_cv_prog_cc_g = yes; then
+@@ -2092,12 +2758,12 @@ else
+     CFLAGS=
+   fi
+ fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_prog_cc_stdc=no
++  ac_cv_prog_cc_c89=no
+ ac_save_CC=$CC
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -2131,12 +2797,17 @@ static char *f (char * (*g) (char **, in
+ /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+    function prototypes and stuff, but not '\xHH' hex character constants.
+    These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
++   as 'x'.  The following induces an error, until -std is added to get
+    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+    array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
++   that's true only with -std.  */
+ int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
+ int test (int i, double x);
+ struct s1 {int (*f) (int a);};
+ struct s2 {int (*f) (double a);};
+@@ -2151,335 +2822,144 @@ return f (e, argv, 0) != argv[0]  ||  f 
+   return 0;
+ }
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+ do
+   CC="$ac_save_CC $ac_arg"
+   rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext
++
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+-rm -f conftest.$ac_ext conftest.$ac_objext
++rm -f conftest.$ac_ext
+ CC=$ac_save_CC
+ fi
+-
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
+   *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
+ esac
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
++
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
++
++
++{ echo "$as_me:$LINENO: checking for library containing strerror" >&5
++echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6; }
++if test "${ac_cv_search_strerror+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_func_search_save_LIBS=$LIBS
+ cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
++
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
++#ifdef __cplusplus
++extern "C"
++#endif
++char strerror ();
+ int
+ main ()
+ {
+-exit (42);
++return strerror ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++for ac_lib in '' cposix; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_strerror=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
+-fi
+-
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_strerror+set}" = set; then
++  break
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+-
+-echo "$as_me:$LINENO: checking for library containing strerror" >&5
+-echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6
++done
+ if test "${ac_cv_search_strerror+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_strerror=no
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="none required"
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_strerror" = no; then
+-  for ac_lib in cposix; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="-l$ac_lib"
+-break
++  :
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++  ac_cv_search_strerror=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
+-echo "${ECHO_T}$ac_cv_search_strerror" >&6
+-if test "$ac_cv_search_strerror" != no; then
+-  test "$ac_cv_search_strerror" = "none required" || LIBS="$ac_cv_search_strerror $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
++echo "${ECHO_T}$ac_cv_search_strerror" >&6; }
++ac_res=$ac_cv_search_strerror
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+@@ -2499,8 +2979,8 @@ am__api_version="1.9"
+ # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+ # OS/2's system install, which has a completely different semantic
+ # ./install, which can be erroneously created by make from ./install.sh.
+-echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+-echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+ if test -z "$INSTALL"; then
+ if test "${ac_cv_path_install+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -2522,7 +3002,7 @@ case $as_dir/ in
+     # by default.
+     for ac_prog in ginstall scoinst install; do
+       for ac_exec_ext in '' $ac_executable_extensions; do
+-      if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
++      if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+         if test $ac_prog = install &&
+           grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+           # AIX install.  It has an incompatible calling convention.
+@@ -2541,21 +3021,22 @@ case $as_dir/ in
+     ;;
+ esac
+ done
++IFS=$as_save_IFS
+ fi
+   if test "${ac_cv_path_install+set}" = set; then
+     INSTALL=$ac_cv_path_install
+   else
+-    # As a last resort, use the slow shell script.  We don't cache a
+-    # path for INSTALL within a source directory, because that will
++    # As a last resort, use the slow shell script.  Don't cache a
++    # value for INSTALL within a source directory, because that will
+     # break other packages using the cache if that directory is
+-    # removed, or if the path is relative.
++    # removed, or if the value is a relative name.
+     INSTALL=$ac_install_sh
+   fi
+ fi
+-echo "$as_me:$LINENO: result: $INSTALL" >&5
+-echo "${ECHO_T}$INSTALL" >&6
++{ echo "$as_me:$LINENO: result: $INSTALL" >&5
++echo "${ECHO_T}$INSTALL" >&6; }
+ # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+ # It thinks the first close brace ends the variable substitution.
+@@ -2565,8 +3046,8 @@ test -z "$INSTALL_SCRIPT" && INSTALL_SCR
+ test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+-echo "$as_me:$LINENO: checking whether build environment is sane" >&5
+-echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether build environment is sane" >&5
++echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6; }
+ # Just in case
+ sleep 1
+ echo timestamp > conftest.file
+@@ -2608,20 +3089,20 @@ echo "$as_me: error: newly created file 
+ Check your system clock" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ test "$program_prefix" != NONE &&
+-  program_transform_name="s,^,$program_prefix,;$program_transform_name"
++  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+ # Use a double $ so make ignores it.
+ test "$program_suffix" != NONE &&
+-  program_transform_name="s,\$,$program_suffix,;$program_transform_name"
++  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+ # Double any \ or $.  echo might interpret backslashes.
+ # By default was `s,x,x', remove it if useless.
+ cat <<\_ACEOF >conftest.sed
+ s/[\\$]/&&/g;s/;s,x,x,$//
+ _ACEOF
+ program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
+-rm conftest.sed
++rm -f conftest.sed
+ # expand $ac_aux_dir to an absolute path
+ am_aux_dir=`cd $ac_aux_dir && pwd`
+@@ -2673,8 +3154,8 @@ for ac_prog in gawk mawk nawk awk
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_AWK+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2687,54 +3168,57 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_AWK="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ AWK=$ac_cv_prog_AWK
+ if test -n "$AWK"; then
+-  echo "$as_me:$LINENO: result: $AWK" >&5
+-echo "${ECHO_T}$AWK" >&6
++  { echo "$as_me:$LINENO: result: $AWK" >&5
++echo "${ECHO_T}$AWK" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$AWK" && break
+ done
+-echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+-echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
+-set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
+-if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
++echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6; }
++set x ${MAKE-make}; ac_make=`echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
++if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.make <<\_ACEOF
++SHELL = /bin/sh
+ all:
+-      @echo 'ac_maketemp="$(MAKE)"'
++      @echo '@@@%%%=$(MAKE)=@@@%%%'
+ _ACEOF
+ # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
+-eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
+-if test -n "$ac_maketemp"; then
+-  eval ac_cv_prog_make_${ac_make}_set=yes
+-else
+-  eval ac_cv_prog_make_${ac_make}_set=no
+-fi
++case `${MAKE-make} -f conftest.make 2>/dev/null` in
++  *@@@%%%=?*=@@@%%%*)
++    eval ac_cv_prog_make_${ac_make}_set=yes;;
++  *)
++    eval ac_cv_prog_make_${ac_make}_set=no;;
++esac
+ rm -f conftest.make
+ fi
+-if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+   SET_MAKE=
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+   SET_MAKE="MAKE=${MAKE-make}"
+ fi
+@@ -2749,7 +3233,7 @@ rmdir .tst 2>/dev/null
+ DEPDIR="${am__leading_dot}deps"
+-          ac_config_commands="$ac_config_commands depfiles"
++ac_config_commands="$ac_config_commands depfiles"
+ am_make=${MAKE-make}
+@@ -2759,8 +3243,8 @@ am__doit:
+ .PHONY: am__doit
+ END
+ # If we don't find an include directive, just comment out the code.
+-echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
+-echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
++echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6; }
+ am__include="#"
+ am__quote=
+ _am_result=none
+@@ -2787,15 +3271,15 @@ if test "$am__include" = "#"; then
+ fi
+-echo "$as_me:$LINENO: result: $_am_result" >&5
+-echo "${ECHO_T}$_am_result" >&6
++{ echo "$as_me:$LINENO: result: $_am_result" >&5
++echo "${ECHO_T}$_am_result" >&6; }
+ rm -f confinc confmf
+-# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
++# Check whether --enable-dependency-tracking was given.
+ if test "${enable_dependency_tracking+set}" = set; then
+-  enableval="$enable_dependency_tracking"
++  enableval=$enable_dependency_tracking;
++fi
+-fi;
+ if test "x$enable_dependency_tracking" != xno; then
+   am_depcomp="$ac_aux_dir/depcomp"
+   AMDEPBACKSLASH='\'
+@@ -2870,8 +3354,8 @@ if test "$cross_compiling" != no; then
+   if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2884,32 +3368,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2922,27 +3408,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -2963,8 +3463,8 @@ am__tar='${AMTAR} chof - "$$tardir"'; am
+ depcc="$CC"   am_compiler_list=
+-echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
+-echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
++echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; }
+ if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3053,8 +3553,8 @@ else
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
+-echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
++echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; }
+ CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+@@ -3072,10 +3572,9 @@ fi
+-# Check whether --enable-shared or --disable-shared was given.
++# Check whether --enable-shared was given.
+ if test "${enable_shared+set}" = set; then
+-  enableval="$enable_shared"
+-  p=${PACKAGE-default}
++  enableval=$enable_shared; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_shared=yes ;;
+ no) enable_shared=no ;;
+@@ -3093,11 +3592,11 @@ no) enable_shared=no ;;
+ esac
+ else
+   enable_shared=yes
+-fi;
+-# Check whether --enable-static or --disable-static was given.
++fi
++
++# Check whether --enable-static was given.
+ if test "${enable_static+set}" = set; then
+-  enableval="$enable_static"
+-  p=${PACKAGE-default}
++  enableval=$enable_static; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_static=yes ;;
+ no) enable_static=no ;;
+@@ -3115,11 +3614,11 @@ no) enable_static=no ;;
+ esac
+ else
+   enable_static=yes
+-fi;
+-# Check whether --enable-fast-install or --disable-fast-install was given.
++fi
++
++# Check whether --enable-fast-install was given.
+ if test "${enable_fast_install+set}" = set; then
+-  enableval="$enable_fast_install"
+-  p=${PACKAGE-default}
++  enableval=$enable_fast_install; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_fast_install=yes ;;
+ no) enable_fast_install=no ;;
+@@ -3137,20 +3636,21 @@ no) enable_fast_install=no ;;
+ esac
+ else
+   enable_fast_install=yes
+-fi;
++fi
++
+-# Check whether --with-gnu-ld or --without-gnu-ld was given.
++# Check whether --with-gnu-ld was given.
+ if test "${with_gnu_ld+set}" = set; then
+-  withval="$with_gnu_ld"
+-  test "$withval" = no || with_gnu_ld=yes
++  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+ else
+   with_gnu_ld=no
+-fi;
++fi
++
+ ac_prog=ld
+ if test "$GCC" = yes; then
+   # Check if gcc -print-prog-name=ld gives a path.
+-  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
+-echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for ld used by GCC" >&5
++echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6; }
+   case $host in
+   *-*-mingw*)
+     # gcc leaves a trailing carriage return which upsets mingw
+@@ -3179,11 +3679,11 @@ echo $ECHO_N "checking for ld used by GC
+     ;;
+   esac
+ elif test "$with_gnu_ld" = yes; then
+-  echo "$as_me:$LINENO: checking for GNU ld" >&5
+-echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for GNU ld" >&5
++echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6; }
+ else
+-  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
+-echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for non-GNU ld" >&5
++echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6; }
+ fi
+ if test "${lt_cv_path_LD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -3212,17 +3712,17 @@ fi
+ LD="$lt_cv_path_LD"
+ if test -n "$LD"; then
+-  echo "$as_me:$LINENO: result: $LD" >&5
+-echo "${ECHO_T}$LD" >&6
++  { echo "$as_me:$LINENO: result: $LD" >&5
++echo "${ECHO_T}$LD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
+ echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
+-echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
++echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6; }
+ if test "${lt_cv_prog_gnu_ld+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3233,25 +3733,25 @@ else
+   lt_cv_prog_gnu_ld=no
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
+-echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
++echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6; }
+ with_gnu_ld=$lt_cv_prog_gnu_ld
+-echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
+-echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
++echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6; }
+ if test "${lt_cv_ld_reload_flag+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   lt_cv_ld_reload_flag='-r'
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
+-echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
++echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6; }
+ reload_flag=$lt_cv_ld_reload_flag
+ test -n "$reload_flag" && reload_flag=" $reload_flag"
+-echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
+-echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
++echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6; }
+ if test "${lt_cv_path_NM+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3286,22 +3786,22 @@ fi
+ fi
+ NM="$lt_cv_path_NM"
+-echo "$as_me:$LINENO: result: $NM" >&5
+-echo "${ECHO_T}$NM" >&6
++{ echo "$as_me:$LINENO: result: $NM" >&5
++echo "${ECHO_T}$NM" >&6; }
+-echo "$as_me:$LINENO: checking whether ln -s works" >&5
+-echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether ln -s works" >&5
++echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6; }
+ LN_S=$as_ln_s
+ if test "$LN_S" = "ln -s"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
+-echo "${ECHO_T}no, using $LN_S" >&6
++  { echo "$as_me:$LINENO: result: no, using $LN_S" >&5
++echo "${ECHO_T}no, using $LN_S" >&6; }
+ fi
+-echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
+-echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
++echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6; }
+ if test "${lt_cv_deplibs_check_method+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3463,8 +3963,8 @@ sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+ esac
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
+-echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
++echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6; }
+ file_magic_cmd=$lt_cv_file_magic_cmd
+ deplibs_check_method=$lt_cv_deplibs_check_method
+@@ -3474,8 +3974,8 @@ deplibs_check_method=$lt_cv_deplibs_chec
+ # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
+ # find the maximum length of command line arguments
+-echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
+-echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
++echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6; }
+ if test "${lt_cv_sys_max_cmd_len+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3526,11 +4026,11 @@ else
+ fi
+ if test -n "$lt_cv_sys_max_cmd_len" ; then
+-  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
+-echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
++  { echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
++echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: none" >&5
+-echo "${ECHO_T}none" >&6
++  { echo "$as_me:$LINENO: result: none" >&5
++echo "${ECHO_T}none" >&6; }
+ fi
+@@ -3538,8 +4038,8 @@ fi
+ case $deplibs_check_method in
+ file_magic*)
+   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+-    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
+-echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
++echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3593,17 +4093,17 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ if test -z "$lt_cv_path_MAGIC_CMD"; then
+   if test -n "$ac_tool_prefix"; then
+-    echo "$as_me:$LINENO: checking for file" >&5
+-echo $ECHO_N "checking for file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for file" >&5
++echo $ECHO_N "checking for file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3657,11 +4157,11 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+   else
+@@ -3676,8 +4176,8 @@ esac
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3690,32 +4190,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3728,27 +4230,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -3756,8 +4272,8 @@ fi
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3770,32 +4286,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3808,27 +4326,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -3843,22 +4375,22 @@ test "$GCC" = yes && libtool_flags="$lib
+ test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
+-# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
++# Check whether --enable-libtool-lock was given.
+ if test "${enable_libtool_lock+set}" = set; then
+-  enableval="$enable_libtool_lock"
++  enableval=$enable_libtool_lock;
++fi
+-fi;
+ test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
+ test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
+-# Check whether --with-pic or --without-pic was given.
++# Check whether --with-pic was given.
+ if test "${with_pic+set}" = set; then
+-  withval="$with_pic"
+-  pic_mode="$withval"
++  withval=$with_pic; pic_mode="$withval"
+ else
+   pic_mode=default
+-fi;
++fi
++
+ test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
+ test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
+@@ -3867,7 +4399,7 @@ test x"$pic_mode" = xno && libtool_flags
+ case $host in
+ *-*-irix6*)
+   # Find out which ABI we are using.
+-  echo '#line 3870 "configure"' > conftest.$ac_ext
++  echo '#line 4402 "configure"' > conftest.$ac_ext
+   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+   (eval $ac_compile) 2>&5
+   ac_status=$?
+@@ -3972,13 +4504,12 @@ x86_64-*linux*|ppc*-*linux*|powerpc*-*li
+   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+   SAVE_CFLAGS="$CFLAGS"
+   CFLAGS="$CFLAGS -belf"
+-  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
+-echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
++echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6; }
+ if test "${lt_cv_cc_needs_belf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -4001,35 +4532,32 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   lt_cv_cc_needs_belf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-lt_cv_cc_needs_belf=no
++      lt_cv_cc_needs_belf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+@@ -4038,8 +4566,8 @@ ac_link='$CC -o conftest$ac_exeext $CFLA
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
+-echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
++echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6; }
+   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+     CFLAGS="$SAVE_CFLAGS"
+@@ -4069,39 +4597,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -4127,8 +4674,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -4154,10 +4701,9 @@ exec 5>>./config.log
+-# Check whether --enable-targets or --disable-targets was given.
++# Check whether --enable-targets was given.
+ if test "${enable_targets+set}" = set; then
+-  enableval="$enable_targets"
+-  case "${enableval}" in
++  enableval=$enable_targets; case "${enableval}" in
+   yes | "") { { echo "$as_me:$LINENO: error: enable-targets option must specify target names or 'all'" >&5
+ echo "$as_me: error: enable-targets option must specify target names or 'all'" >&2;}
+    { (exit 1); exit 1; }; }
+@@ -4165,31 +4711,32 @@ echo "$as_me: error: enable-targets opti
+   no)       enable_targets= ;;
+   *)        enable_targets=$enableval ;;
+ esac
+-fi; # Check whether --enable-commonbfdlib or --disable-commonbfdlib was given.
++fi
++# Check whether --enable-commonbfdlib was given.
+ if test "${enable_commonbfdlib+set}" = set; then
+-  enableval="$enable_commonbfdlib"
+-  case "${enableval}" in
++  enableval=$enable_commonbfdlib; case "${enableval}" in
+   yes) commonbfdlib=true ;;
+   no)  commonbfdlib=false ;;
+   *)   { { echo "$as_me:$LINENO: error: bad value ${enableval} for BFD commonbfdlib option" >&5
+ echo "$as_me: error: bad value ${enableval} for BFD commonbfdlib option" >&2;}
+    { (exit 1); exit 1; }; } ;;
+ esac
+-fi;
++fi
++
+ GCC_WARN_CFLAGS="-W -Wall -Wstrict-prototypes -Wmissing-prototypes"
+-# Check whether --enable-werror or --disable-werror was given.
++# Check whether --enable-werror was given.
+ if test "${enable_werror+set}" = set; then
+-  enableval="$enable_werror"
+-  case "${enableval}" in
++  enableval=$enable_werror; case "${enableval}" in
+      yes | y) ERROR_ON_WARNING="yes" ;;
+      no | n)  ERROR_ON_WARNING="no" ;;
+      *) { { echo "$as_me:$LINENO: error: bad value ${enableval} for --enable-werror" >&5
+ echo "$as_me: error: bad value ${enableval} for --enable-werror" >&2;}
+    { (exit 1); exit 1; }; } ;;
+    esac
+-fi;
++fi
++
+ # Enable -Werror by default when using gcc
+ if test "${GCC}" = yes -a -z "${ERROR_ON_WARNING}" ; then
+@@ -4206,10 +4753,9 @@ if test "${GCC}" = yes ; then
+   WARN_CFLAGS="${GCC_WARN_CFLAGS}"
+ fi
+-# Check whether --enable-build-warnings or --disable-build-warnings was given.
++# Check whether --enable-build-warnings was given.
+ if test "${enable_build_warnings+set}" = set; then
+-  enableval="$enable_build_warnings"
+-  case "${enableval}" in
++  enableval=$enable_build_warnings; case "${enableval}" in
+   yes)        WARN_CFLAGS="${GCC_WARN_CFLAGS}";;
+   no) if test "${GCC}" = yes ; then
+         WARN_CFLAGS="-w"
+@@ -4220,7 +4766,8 @@ if test "${enable_build_warnings+set}" =
+         WARN_CFLAGS="${t} ${GCC_WARN_CFLAGS}";;
+   *)    WARN_CFLAGS=`echo "${enableval}" | sed -e "s/,/ /g"`;;
+ esac
+-fi;
++fi
++
+ if test x"$silent" != x"yes" && test x"$WARN_CFLAGS" != x""; then
+   echo "Setting warning flags = $WARN_CFLAGS" 6>&1
+@@ -4230,7 +4777,7 @@ fi
+-          ac_config_headers="$ac_config_headers config.h:config.in"
++ac_config_headers="$ac_config_headers config.h:config.in"
+ if test -z "$target" ; then
+@@ -4252,8 +4799,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4266,32 +4813,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_CC"; then
+   ac_ct_CC=$CC
+   # Extract the first word of "gcc", so it can be a program name with args.
+ set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4304,36 +4853,51 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ else
+   CC="$ac_cv_prog_CC"
+ fi
+ if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4346,74 +4910,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}cc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
+-
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++  fi
+ fi
+ if test -z "$CC"; then
+   # Extract the first word of "cc", so it can be a program name with args.
+ set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4427,7 +4951,7 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+        continue
+@@ -4438,6 +4962,7 @@ do
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ if test $ac_prog_rejected = yes; then
+   # We found a bogon in the path, so make sure we never use it.
+@@ -4455,22 +4980,23 @@ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$CC"; then
+   if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4483,36 +5009,38 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+     test -n "$CC" && break
+   done
+ fi
+ if test -z "$CC"; then
+   ac_ct_CC=$CC
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4525,29 +5053,45 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$ac_ct_CC" && break
+ done
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ fi
+ fi
+@@ -4560,27 +5104,41 @@ See \`config.log' for more details." >&2
+    { (exit 1); exit 1; }; }
+ # Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
++echo "$as_me:$LINENO: checking for C compiler version" >&5
+ ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+ if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4603,50 +5161,49 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+ GCC=`test $ac_compiler_gnu = yes && echo yes`
+ ac_test_CFLAGS=${CFLAGS+set}
+ ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -4662,311 +5219,248 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
+-if test "$ac_test_CFLAGS" = set; then
+-  CFLAGS=$ac_save_CFLAGS
+-elif test $ac_cv_prog_cc_g = yes; then
+-  if test "$GCC" = yes; then
+-    CFLAGS="-g -O2"
+-  else
+-    CFLAGS="-g"
+-  fi
+-else
+-  if test "$GCC" = yes; then
+-    CFLAGS="-O2"
+-  else
+-    CFLAGS=
+-  fi
+-fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_cv_prog_cc_stdc=no
+-ac_save_CC=$CC
+-cat >conftest.$ac_ext <<_ACEOF
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#include <stdarg.h>
+-#include <stdio.h>
+-#include <sys/types.h>
+-#include <sys/stat.h>
+-/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+-struct buf { int x; };
+-FILE * (*rcsopen) (struct buf *, struct stat *, int);
+-static char *e (p, i)
+-     char **p;
+-     int i;
+-{
+-  return p[i];
+-}
+-static char *f (char * (*g) (char **, int), char **p, ...)
+-{
+-  char *s;
+-  va_list v;
+-  va_start (v,p);
+-  s = g (p, va_arg (v,int));
+-  va_end (v);
+-  return s;
+-}
+-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+-   function prototypes and stuff, but not '\xHH' hex character constants.
+-   These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
+-   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+-   array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
+-int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+-
+-int test (int i, double x);
+-struct s1 {int (*f) (int a);};
+-struct s2 {int (*f) (double a);};
+-int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+-int argc;
+-char **argv;
+ int
+ main ()
+ {
+-return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
++
+   ;
+   return 0;
+ }
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+-do
+-  CC="$ac_save_CC $ac_arg"
+-  rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-fi
+-rm -f conftest.err conftest.$ac_objext
+-done
+-rm -f conftest.$ac_ext conftest.$ac_objext
+-CC=$ac_save_CC
+-
+-fi
+-
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
+-  *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
+-esac
+-
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
+-cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
++
+ int
+ main ()
+ {
+-exit (42);
++
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-continue
++
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
++if test "$ac_test_CFLAGS" = set; then
++  CFLAGS=$ac_save_CFLAGS
++elif test $ac_cv_prog_cc_g = yes; then
++  if test "$GCC" = yes; then
++    CFLAGS="-g -O2"
++  else
++    CFLAGS="-g"
++  fi
++else
++  if test "$GCC" = yes; then
++    CFLAGS="-O2"
++  else
++    CFLAGS=
++  fi
++fi
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_cv_prog_cc_c89=no
++ac_save_CC=$CC
++cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-$ac_declaration
++#include <stdarg.h>
++#include <stdio.h>
++#include <sys/types.h>
++#include <sys/stat.h>
++/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
++struct buf { int x; };
++FILE * (*rcsopen) (struct buf *, struct stat *, int);
++static char *e (p, i)
++     char **p;
++     int i;
++{
++  return p[i];
++}
++static char *f (char * (*g) (char **, int), char **p, ...)
++{
++  char *s;
++  va_list v;
++  va_start (v,p);
++  s = g (p, va_arg (v,int));
++  va_end (v);
++  return s;
++}
++
++/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
++   function prototypes and stuff, but not '\xHH' hex character constants.
++   These don't provoke an error unfortunately, instead are silently treated
++   as 'x'.  The following induces an error, until -std is added to get
++   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
++   array size at least.  It's necessary to write '\x00'==0 to get something
++   that's true only with -std.  */
++int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
++int test (int i, double x);
++struct s1 {int (*f) (int a);};
++struct s2 {int (*f) (double a);};
++int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
++int argc;
++char **argv;
+ int
+ main ()
+ {
+-exit (42);
++return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++do
++  CC="$ac_save_CC $ac_arg"
++  rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
++rm -f conftest.$ac_ext
++CC=$ac_save_CC
++
+ fi
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
++  *)
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
++esac
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -4984,8 +5478,8 @@ for ac_prog in 'bison -y' byacc
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_YACC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4998,25 +5492,27 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_YACC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ YACC=$ac_cv_prog_YACC
+ if test -n "$YACC"; then
+-  echo "$as_me:$LINENO: result: $YACC" >&5
+-echo "${ECHO_T}$YACC" >&6
++  { echo "$as_me:$LINENO: result: $YACC" >&5
++echo "${ECHO_T}$YACC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$YACC" && break
+ done
+ test -n "$YACC" || YACC="yacc"
+@@ -5025,8 +5521,8 @@ for ac_prog in flex lex
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_LEX+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5039,253 +5535,182 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_LEX="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ LEX=$ac_cv_prog_LEX
+ if test -n "$LEX"; then
+-  echo "$as_me:$LINENO: result: $LEX" >&5
+-echo "${ECHO_T}$LEX" >&6
++  { echo "$as_me:$LINENO: result: $LEX" >&5
++echo "${ECHO_T}$LEX" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$LEX" && break
+ done
+ test -n "$LEX" || LEX=":"
+-if test -z "$LEXLIB"
+-then
+-  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
+-echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
+-if test "${ac_cv_lib_fl_yywrap+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
+-LIBS="-lfl  $LIBS"
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
++if test "x$LEX" != "x:"; then
++  cat >conftest.l <<_ACEOF
++%%
++a { ECHO; }
++b { REJECT; }
++c { yymore (); }
++d { yyless (1); }
++e { yyless (input () != 0); }
++f { unput (yytext[0]); }
++. { BEGIN INITIAL; }
++%%
++#ifdef YYTEXT_POINTER
++extern char *yytext;
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char yywrap ();
+ int
+-main ()
++main (void)
+ {
+-yywrap ();
+-  ;
+-  return 0;
++  return ! yylex () + ! yywrap ();
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++{ (ac_try="$LEX conftest.l"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$LEX conftest.l") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_lib_fl_yywrap=yes
++  (exit $ac_status); }
++{ echo "$as_me:$LINENO: checking lex output file root" >&5
++echo $ECHO_N "checking lex output file root... $ECHO_C" >&6; }
++if test "${ac_cv_prog_lex_root+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_fl_yywrap=no
++if test -f lex.yy.c; then
++  ac_cv_prog_lex_root=lex.yy
++elif test -f lexyy.c; then
++  ac_cv_prog_lex_root=lexyy
++else
++  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
++echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
++   { (exit 1); exit 1; }; }
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
+-echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
+-if test $ac_cv_lib_fl_yywrap = yes; then
+-  LEXLIB="-lfl"
+-else
+-  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
+-echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
+-if test "${ac_cv_lib_l_yywrap+set}" = set; then
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
++echo "${ECHO_T}$ac_cv_prog_lex_root" >&6; }
++LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
++
++if test -z "${LEXLIB+set}"; then
++  { echo "$as_me:$LINENO: checking lex library" >&5
++echo $ECHO_N "checking lex library... $ECHO_C" >&6; }
++if test "${ac_cv_lib_lex+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_check_lib_save_LIBS=$LIBS
+-LIBS="-ll  $LIBS"
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char yywrap ();
+-int
+-main ()
+-{
+-yywrap ();
+-  ;
+-  return 0;
+-}
++    ac_save_LIBS=$LIBS
++    ac_cv_lib_lex='none needed'
++    for ac_lib in '' -lfl -ll; do
++      LIBS="$ac_lib $ac_save_LIBS"
++      cat >conftest.$ac_ext <<_ACEOF
++`cat $LEX_OUTPUT_ROOT.c`
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_lib_l_yywrap=yes
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_lib_lex=$ac_lib
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_l_yywrap=no
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
+-echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
+-if test $ac_cv_lib_l_yywrap = yes; then
+-  LEXLIB="-ll"
+-fi
+-
+-fi
+-
+-fi
+-if test "x$LEX" != "x:"; then
+-  echo "$as_me:$LINENO: checking lex output file root" >&5
+-echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
+-if test "${ac_cv_prog_lex_root+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  # The minimal lex program is just a single line: %%.  But some broken lexes
+-# (Solaris, I think it was) want two %% lines, so accommodate them.
+-cat >conftest.l <<_ACEOF
+-%%
+-%%
+-_ACEOF
+-{ (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
+-  (eval $LEX conftest.l) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }
+-if test -f lex.yy.c; then
+-  ac_cv_prog_lex_root=lex.yy
+-elif test -f lexyy.c; then
+-  ac_cv_prog_lex_root=lexyy
+-else
+-  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
+-echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
+-   { (exit 1); exit 1; }; }
+ fi
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext conftest.$ac_ext
++      test "$ac_cv_lib_lex" != 'none needed' && break
++    done
++    LIBS=$ac_save_LIBS
++
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_lex" >&5
++echo "${ECHO_T}$ac_cv_lib_lex" >&6; }
++  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
+-echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
+-rm -f conftest.l
+-LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
+-echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
+-echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
++
++{ echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
++echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   # POSIX says lex can declare yytext either as a pointer or an array; the
+-# default is implementation-dependent. Figure out which it is, since
++# default is implementation-dependent.  Figure out which it is, since
+ # not all implementations provide the %pointer and %array declarations.
+ ac_cv_prog_lex_yytext_pointer=no
+-echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
+ ac_save_LIBS=$LIBS
+-LIBS="$LIBS $LEXLIB"
++LIBS="$LEXLIB $ac_save_LIBS"
+ cat >conftest.$ac_ext <<_ACEOF
++#define YYTEXT_POINTER 1
+ `cat $LEX_OUTPUT_ROOT.c`
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_prog_lex_yytext_pointer=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_save_LIBS
+-rm -f "${LEX_OUTPUT_ROOT}.c"
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
+-echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
++echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6; }
+ if test $ac_cv_prog_lex_yytext_pointer = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -5293,6 +5718,7 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+ fi
++rm -f conftest.l $LEX_OUTPUT_ROOT.c
+ fi
+ if test "$LEX" = :; then
+@@ -5303,8 +5729,8 @@ ALL_LINGUAS="fr tr ja es sv da zh_CN ru 
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5317,32 +5743,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5355,27 +5783,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -5385,8 +5827,8 @@ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
+-echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
++echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }
+ # On Suns, sometimes $CPP names a directory.
+ if test -n "$CPP" && test -d "$CPP"; then
+   CPP=
+@@ -5420,24 +5862,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #endif
+                    Syntax error
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   :
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -5446,9 +5886,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   # Broken: fails on valid input.
+ continue
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
++  # OK, works on sane cases.  Now check whether nonexistent headers
+   # can be detected and how.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -5458,24 +5899,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   # Broken: success on invalid input.
+ continue
+ else
+@@ -5486,6 +5925,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ac_preproc_ok=:
+ break
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+ done
+@@ -5503,8 +5943,8 @@ fi
+ else
+   ac_cv_prog_CPP=$CPP
+ fi
+-echo "$as_me:$LINENO: result: $CPP" >&5
+-echo "${ECHO_T}$CPP" >&6
++{ echo "$as_me:$LINENO: result: $CPP" >&5
++echo "${ECHO_T}$CPP" >&6; }
+ ac_preproc_ok=false
+ for ac_c_preproc_warn_flag in '' yes
+ do
+@@ -5527,24 +5967,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #endif
+                    Syntax error
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   :
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -5553,9 +5991,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   # Broken: fails on valid input.
+ continue
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
++  # OK, works on sane cases.  Now check whether nonexistent headers
+   # can be detected and how.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -5565,24 +6004,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   # Broken: success on invalid input.
+ continue
+ else
+@@ -5593,6 +6030,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ac_preproc_ok=:
+ break
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+ done
+@@ -5615,23 +6053,170 @@ ac_link='$CC -o conftest$ac_exeext $CFLA
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-echo "$as_me:$LINENO: checking for egrep" >&5
+-echo $ECHO_N "checking for egrep... $ECHO_C" >&6
+-if test "${ac_cv_prog_egrep+set}" = set; then
++{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
++echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }
++if test "${ac_cv_path_GREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  # Extract the first word of "grep ggrep" to use in msg output
++if test -z "$GREP"; then
++set dummy grep ggrep; ac_prog_name=$2
++if test "${ac_cv_path_GREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_path_GREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in grep ggrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
++    # Check for GNU ac_path_GREP and select it if it is found.
++  # Check for GNU $ac_path_GREP
++case `"$ac_path_GREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'GREP' >> "conftest.nl"
++    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_GREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_GREP="$ac_path_GREP"
++      ac_path_GREP_max=$ac_count
++    fi
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
++
++
++    $ac_path_GREP_found && break 3
++  done
++done
++
++done
++IFS=$as_save_IFS
++
++
++fi
++
++GREP="$ac_cv_path_GREP"
++if test -z "$GREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
++
++else
++  ac_cv_path_GREP=$GREP
++fi
++
++
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
++echo "${ECHO_T}$ac_cv_path_GREP" >&6; }
++ GREP="$ac_cv_path_GREP"
++
++
++{ echo "$as_me:$LINENO: checking for egrep" >&5
++echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }
++if test "${ac_cv_path_EGREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
++   then ac_cv_path_EGREP="$GREP -E"
++   else
++     # Extract the first word of "egrep" to use in msg output
++if test -z "$EGREP"; then
++set dummy egrep; ac_prog_name=$2
++if test "${ac_cv_path_EGREP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
+-    then ac_cv_prog_egrep='grep -E'
+-    else ac_cv_prog_egrep='egrep'
++  ac_path_EGREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in egrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
++    # Check for GNU ac_path_EGREP and select it if it is found.
++  # Check for GNU $ac_path_EGREP
++case `"$ac_path_EGREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'EGREP' >> "conftest.nl"
++    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_EGREP="$ac_path_EGREP"
++      ac_path_EGREP_max=$ac_count
+     fi
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
++
++
++    $ac_path_EGREP_found && break 3
++  done
++done
++
++done
++IFS=$as_save_IFS
++
++
++fi
++
++EGREP="$ac_cv_path_EGREP"
++if test -z "$EGREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
++
++else
++  ac_cv_path_EGREP=$EGREP
++fi
++
++
++   fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
+-echo "${ECHO_T}$ac_cv_prog_egrep" >&6
+- EGREP=$ac_cv_prog_egrep
++{ echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
++echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }
++ EGREP="$ac_cv_path_EGREP"
+-echo "$as_me:$LINENO: checking for ANSI C header files" >&5
+-echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for ANSI C header files" >&5
++echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
+ if test "${ac_cv_header_stdc+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5655,35 +6240,31 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_header_stdc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_header_stdc=no
++      ac_cv_header_stdc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ if test $ac_cv_header_stdc = yes; then
+   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+@@ -5739,6 +6320,7 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ctype.h>
++#include <stdlib.h>
+ #if ((' ' & 0x0FF) == 0x020)
+ # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+ # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+@@ -5758,18 +6340,27 @@ main ()
+   for (i = 0; i < 256; i++)
+     if (XOR (islower (i), ISLOWER (i))
+       || toupper (i) != TOUPPER (i))
+-      exit(2);
+-  exit (0);
++      return 2;
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -5782,12 +6373,14 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_header_stdc=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
+-echo "${ECHO_T}$ac_cv_header_stdc" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
++echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
+ if test $ac_cv_header_stdc = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -5796,8 +6389,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
+-echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
++echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; }
+ if test "${ac_cv_c_const+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5815,10 +6408,10 @@ main ()
+ #ifndef __cplusplus
+   /* Ultrix mips cc rejects this.  */
+   typedef int charset[2];
+-  const charset x;
++  const charset cs;
+   /* SunOS 4.1.1 cc rejects this.  */
+-  char const *const *ccp;
+-  char **p;
++  char const *const *pcpcc;
++  char **ppc;
+   /* NEC SVR4.0.2 mips cc rejects this.  */
+   struct point {int x, y;};
+   static struct point const zero = {0,0};
+@@ -5827,16 +6420,17 @@ main ()
+      an arm of an if-expression whose if-part is not a constant
+      expression */
+   const char *g = "string";
+-  ccp = &g + (g ? g-g : 0);
++  pcpcc = &g + (g ? g-g : 0);
+   /* HPUX 7.0 cc rejects these. */
+-  ++ccp;
+-  p = (char**) ccp;
+-  ccp = (char const *const *) p;
++  ++pcpcc;
++  ppc = (char**) pcpcc;
++  pcpcc = (char const *const *) ppc;
+   { /* SCO 3.2v4 cc rejects this.  */
+     char *t;
+     char const *s = 0 ? (char *) 0 : (char const *) 0;
+     *t++ = 0;
++    if (s) return 0;
+   }
+   { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+     int x[] = {25, 17};
+@@ -5855,7 +6449,9 @@ main ()
+   }
+   { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+     const int foo = 10;
++    if (!foo) return 0;
+   }
++  return !cs[0] && !zero.x;
+ #endif
+   ;
+@@ -5863,38 +6459,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_c_const=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_c_const=no
++      ac_cv_c_const=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
+-echo "${ECHO_T}$ac_cv_c_const" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
++echo "${ECHO_T}$ac_cv_c_const" >&6; }
+ if test $ac_cv_c_const = no; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -5903,8 +6495,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for inline" >&5
+-echo $ECHO_N "checking for inline... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for inline" >&5
++echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
+ if test "${ac_cv_c_inline+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5924,39 +6516,37 @@ $ac_kw foo_t foo () {return 0; }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_c_inline=$ac_kw; break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_c_inline=$ac_kw
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++  test "$ac_cv_c_inline" != no && break
+ done
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
+-echo "${ECHO_T}$ac_cv_c_inline" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
++echo "${ECHO_T}$ac_cv_c_inline" >&6; }
+ case $ac_cv_c_inline in
+@@ -5988,9 +6578,9 @@ for ac_header in sys/types.h sys/stat.h 
+                 inttypes.h stdint.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6004,38 +6594,35 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   eval "$as_ac_Header=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_Header=no"
++      eval "$as_ac_Header=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+@@ -6046,8 +6633,8 @@ fi
+ done
+-echo "$as_me:$LINENO: checking for off_t" >&5
+-echo $ECHO_N "checking for off_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for off_t" >&5
++echo $ECHO_N "checking for off_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_off_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6058,62 +6645,59 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef off_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((off_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (off_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_off_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_off_t=no
++      ac_cv_type_off_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
+-echo "${ECHO_T}$ac_cv_type_off_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
++echo "${ECHO_T}$ac_cv_type_off_t" >&6; }
+ if test $ac_cv_type_off_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define off_t long
++#define off_t long int
+ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for size_t" >&5
+-echo $ECHO_N "checking for size_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for size_t" >&5
++echo $ECHO_N "checking for size_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_size_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6124,64 +6708,61 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef size_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((size_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (size_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_size_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_size_t=no
++      ac_cv_type_size_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
+-echo "${ECHO_T}$ac_cv_type_size_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
++echo "${ECHO_T}$ac_cv_type_size_t" >&6; }
+ if test $ac_cv_type_size_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define size_t unsigned
++#define size_t unsigned int
+ _ACEOF
+ fi
+ # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+ # for constant arguments.  Useless!
+-echo "$as_me:$LINENO: checking for working alloca.h" >&5
+-echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working alloca.h" >&5
++echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6; }
+ if test "${ac_cv_working_alloca_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6196,44 +6777,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (2 * sizeof (int));
++                        if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_working_alloca_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_working_alloca_h=no
++      ac_cv_working_alloca_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
+-echo "${ECHO_T}$ac_cv_working_alloca_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
++echo "${ECHO_T}$ac_cv_working_alloca_h" >&6; }
+ if test $ac_cv_working_alloca_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -6242,8 +6821,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for alloca" >&5
+-echo $ECHO_N "checking for alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for alloca" >&5
++echo $ECHO_N "checking for alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_func_alloca_works+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6260,7 +6839,7 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #  include <malloc.h>
+ #  define alloca _alloca
+ # else
+-#  if HAVE_ALLOCA_H
++#  ifdef HAVE_ALLOCA_H
+ #   include <alloca.h>
+ #  else
+ #   ifdef _AIX
+@@ -6278,44 +6857,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (1);
++                                  if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_func_alloca_works=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_func_alloca_works=no
++      ac_cv_func_alloca_works=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
+-echo "${ECHO_T}$ac_cv_func_alloca_works" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
++echo "${ECHO_T}$ac_cv_func_alloca_works" >&6; }
+ if test $ac_cv_func_alloca_works = yes; then
+@@ -6329,15 +6906,15 @@ else
+ # contain a buggy version.  If you still want to use their alloca,
+ # use ar to extract alloca.o from them instead of compiling alloca.c.
+-ALLOCA=alloca.$ac_objext
++ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
+ cat >>confdefs.h <<\_ACEOF
+ #define C_ALLOCA 1
+ _ACEOF
+-echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
+-echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
++echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6; }
+ if test "${ac_cv_os_cray+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6347,7 +6924,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#if defined(CRAY) && ! defined(CRAY2)
++#if defined CRAY && ! defined CRAY2
+ webecray
+ #else
+ wenotbecray
+@@ -6363,14 +6940,14 @@ fi
+ rm -f conftest*
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
+-echo "${ECHO_T}$ac_cv_os_cray" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
++echo "${ECHO_T}$ac_cv_os_cray" >&6; }
+ if test $ac_cv_os_cray = yes; then
+   for ac_func in _getb67 GETB67 getb67; do
+     as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6396,68 +6973,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -6470,8 +7039,8 @@ fi
+   done
+ fi
+-echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
+-echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
++echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_c_stack_direction+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6484,6 +7053,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
++$ac_includes_default
+ int
+ find_stack_direction ()
+ {
+@@ -6501,17 +7071,26 @@ find_stack_direction ()
+ int
+ main ()
+ {
+-  exit (find_stack_direction () < 0);
++  return find_stack_direction () < 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -6524,11 +7103,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_c_stack_direction=-1
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
+-echo "${ECHO_T}$ac_cv_c_stack_direction" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
++echo "${ECHO_T}$ac_cv_c_stack_direction" >&6; }
+ cat >>confdefs.h <<_ACEOF
+ #define STACK_DIRECTION $ac_cv_c_stack_direction
+@@ -6542,18 +7123,19 @@ fi
+ for ac_header in stdlib.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6564,41 +7146,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6607,24 +7185,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -6632,9 +7208,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -6658,25 +7235,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -6692,9 +7263,9 @@ done
+ for ac_func in getpagesize
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6720,68 +7291,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -6790,8 +7353,8 @@ _ACEOF
+ fi
+ done
+-echo "$as_me:$LINENO: checking for working mmap" >&5
+-echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working mmap" >&5
++echo $ECHO_N "checking for working mmap... $ECHO_C" >&6; }
+ if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6833,21 +7396,21 @@ $ac_includes_default
+ #include <fcntl.h>
+ #include <sys/mman.h>
+-#if !STDC_HEADERS && !HAVE_STDLIB_H
++#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H
+ char *malloc ();
+ #endif
+ /* This mess was copied from the GNU getpagesize.h.  */
+-#if !HAVE_GETPAGESIZE
++#ifndef HAVE_GETPAGESIZE
+ /* Assume that all systems that can run configure have sys/param.h.  */
+-# if !HAVE_SYS_PARAM_H
++# ifndef HAVE_SYS_PARAM_H
+ #  define HAVE_SYS_PARAM_H 1
+ # endif
+ # ifdef _SC_PAGESIZE
+ #  define getpagesize() sysconf(_SC_PAGESIZE)
+ # else /* no _SC_PAGESIZE */
+-#  if HAVE_SYS_PARAM_H
++#  ifdef HAVE_SYS_PARAM_H
+ #   include <sys/param.h>
+ #   ifdef EXEC_PAGESIZE
+ #    define getpagesize() EXEC_PAGESIZE
+@@ -6886,15 +7449,15 @@ main ()
+   /* First, make a file with some known garbage in it. */
+   data = (char *) malloc (pagesize);
+   if (!data)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     *(data + i) = rand ();
+   umask (0);
+   fd = creat ("conftest.mmap", 0600);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   if (write (fd, data, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   close (fd);
+   /* Next, try to mmap the file at a fixed address which already has
+@@ -6902,17 +7465,17 @@ main ()
+      we see the same garbage.  */
+   fd = open ("conftest.mmap", O_RDWR);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   data2 = (char *) malloc (2 * pagesize);
+   if (!data2)
+-    exit (1);
+-  data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
++    return 1;
++  data2 += (pagesize - ((long int) data2 & (pagesize - 1))) & (pagesize - 1);
+   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_FIXED, fd, 0L))
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data2 + i))
+-      exit (1);
++      return 1;
+   /* Finally, make sure that changes to the mapped area do not
+      percolate back to the file as seen by read().  (This is a bug on
+@@ -6921,24 +7484,33 @@ main ()
+     *(data2 + i) = *(data2 + i) + 1;
+   data3 = (char *) malloc (pagesize);
+   if (!data3)
+-    exit (1);
++    return 1;
+   if (read (fd, data3, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data3 + i))
+-      exit (1);
++      return 1;
+   close (fd);
+-  exit (0);
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -6951,11 +7523,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_func_mmap_fixed_mapped=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
+-echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
++echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6; }
+ if test $ac_cv_func_mmap_fixed_mapped = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -6979,18 +7553,19 @@ for ac_header in argz.h limits.h locale.
+ unistd.h values.h sys/param.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7001,41 +7576,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7044,24 +7615,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -7069,9 +7638,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -7095,25 +7665,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -7139,9 +7703,9 @@ for ac_func in getcwd munmap putenv sete
+ __argz_count __argz_stringify __argz_next
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7167,68 +7731,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7243,9 +7799,9 @@ done
+ for ac_func in stpcpy
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7271,68 +7827,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7351,8 +7899,8 @@ _ACEOF
+    fi
+    if test $ac_cv_header_locale_h = yes; then
+-    echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
+-echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
++echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6; }
+ if test "${am_cv_val_LC_MESSAGES+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7372,39 +7920,36 @@ return LC_MESSAGES
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   am_cv_val_LC_MESSAGES=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-am_cv_val_LC_MESSAGES=no
++      am_cv_val_LC_MESSAGES=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
+-echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
++echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6; }
+     if test $am_cv_val_LC_MESSAGES = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -7413,34 +7958,34 @@ _ACEOF
+     fi
+   fi
+-   echo "$as_me:$LINENO: checking whether NLS is requested" >&5
+-echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6
+-        # Check whether --enable-nls or --disable-nls was given.
++   { echo "$as_me:$LINENO: checking whether NLS is requested" >&5
++echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6; }
++        # Check whether --enable-nls was given.
+ if test "${enable_nls+set}" = set; then
+-  enableval="$enable_nls"
+-  USE_NLS=$enableval
++  enableval=$enable_nls; USE_NLS=$enableval
+ else
+   USE_NLS=yes
+-fi;
+-    echo "$as_me:$LINENO: result: $USE_NLS" >&5
+-echo "${ECHO_T}$USE_NLS" >&6
++fi
++
++    { echo "$as_me:$LINENO: result: $USE_NLS" >&5
++echo "${ECHO_T}$USE_NLS" >&6; }
+     USE_INCLUDED_LIBINTL=no
+         if test "$USE_NLS" = "yes"; then
+-      echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
+-echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6
++      { echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
++echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6; }
+-# Check whether --with-included-gettext or --without-included-gettext was given.
++# Check whether --with-included-gettext was given.
+ if test "${with_included_gettext+set}" = set; then
+-  withval="$with_included_gettext"
+-  nls_cv_force_use_gnu_gettext=$withval
++  withval=$with_included_gettext; nls_cv_force_use_gnu_gettext=$withval
+ else
+   nls_cv_force_use_gnu_gettext=no
+-fi;
+-      echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
+-echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6
++fi
++
++      { echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
++echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6; }
+       nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext"
+       if test "$nls_cv_force_use_gnu_gettext" != "yes"; then
+@@ -7449,17 +7994,17 @@ echo "${ECHO_T}$nls_cv_force_use_gnu_get
+       CATOBJEXT=
+       if test "${ac_cv_header_libintl_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking libintl.h usability" >&5
+-echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h usability" >&5
++echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7470,41 +8015,37 @@ $ac_includes_default
+ #include <libintl.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking libintl.h presence" >&5
+-echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h presence" >&5
++echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7513,24 +8054,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <libintl.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -7538,9 +8077,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -7564,30 +8104,23 @@ echo "$as_me: WARNING: libintl.h:     se
+ echo "$as_me: WARNING: libintl.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: libintl.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: libintl.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_libintl_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ fi
+ if test $ac_cv_header_libintl_h = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libc" >&5
+-echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libc" >&5
++echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libc+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7607,43 +8140,40 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libc=no
++      gt_cv_func_gettext_libc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6; }
+          if test "$gt_cv_func_gettext_libc" != "yes"; then
+-           echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
+-echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6
++           { echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
++echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6; }
+ if test "${ac_cv_lib_intl_bindtextdomain+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7656,59 +8186,56 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char bindtextdomain ();
+ int
+ main ()
+ {
+-bindtextdomain ();
++return bindtextdomain ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_lib_intl_bindtextdomain=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_intl_bindtextdomain=no
++      ac_cv_lib_intl_bindtextdomain=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
+-echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
++echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6; }
+ if test $ac_cv_lib_intl_bindtextdomain = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libintl" >&5
+-echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libintl" >&5
++echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libintl+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7728,39 +8255,36 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libintl=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libintl=no
++      gt_cv_func_gettext_libintl=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6; }
+ fi
+          fi
+@@ -7774,8 +8298,8 @@ _ACEOF
+             # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7801,20 +8325,20 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+             if test "$MSGFMT" != "no"; then
+ for ac_func in dcgettext
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7840,68 +8364,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7912,8 +8428,8 @@ done
+               # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7928,32 +8444,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+               # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7979,11 +8496,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+               cat >conftest.$ac_ext <<_ACEOF
+@@ -8003,37 +8520,34 @@ extern int _nl_msg_cat_cntr;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   CATOBJEXT=.gmo
+                  DATADIRNAME=share
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-CATOBJEXT=.mo
++      CATOBJEXT=.mo
+                  DATADIRNAME=lib
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+               INSTOBJEXT=.mo
+             fi
+@@ -8055,8 +8569,8 @@ fi
+                 INTLOBJS="\$(GETTOBJS)"
+         # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8082,17 +8596,17 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+         # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8107,32 +8621,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+         # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8158,11 +8673,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+@@ -8181,8 +8696,8 @@ fi
+                       if $XGETTEXT --omit-header /dev/null 2> /dev/null; then
+         : ;
+       else
+-        echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
+-echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6
++        { echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
++echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6; }
+         XGETTEXT=":"
+       fi
+       fi
+@@ -8231,8 +8746,8 @@ _ACEOF
+      if test "x$ALL_LINGUAS" = "x"; then
+        LINGUAS=
+      else
+-       echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
+-echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6
++       { echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
++echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6; }
+        NEW_LINGUAS=
+        for lang in ${LINGUAS=$ALL_LINGUAS}; do
+          case "$ALL_LINGUAS" in
+@@ -8240,8 +8755,8 @@ echo $ECHO_N "checking for catalogs to b
+          esac
+        done
+        LINGUAS=$NEW_LINGUAS
+-       echo "$as_me:$LINENO: result: $LINGUAS" >&5
+-echo "${ECHO_T}$LINGUAS" >&6
++       { echo "$as_me:$LINENO: result: $LINGUAS" >&5
++echo "${ECHO_T}$LINGUAS" >&6; }
+      fi
+           if test -n "$LINGUAS"; then
+@@ -8260,17 +8775,17 @@ echo "${ECHO_T}$LINGUAS" >&6
+             if test -f $srcdir/po2tbl.sed.in; then
+       if test "$CATOBJEXT" = ".cat"; then
+        if test "${ac_cv_header_linux_version_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking linux/version.h usability" >&5
+-echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h usability" >&5
++echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8281,41 +8796,37 @@ $ac_includes_default
+ #include <linux/version.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking linux/version.h presence" >&5
+-echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h presence" >&5
++echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8324,24 +8835,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <linux/version.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -8349,9 +8858,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -8375,25 +8885,18 @@ echo "$as_me: WARNING: linux/version.h: 
+ echo "$as_me: WARNING: linux/version.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: linux/version.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: linux/version.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_linux_version_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ fi
+ if test $ac_cv_header_linux_version_h = yes; then
+@@ -8443,17 +8946,17 @@ fi
+    fi
+-echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
+-echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
+-    # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
++{ echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
++echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6; }
++    # Check whether --enable-maintainer-mode was given.
+ if test "${enable_maintainer_mode+set}" = set; then
+-  enableval="$enable_maintainer_mode"
+-  USE_MAINTAINER_MODE=$enableval
++  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
+ else
+   USE_MAINTAINER_MODE=no
+-fi;
+-  echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
+-echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
++fi
++
++  { echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
++echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6; }
+ if test $USE_MAINTAINER_MODE = yes; then
+@@ -8493,8 +8996,8 @@ AR=${AR-ar}
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8507,32 +9010,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8545,27 +9050,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -8583,8 +9102,8 @@ fi
+ # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+ # OS/2's system install, which has a completely different semantic
+ # ./install, which can be erroneously created by make from ./install.sh.
+-echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+-echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+ if test -z "$INSTALL"; then
+ if test "${ac_cv_path_install+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -8606,7 +9125,7 @@ case $as_dir/ in
+     # by default.
+     for ac_prog in ginstall scoinst install; do
+       for ac_exec_ext in '' $ac_executable_extensions; do
+-      if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
++      if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+         if test $ac_prog = install &&
+           grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+           # AIX install.  It has an incompatible calling convention.
+@@ -8625,21 +9144,22 @@ case $as_dir/ in
+     ;;
+ esac
+ done
++IFS=$as_save_IFS
+ fi
+   if test "${ac_cv_path_install+set}" = set; then
+     INSTALL=$ac_cv_path_install
+   else
+-    # As a last resort, use the slow shell script.  We don't cache a
+-    # path for INSTALL within a source directory, because that will
++    # As a last resort, use the slow shell script.  Don't cache a
++    # value for INSTALL within a source directory, because that will
+     # break other packages using the cache if that directory is
+-    # removed, or if the path is relative.
++    # removed, or if the value is a relative name.
+     INSTALL=$ac_install_sh
+   fi
+ fi
+-echo "$as_me:$LINENO: result: $INSTALL" >&5
+-echo "${ECHO_T}$INSTALL" >&6
++{ echo "$as_me:$LINENO: result: $INSTALL" >&5
++echo "${ECHO_T}$INSTALL" >&6; }
+ # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+ # It thinks the first close brace ends the variable substitution.
+@@ -8663,8 +9183,8 @@ fi
+ if test "x$cross_compiling" = "xno"; then
+   EXEEXT_FOR_BUILD='$(EXEEXT)'
+ else
+-  echo "$as_me:$LINENO: checking for build system executable suffix" >&5
+-echo $ECHO_N "checking for build system executable suffix... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for build system executable suffix" >&5
++echo $ECHO_N "checking for build system executable suffix... $ECHO_C" >&6; }
+ if test "${bfd_cv_build_exeext+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8681,8 +9201,8 @@ else
+      rm -f conftest*
+      test x"${bfd_cv_build_exeext}" = x && bfd_cv_build_exeext=no
+ fi
+-echo "$as_me:$LINENO: result: $bfd_cv_build_exeext" >&5
+-echo "${ECHO_T}$bfd_cv_build_exeext" >&6
++{ echo "$as_me:$LINENO: result: $bfd_cv_build_exeext" >&5
++echo "${ECHO_T}$bfd_cv_build_exeext" >&6; }
+   EXEEXT_FOR_BUILD=""
+   test x"${bfd_cv_build_exeext}" != xno && EXEEXT_FOR_BUILD=${bfd_cv_build_exeext}
+ fi
+@@ -8704,18 +9224,19 @@ esac
+ for ac_header in string.h strings.h stdlib.h unistd.h fcntl.h sys/file.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8726,41 +9247,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8769,24 +9286,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -8794,9 +9309,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -8820,25 +9336,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -8850,8 +9360,8 @@ fi
+ done
+-echo "$as_me:$LINENO: checking for sys/wait.h that is POSIX.1 compatible" >&5
+-echo $ECHO_N "checking for sys/wait.h that is POSIX.1 compatible... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for sys/wait.h that is POSIX.1 compatible" >&5
++echo $ECHO_N "checking for sys/wait.h that is POSIX.1 compatible... $ECHO_C" >&6; }
+ if test "${ac_cv_header_sys_wait_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8864,7 +9374,7 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #ifndef WEXITSTATUS
+-# define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
++# define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8)
+ #endif
+ #ifndef WIFEXITED
+ # define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
+@@ -8881,38 +9391,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_header_sys_wait_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_header_sys_wait_h=no
++      ac_cv_header_sys_wait_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_sys_wait_h" >&5
+-echo "${ECHO_T}$ac_cv_header_sys_wait_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_sys_wait_h" >&5
++echo "${ECHO_T}$ac_cv_header_sys_wait_h" >&6; }
+ if test $ac_cv_header_sys_wait_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -8923,8 +9429,8 @@ fi
+ # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+ # for constant arguments.  Useless!
+-echo "$as_me:$LINENO: checking for working alloca.h" >&5
+-echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working alloca.h" >&5
++echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6; }
+ if test "${ac_cv_working_alloca_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8939,44 +9445,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (2 * sizeof (int));
++                        if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_working_alloca_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_working_alloca_h=no
++      ac_cv_working_alloca_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
+-echo "${ECHO_T}$ac_cv_working_alloca_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
++echo "${ECHO_T}$ac_cv_working_alloca_h" >&6; }
+ if test $ac_cv_working_alloca_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -8985,8 +9489,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for alloca" >&5
+-echo $ECHO_N "checking for alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for alloca" >&5
++echo $ECHO_N "checking for alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_func_alloca_works+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9003,7 +9507,7 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #  include <malloc.h>
+ #  define alloca _alloca
+ # else
+-#  if HAVE_ALLOCA_H
++#  ifdef HAVE_ALLOCA_H
+ #   include <alloca.h>
+ #  else
+ #   ifdef _AIX
+@@ -9021,44 +9525,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (1);
++                                  if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_func_alloca_works=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_func_alloca_works=no
++      ac_cv_func_alloca_works=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
+-echo "${ECHO_T}$ac_cv_func_alloca_works" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
++echo "${ECHO_T}$ac_cv_func_alloca_works" >&6; }
+ if test $ac_cv_func_alloca_works = yes; then
+@@ -9072,15 +9574,15 @@ else
+ # contain a buggy version.  If you still want to use their alloca,
+ # use ar to extract alloca.o from them instead of compiling alloca.c.
+-ALLOCA=alloca.$ac_objext
++ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
+ cat >>confdefs.h <<\_ACEOF
+ #define C_ALLOCA 1
+ _ACEOF
+-echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
+-echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
++echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6; }
+ if test "${ac_cv_os_cray+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9090,7 +9592,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#if defined(CRAY) && ! defined(CRAY2)
++#if defined CRAY && ! defined CRAY2
+ webecray
+ #else
+ wenotbecray
+@@ -9106,14 +9608,14 @@ fi
+ rm -f conftest*
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
+-echo "${ECHO_T}$ac_cv_os_cray" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
++echo "${ECHO_T}$ac_cv_os_cray" >&6; }
+ if test $ac_cv_os_cray = yes; then
+   for ac_func in _getb67 GETB67 getb67; do
+     as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -9139,68 +9641,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -9213,8 +9707,8 @@ fi
+   done
+ fi
+-echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
+-echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
++echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_c_stack_direction+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9227,6 +9721,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
++$ac_includes_default
+ int
+ find_stack_direction ()
+ {
+@@ -9244,17 +9739,26 @@ find_stack_direction ()
+ int
+ main ()
+ {
+-  exit (find_stack_direction () < 0);
++  return find_stack_direction () < 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -9267,11 +9771,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_c_stack_direction=-1
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
+-echo "${ECHO_T}$ac_cv_c_stack_direction" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
++echo "${ECHO_T}$ac_cv_c_stack_direction" >&6; }
+ cat >>confdefs.h <<_ACEOF
+ #define STACK_DIRECTION $ac_cv_c_stack_direction
+@@ -9288,9 +9794,9 @@ fi
+ for ac_func in sbrk utimes setmode getc_unlocked strcoll
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -9316,68 +9822,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -9389,8 +9887,8 @@ done
+ # Check whether fopen64 is available and whether _LARGEFILE64_SOURCE
+ # needs to be defined for it
+-echo "$as_me:$LINENO: checking for fopen64" >&5
+-echo $ECHO_N "checking for fopen64... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for fopen64" >&5
++echo $ECHO_N "checking for fopen64... $ECHO_C" >&6; }
+ if test "${bu_cv_have_fopen64+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9410,33 +9908,29 @@ FILE *f = fopen64 ("/tmp/foo","r");
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   bu_cv_have_fopen64=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-saved_CPPFLAGS=$CPPFLAGS
++      saved_CPPFLAGS=$CPPFLAGS
+  CPPFLAGS="$CPPFLAGS -D_LARGEFILE64_SOURCE"
+  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -9454,44 +9948,42 @@ FILE *f = fopen64 ("/tmp/foo","r");
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   bu_cv_have_fopen64="need -D_LARGEFILE64_SOURCE"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bu_cv_have_fopen64=no
++      bu_cv_have_fopen64=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+  CPPFLAGS=$saved_CPPFLAGS
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $bu_cv_have_fopen64" >&5
+-echo "${ECHO_T}$bu_cv_have_fopen64" >&6
++{ echo "$as_me:$LINENO: result: $bu_cv_have_fopen64" >&5
++echo "${ECHO_T}$bu_cv_have_fopen64" >&6; }
+ if test "$bu_cv_have_fopen64" != no; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -9499,8 +9991,8 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for stat64" >&5
+-echo $ECHO_N "checking for stat64... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for stat64" >&5
++echo $ECHO_N "checking for stat64... $ECHO_C" >&6; }
+ if test "${bu_cv_have_stat64+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9520,33 +10012,29 @@ struct stat64 st; stat64 ("/tmp/foo", &s
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   bu_cv_have_stat64=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-saved_CPPFLAGS=$CPPFLAGS
++      saved_CPPFLAGS=$CPPFLAGS
+  CPPFLAGS="$CPPFLAGS -D_LARGEFILE64_SOURCE"
+  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -9564,191 +10052,146 @@ struct stat64 st; stat64 ("/tmp/foo", &s
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   bu_cv_have_stat64="need -D_LARGEFILE64_SOURCE"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bu_cv_have_stat64=no
++      bu_cv_have_stat64=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+  CPPFLAGS=$saved_CPPFLAGS
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $bu_cv_have_stat64" >&5
+-echo "${ECHO_T}$bu_cv_have_stat64" >&6
++{ echo "$as_me:$LINENO: result: $bu_cv_have_stat64" >&5
++echo "${ECHO_T}$bu_cv_have_stat64" >&6; }
+ if test "$bu_cv_have_stat64" != no; then
+ cat >>confdefs.h <<\_ACEOF
+ #define HAVE_STAT64 1
+ _ACEOF
+-fi
+-if test "$bu_cv_have_fopen64" = "need -D_LARGEFILE64_SOURCE" \
+-   || test "$bu_cv_have_stat64" = "need -D_LARGEFILE64_SOURCE"; then
+-
+-cat >>confdefs.h <<\_ACEOF
+-#define _LARGEFILE64_SOURCE 1
+-_ACEOF
+-
+-  CPPFLAGS="$CPPFLAGS -D_LARGEFILE64_SOURCE"
+-fi
+-
+-# Some systems have frexp only in -lm, not in -lc.
+-echo "$as_me:$LINENO: checking for library containing frexp" >&5
+-echo $ECHO_N "checking for library containing frexp... $ECHO_C" >&6
+-if test "${ac_cv_search_frexp+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_frexp=no
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char frexp ();
+-int
+-main ()
+-{
+-frexp ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_frexp="none required"
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++fi
++if test "$bu_cv_have_fopen64" = "need -D_LARGEFILE64_SOURCE" \
++   || test "$bu_cv_have_stat64" = "need -D_LARGEFILE64_SOURCE"; then
++
++cat >>confdefs.h <<\_ACEOF
++#define _LARGEFILE64_SOURCE 1
++_ACEOF
++  CPPFLAGS="$CPPFLAGS -D_LARGEFILE64_SOURCE"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_frexp" = no; then
+-  for ac_lib in m; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
++
++# Some systems have frexp only in -lm, not in -lc.
++{ echo "$as_me:$LINENO: checking for library containing frexp" >&5
++echo $ECHO_N "checking for library containing frexp... $ECHO_C" >&6; }
++if test "${ac_cv_search_frexp+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_func_search_save_LIBS=$LIBS
++cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char frexp ();
+ int
+ main ()
+ {
+-frexp ();
++return frexp ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++for ac_lib in '' m; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_frexp="-l$ac_lib"
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_frexp=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_frexp+set}" = set; then
++  break
++fi
++done
++if test "${ac_cv_search_frexp+set}" = set; then
++  :
++else
++  ac_cv_search_frexp=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_frexp" >&5
+-echo "${ECHO_T}$ac_cv_search_frexp" >&6
+-if test "$ac_cv_search_frexp" != no; then
+-  test "$ac_cv_search_frexp" = "none required" || LIBS="$ac_cv_search_frexp $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_frexp" >&5
++echo "${ECHO_T}$ac_cv_search_frexp" >&6; }
++ac_res=$ac_cv_search_frexp
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+-echo "$as_me:$LINENO: checking for time_t in time.h" >&5
+-echo $ECHO_N "checking for time_t in time.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for time_t in time.h" >&5
++echo $ECHO_N "checking for time_t in time.h... $ECHO_C" >&6; }
+ if test "${bu_cv_decl_time_t_time_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9768,39 +10211,35 @@ time_t i;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bu_cv_decl_time_t_time_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bu_cv_decl_time_t_time_h=no
++      bu_cv_decl_time_t_time_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $bu_cv_decl_time_t_time_h" >&5
+-echo "${ECHO_T}$bu_cv_decl_time_t_time_h" >&6
++{ echo "$as_me:$LINENO: result: $bu_cv_decl_time_t_time_h" >&5
++echo "${ECHO_T}$bu_cv_decl_time_t_time_h" >&6; }
+ if test $bu_cv_decl_time_t_time_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -9809,8 +10248,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for time_t in sys/types.h" >&5
+-echo $ECHO_N "checking for time_t in sys/types.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for time_t in sys/types.h" >&5
++echo $ECHO_N "checking for time_t in sys/types.h... $ECHO_C" >&6; }
+ if test "${bu_cv_decl_time_t_types_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9830,39 +10269,35 @@ time_t i;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bu_cv_decl_time_t_types_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bu_cv_decl_time_t_types_h=no
++      bu_cv_decl_time_t_types_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $bu_cv_decl_time_t_types_h" >&5
+-echo "${ECHO_T}$bu_cv_decl_time_t_types_h" >&6
++{ echo "$as_me:$LINENO: result: $bu_cv_decl_time_t_types_h" >&5
++echo "${ECHO_T}$bu_cv_decl_time_t_types_h" >&6; }
+ if test $bu_cv_decl_time_t_types_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -9871,8 +10306,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for a known getopt prototype in unistd.h" >&5
+-echo $ECHO_N "checking for a known getopt prototype in unistd.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a known getopt prototype in unistd.h" >&5
++echo $ECHO_N "checking for a known getopt prototype in unistd.h... $ECHO_C" >&6; }
+ if test "${bu_cv_decl_getopt_unistd_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9892,39 +10327,35 @@ extern int getopt (int, char *const*, co
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bu_cv_decl_getopt_unistd_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bu_cv_decl_getopt_unistd_h=no
++      bu_cv_decl_getopt_unistd_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $bu_cv_decl_getopt_unistd_h" >&5
+-echo "${ECHO_T}$bu_cv_decl_getopt_unistd_h" >&6
++{ echo "$as_me:$LINENO: result: $bu_cv_decl_getopt_unistd_h" >&5
++echo "${ECHO_T}$bu_cv_decl_getopt_unistd_h" >&6; }
+ if test $bu_cv_decl_getopt_unistd_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -9935,8 +10366,8 @@ fi
+ # Under Next 3.2 <utime.h> apparently does not define struct utimbuf
+ # by default.
+-echo "$as_me:$LINENO: checking for utime.h" >&5
+-echo $ECHO_N "checking for utime.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for utime.h" >&5
++echo $ECHO_N "checking for utime.h... $ECHO_C" >&6; }
+ if test "${bu_cv_header_utime_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9960,39 +10391,35 @@ struct utimbuf s;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   bu_cv_header_utime_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-bu_cv_header_utime_h=no
++      bu_cv_header_utime_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $bu_cv_header_utime_h" >&5
+-echo "${ECHO_T}$bu_cv_header_utime_h" >&6
++{ echo "$as_me:$LINENO: result: $bu_cv_header_utime_h" >&5
++echo "${ECHO_T}$bu_cv_header_utime_h" >&6; }
+ if test $bu_cv_header_utime_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -10001,8 +10428,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether fprintf is declared" >&5
+-echo $ECHO_N "checking whether fprintf is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether fprintf is declared" >&5
++echo $ECHO_N "checking whether fprintf is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_fprintf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10017,7 +10444,7 @@ int
+ main ()
+ {
+ #ifndef fprintf
+-  char *p = (char *) fprintf;
++  (void) fprintf;
+ #endif
+   ;
+@@ -10025,38 +10452,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_fprintf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_fprintf=no
++      ac_cv_have_decl_fprintf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_fprintf" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_fprintf" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_fprintf" >&5
++echo "${ECHO_T}$ac_cv_have_decl_fprintf" >&6; }
+ if test $ac_cv_have_decl_fprintf = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10071,8 +10494,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether stpcpy is declared" >&5
+-echo $ECHO_N "checking whether stpcpy is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether stpcpy is declared" >&5
++echo $ECHO_N "checking whether stpcpy is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_stpcpy+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10087,7 +10510,7 @@ int
+ main ()
+ {
+ #ifndef stpcpy
+-  char *p = (char *) stpcpy;
++  (void) stpcpy;
+ #endif
+   ;
+@@ -10095,38 +10518,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_stpcpy=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_stpcpy=no
++      ac_cv_have_decl_stpcpy=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_stpcpy" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_stpcpy" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_stpcpy" >&5
++echo "${ECHO_T}$ac_cv_have_decl_stpcpy" >&6; }
+ if test $ac_cv_have_decl_stpcpy = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10141,8 +10560,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether strstr is declared" >&5
+-echo $ECHO_N "checking whether strstr is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether strstr is declared" >&5
++echo $ECHO_N "checking whether strstr is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_strstr+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10157,7 +10576,7 @@ int
+ main ()
+ {
+ #ifndef strstr
+-  char *p = (char *) strstr;
++  (void) strstr;
+ #endif
+   ;
+@@ -10165,38 +10584,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_strstr=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_strstr=no
++      ac_cv_have_decl_strstr=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_strstr" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_strstr" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_strstr" >&5
++echo "${ECHO_T}$ac_cv_have_decl_strstr" >&6; }
+ if test $ac_cv_have_decl_strstr = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10211,8 +10626,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether sbrk is declared" >&5
+-echo $ECHO_N "checking whether sbrk is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether sbrk is declared" >&5
++echo $ECHO_N "checking whether sbrk is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_sbrk+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10227,7 +10642,7 @@ int
+ main ()
+ {
+ #ifndef sbrk
+-  char *p = (char *) sbrk;
++  (void) sbrk;
+ #endif
+   ;
+@@ -10235,38 +10650,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_sbrk=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_sbrk=no
++      ac_cv_have_decl_sbrk=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_sbrk" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_sbrk" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_sbrk" >&5
++echo "${ECHO_T}$ac_cv_have_decl_sbrk" >&6; }
+ if test $ac_cv_have_decl_sbrk = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10281,8 +10692,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether getenv is declared" >&5
+-echo $ECHO_N "checking whether getenv is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether getenv is declared" >&5
++echo $ECHO_N "checking whether getenv is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_getenv+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10297,7 +10708,7 @@ int
+ main ()
+ {
+ #ifndef getenv
+-  char *p = (char *) getenv;
++  (void) getenv;
+ #endif
+   ;
+@@ -10305,38 +10716,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_getenv=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_getenv=no
++      ac_cv_have_decl_getenv=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_getenv" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_getenv" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_getenv" >&5
++echo "${ECHO_T}$ac_cv_have_decl_getenv" >&6; }
+ if test $ac_cv_have_decl_getenv = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10351,8 +10758,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether environ is declared" >&5
+-echo $ECHO_N "checking whether environ is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether environ is declared" >&5
++echo $ECHO_N "checking whether environ is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_environ+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10367,7 +10774,7 @@ int
+ main ()
+ {
+ #ifndef environ
+-  char *p = (char *) environ;
++  (void) environ;
+ #endif
+   ;
+@@ -10375,38 +10782,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_environ=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_environ=no
++      ac_cv_have_decl_environ=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_environ" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_environ" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_environ" >&5
++echo "${ECHO_T}$ac_cv_have_decl_environ" >&6; }
+ if test $ac_cv_have_decl_environ = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10421,8 +10824,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether getc_unlocked is declared" >&5
+-echo $ECHO_N "checking whether getc_unlocked is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether getc_unlocked is declared" >&5
++echo $ECHO_N "checking whether getc_unlocked is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_getc_unlocked+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10437,7 +10840,7 @@ int
+ main ()
+ {
+ #ifndef getc_unlocked
+-  char *p = (char *) getc_unlocked;
++  (void) getc_unlocked;
+ #endif
+   ;
+@@ -10445,38 +10848,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_getc_unlocked=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_getc_unlocked=no
++      ac_cv_have_decl_getc_unlocked=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_getc_unlocked" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_getc_unlocked" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_getc_unlocked" >&5
++echo "${ECHO_T}$ac_cv_have_decl_getc_unlocked" >&6; }
+ if test $ac_cv_have_decl_getc_unlocked = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10491,8 +10890,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether snprintf is declared" >&5
+-echo $ECHO_N "checking whether snprintf is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether snprintf is declared" >&5
++echo $ECHO_N "checking whether snprintf is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_snprintf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10507,7 +10906,7 @@ int
+ main ()
+ {
+ #ifndef snprintf
+-  char *p = (char *) snprintf;
++  (void) snprintf;
+ #endif
+   ;
+@@ -10515,38 +10914,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_snprintf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_snprintf=no
++      ac_cv_have_decl_snprintf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_snprintf" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_snprintf" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_snprintf" >&5
++echo "${ECHO_T}$ac_cv_have_decl_snprintf" >&6; }
+ if test $ac_cv_have_decl_snprintf = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10561,8 +10956,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether vsnprintf is declared" >&5
+-echo $ECHO_N "checking whether vsnprintf is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether vsnprintf is declared" >&5
++echo $ECHO_N "checking whether vsnprintf is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_vsnprintf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10577,7 +10972,7 @@ int
+ main ()
+ {
+ #ifndef vsnprintf
+-  char *p = (char *) vsnprintf;
++  (void) vsnprintf;
+ #endif
+   ;
+@@ -10585,38 +10980,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_vsnprintf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_vsnprintf=no
++      ac_cv_have_decl_vsnprintf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_vsnprintf" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_vsnprintf" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_vsnprintf" >&5
++echo "${ECHO_T}$ac_cv_have_decl_vsnprintf" >&6; }
+ if test $ac_cv_have_decl_vsnprintf = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -10817,8 +11208,10 @@ done
+-                              ac_config_files="$ac_config_files Makefile doc/Makefile po/Makefile.in:po/Make-in"
+-          ac_config_commands="$ac_config_commands default"
++ac_config_files="$ac_config_files Makefile doc/Makefile po/Makefile.in:po/Make-in"
++
++ac_config_commands="$ac_config_commands default"
++
+ cat >confcache <<\_ACEOF
+ # This file is a shell script that caches the results of configure
+ # tests run on this system so they can be shared between configure
+@@ -10837,39 +11230,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -10878,32 +11290,18 @@ test "x$prefix" = xNONE && prefix=$ac_de
+ # Let make expand exec_prefix.
+ test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+-# VPATH may cause trouble with some makes, so we remove $(srcdir),
+-# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+-# trailing colons and then remove the whole line if VPATH becomes empty
+-# (actually we leave an empty line to preserve line numbers).
+-if test "x$srcdir" = x.; then
+-  ac_vpsub='/^[        ]*VPATH[        ]*=/{
+-s/:*\$(srcdir):*/:/;
+-s/:*\${srcdir}:*/:/;
+-s/:*@srcdir@:*/:/;
+-s/^\([^=]*=[   ]*\):*/\1/;
+-s/:*$//;
+-s/^[^=]*=[     ]*$//;
+-}'
+-fi
+-
+ DEFS=-DHAVE_CONFIG_H
+ ac_libobjs=
+ ac_ltlibobjs=
+ for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+   # 1. Remove the extension, and $U if already installed.
+-  ac_i=`echo "$ac_i" |
+-       sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
+-  # 2. Add them.
+-  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
+-  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
++  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
++  ac_i=`echo "$ac_i" | sed "$ac_script"`
++  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
++  #    will be set to the directory where LIBOBJS objects are built.
++  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
++  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
+ done
+ LIBOBJS=$ac_libobjs
+@@ -10955,17 +11353,45 @@ cat >>$CONFIG_STATUS <<\_ACEOF
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -10975,8 +11401,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -10990,18 +11451,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -11009,159 +11471,120 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+-
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
+-
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
+-fi
++# CDPATH.
++$as_unset CDPATH
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+-echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
+-    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
+-       /*)
+-         if ("$as_dir/$as_base" -c '
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
+-    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+-echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
++  chmod +x "$as_me.lineno" ||
++    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -11170,7 +11593,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -11179,31 +11623,14 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
+-
+ exec 6>&1
+-# Open the log real soon, to keep \$[0] and so on meaningful, and to
++# Save the log message, to keep $[0] and so on meaningful, and to
+ # report actual input values of CONFIG_FILES etc. instead of their
+-# values after options handling.  Logging --version etc. is OK.
+-exec 5>>config.log
+-{
+-  echo
+-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+-## Running $as_me. ##
+-_ASBOX
+-} >&5
+-cat >&5 <<_CSEOF
+-
++# values after options handling.
++ac_log="
+ This file was extended by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   CONFIG_FILES    = $CONFIG_FILES
+   CONFIG_HEADERS  = $CONFIG_HEADERS
+@@ -11211,30 +11638,20 @@ generated by GNU Autoconf 2.59.  Invocat
+   CONFIG_COMMANDS = $CONFIG_COMMANDS
+   $ $0 $@
+-_CSEOF
+-echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+-echo >&5
++on `(hostname || uname -n) 2>/dev/null | sed 1q`
++"
++
+ _ACEOF
++cat >>$CONFIG_STATUS <<_ACEOF
+ # Files that config.status was made for.
+-if test -n "$ac_config_files"; then
+-  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_headers"; then
+-  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_links"; then
+-  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
+-fi
++config_files="$ac_config_files"
++config_headers="$ac_config_headers"
++config_commands="$ac_config_commands"
+-if test -n "$ac_config_commands"; then
+-  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
+-fi
++_ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-
+ ac_cs_usage="\
+ \`$as_me' instantiates files from templates according to the
+ current configuration.
+@@ -11242,7 +11659,7 @@ current configuration.
+ Usage: $0 [OPTIONS] [FILE]...
+   -h, --help       print this help, then exit
+-  -V, --version    print version number, then exit
++  -V, --version    print version number and configuration settings, then exit
+   -q, --quiet      do not print progress messages
+   -d, --debug      don't remove temporary files
+       --recheck    update $as_me by reconfiguring in the same conditions
+@@ -11261,19 +11678,21 @@ Configuration commands:
+ $config_commands
+ Report bugs to <bug-autoconf@gnu.org>."
+-_ACEOF
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ ac_cs_version="\\
+ config.status
+-configured by $0, generated by GNU Autoconf 2.59,
+-  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
++configured by $0, generated by GNU Autoconf 2.61,
++  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 2006 Free Software Foundation, Inc.
+ This config.status script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it."
+-srcdir=$srcdir
+-INSTALL="$INSTALL"
++
++ac_pwd='$ac_pwd'
++srcdir='$srcdir'
++INSTALL='$INSTALL'
+ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+@@ -11284,39 +11703,24 @@ while test $# != 0
+ do
+   case $1 in
+   --*=*)
+-    ac_option=`expr "x$1" : 'x\([^=]*\)='`
+-    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
++    ac_option=`expr "X$1" : 'X\([^=]*\)='`
++    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+     ac_shift=:
+     ;;
+-  -*)
++  *)
+     ac_option=$1
+     ac_optarg=$2
+     ac_shift=shift
+     ;;
+-  *) # This is not an option, so the user has probably given explicit
+-     # arguments.
+-     ac_option=$1
+-     ac_need_defaults=false;;
+   esac
+   case $ac_option in
+   # Handling of the options.
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+     ac_cs_recheck=: ;;
+-  --version | --vers* | -V )
+-    echo "$ac_cs_version"; exit 0 ;;
+-  --he | --h)
+-    # Conflict between --help and --header
+-    { { echo "$as_me:$LINENO: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&2;}
+-   { (exit 1); exit 1; }; };;
+-  --help | --hel | -h )
+-    echo "$ac_cs_usage"; exit 0 ;;
+-  --debug | --d* | -d )
++  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
++    echo "$ac_cs_version"; exit ;;
++  --debug | --debu | --deb | --de | --d | -d )
+     debug=: ;;
+   --file | --fil | --fi | --f )
+     $ac_shift
+@@ -11326,18 +11730,24 @@ Try \`$0 --help' for more information." 
+     $ac_shift
+     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+     ac_need_defaults=false;;
++  --he | --h)
++    # Conflict between --help and --header
++    { echo "$as_me: error: ambiguous option: $1
++Try \`$0 --help' for more information." >&2
++   { (exit 1); exit 1; }; };;
++  --help | --hel | -h )
++    echo "$ac_cs_usage"; exit ;;
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil | --si | --s)
+     ac_cs_silent=: ;;
+   # This is an error.
+-  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&2;}
++  -*) { echo "$as_me: error: unrecognized option: $1
++Try \`$0 --help' for more information." >&2
+    { (exit 1); exit 1; }; } ;;
+-  *) ac_config_targets="$ac_config_targets $1" ;;
++  *) ac_config_targets="$ac_config_targets $1"
++     ac_need_defaults=false ;;
+   esac
+   shift
+@@ -11353,40 +11763,52 @@ fi
+ _ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ if \$ac_cs_recheck; then
+-  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
+-  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
++  echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
++  CONFIG_SHELL=$SHELL
++  export CONFIG_SHELL
++  exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+ fi
+ _ACEOF
++cat >>$CONFIG_STATUS <<\_ACEOF
++exec 5>>config.log
++{
++  echo
++  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
++## Running $as_me. ##
++_ASBOX
++  echo "$ac_log"
++} >&5
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ #
+-# INIT-COMMANDS section.
++# INIT-COMMANDS
+ #
+-
+ AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+ _ACEOF
+-
+-
+ cat >>$CONFIG_STATUS <<\_ACEOF
++
++# Handling of arguments.
+ for ac_config_target in $ac_config_targets
+ do
+-  case "$ac_config_target" in
+-  # Handling of arguments.
+-  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+-  "doc/Makefile" ) CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
+-  "po/Makefile.in" ) CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
+-  "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+-  "default" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
+-  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++  case $ac_config_target in
++    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
++    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
++    "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
++    "po/Makefile.in") CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
++    "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
++
+   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+ echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+    { (exit 1); exit 1; }; };;
+   esac
+ done
++
+ # If the user did not use the arguments to specify the items to instantiate,
+ # then the envvar interface is used.  Set only those that are not.
+ # We use the long form for the default assignment because of an extremely
+@@ -11398,391 +11820,496 @@ if $ac_need_defaults; then
+ fi
+ # Have a temporary directory for convenience.  Make it in the build tree
+-# simply because there is no reason to put it here, and in addition,
++# simply because there is no reason against having it here, and in addition,
+ # creating and moving files from /tmp can sometimes cause problems.
+-# Create a temporary directory, and hook for its removal unless debugging.
++# Hook for its removal unless debugging.
++# Note that there is a small window in which the directory will not be cleaned:
++# after its creation but before its name has been assigned to `$tmp'.
+ $debug ||
+ {
+-  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
++  tmp=
++  trap 'exit_status=$?
++  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
++' 0
+   trap '{ (exit 1); exit 1; }' 1 2 13 15
+ }
+-
+ # Create a (secure) tmp directory for tmp files.
+ {
+-  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
++  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+   test -n "$tmp" && test -d "$tmp"
+ }  ||
+ {
+-  tmp=./confstat$$-$RANDOM
+-  (umask 077 && mkdir $tmp)
++  tmp=./conf$$-$RANDOM
++  (umask 077 && mkdir "$tmp")
+ } ||
+ {
+    echo "$me: cannot create a temporary directory in ." >&2
+    { (exit 1); exit 1; }
+ }
+-_ACEOF
+-
+-cat >>$CONFIG_STATUS <<_ACEOF
+-
+ #
+-# CONFIG_FILES section.
++# Set up the sed scripts for CONFIG_FILES section.
+ #
+ # No need to generate the scripts if there are no CONFIG_FILES.
+ # This happens for instance when ./config.status config.h
+-if test -n "\$CONFIG_FILES"; then
+-  # Protect against being on the right side of a sed subst in config.status.
+-  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
+-   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
+-s,@SHELL@,$SHELL,;t t
+-s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
+-s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
+-s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
+-s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
+-s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
+-s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
+-s,@exec_prefix@,$exec_prefix,;t t
+-s,@prefix@,$prefix,;t t
+-s,@program_transform_name@,$program_transform_name,;t t
+-s,@bindir@,$bindir,;t t
+-s,@sbindir@,$sbindir,;t t
+-s,@libexecdir@,$libexecdir,;t t
+-s,@datadir@,$datadir,;t t
+-s,@sysconfdir@,$sysconfdir,;t t
+-s,@sharedstatedir@,$sharedstatedir,;t t
+-s,@localstatedir@,$localstatedir,;t t
+-s,@libdir@,$libdir,;t t
+-s,@includedir@,$includedir,;t t
+-s,@oldincludedir@,$oldincludedir,;t t
+-s,@infodir@,$infodir,;t t
+-s,@mandir@,$mandir,;t t
+-s,@build_alias@,$build_alias,;t t
+-s,@host_alias@,$host_alias,;t t
+-s,@target_alias@,$target_alias,;t t
+-s,@DEFS@,$DEFS,;t t
+-s,@ECHO_C@,$ECHO_C,;t t
+-s,@ECHO_N@,$ECHO_N,;t t
+-s,@ECHO_T@,$ECHO_T,;t t
+-s,@LIBS@,$LIBS,;t t
+-s,@build@,$build,;t t
+-s,@build_cpu@,$build_cpu,;t t
+-s,@build_vendor@,$build_vendor,;t t
+-s,@build_os@,$build_os,;t t
+-s,@host@,$host,;t t
+-s,@host_cpu@,$host_cpu,;t t
+-s,@host_vendor@,$host_vendor,;t t
+-s,@host_os@,$host_os,;t t
+-s,@target@,$target,;t t
+-s,@target_cpu@,$target_cpu,;t t
+-s,@target_vendor@,$target_vendor,;t t
+-s,@target_os@,$target_os,;t t
+-s,@CC@,$CC,;t t
+-s,@CFLAGS@,$CFLAGS,;t t
+-s,@LDFLAGS@,$LDFLAGS,;t t
+-s,@CPPFLAGS@,$CPPFLAGS,;t t
+-s,@ac_ct_CC@,$ac_ct_CC,;t t
+-s,@EXEEXT@,$EXEEXT,;t t
+-s,@OBJEXT@,$OBJEXT,;t t
+-s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
+-s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
+-s,@INSTALL_DATA@,$INSTALL_DATA,;t t
+-s,@CYGPATH_W@,$CYGPATH_W,;t t
+-s,@PACKAGE@,$PACKAGE,;t t
+-s,@VERSION@,$VERSION,;t t
+-s,@ACLOCAL@,$ACLOCAL,;t t
+-s,@AUTOCONF@,$AUTOCONF,;t t
+-s,@AUTOMAKE@,$AUTOMAKE,;t t
+-s,@AUTOHEADER@,$AUTOHEADER,;t t
+-s,@MAKEINFO@,$MAKEINFO,;t t
+-s,@install_sh@,$install_sh,;t t
+-s,@STRIP@,$STRIP,;t t
+-s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
+-s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
+-s,@mkdir_p@,$mkdir_p,;t t
+-s,@AWK@,$AWK,;t t
+-s,@SET_MAKE@,$SET_MAKE,;t t
+-s,@am__leading_dot@,$am__leading_dot,;t t
+-s,@AMTAR@,$AMTAR,;t t
+-s,@am__tar@,$am__tar,;t t
+-s,@am__untar@,$am__untar,;t t
+-s,@DEPDIR@,$DEPDIR,;t t
+-s,@am__include@,$am__include,;t t
+-s,@am__quote@,$am__quote,;t t
+-s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
+-s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
+-s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
+-s,@CCDEPMODE@,$CCDEPMODE,;t t
+-s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
+-s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
+-s,@LN_S@,$LN_S,;t t
+-s,@RANLIB@,$RANLIB,;t t
+-s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
+-s,@LIBTOOL@,$LIBTOOL,;t t
+-s,@WARN_CFLAGS@,$WARN_CFLAGS,;t t
+-s,@NO_WERROR@,$NO_WERROR,;t t
+-s,@YACC@,$YACC,;t t
+-s,@LEX@,$LEX,;t t
+-s,@LEXLIB@,$LEXLIB,;t t
+-s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
+-s,@CPP@,$CPP,;t t
+-s,@EGREP@,$EGREP,;t t
+-s,@ALLOCA@,$ALLOCA,;t t
+-s,@USE_NLS@,$USE_NLS,;t t
+-s,@MSGFMT@,$MSGFMT,;t t
+-s,@GMSGFMT@,$GMSGFMT,;t t
+-s,@XGETTEXT@,$XGETTEXT,;t t
+-s,@USE_INCLUDED_LIBINTL@,$USE_INCLUDED_LIBINTL,;t t
+-s,@CATALOGS@,$CATALOGS,;t t
+-s,@CATOBJEXT@,$CATOBJEXT,;t t
+-s,@DATADIRNAME@,$DATADIRNAME,;t t
+-s,@GMOFILES@,$GMOFILES,;t t
+-s,@INSTOBJEXT@,$INSTOBJEXT,;t t
+-s,@INTLDEPS@,$INTLDEPS,;t t
+-s,@INTLLIBS@,$INTLLIBS,;t t
+-s,@INTLOBJS@,$INTLOBJS,;t t
+-s,@POFILES@,$POFILES,;t t
+-s,@POSUB@,$POSUB,;t t
+-s,@INCLUDE_LOCALE_H@,$INCLUDE_LOCALE_H,;t t
+-s,@GT_NO@,$GT_NO,;t t
+-s,@GT_YES@,$GT_YES,;t t
+-s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t
+-s,@l@,$l,;t t
+-s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
+-s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
+-s,@MAINT@,$MAINT,;t t
+-s,@HDEFINES@,$HDEFINES,;t t
+-s,@AR@,$AR,;t t
+-s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
+-s,@EXEEXT_FOR_BUILD@,$EXEEXT_FOR_BUILD,;t t
+-s,@DEMANGLER_NAME@,$DEMANGLER_NAME,;t t
+-s,@NLMCONV_DEFS@,$NLMCONV_DEFS,;t t
+-s,@BUILD_NLMCONV@,$BUILD_NLMCONV,;t t
+-s,@BUILD_SRCONV@,$BUILD_SRCONV,;t t
+-s,@BUILD_DLLTOOL@,$BUILD_DLLTOOL,;t t
+-s,@DLLTOOL_DEFS@,$DLLTOOL_DEFS,;t t
+-s,@BUILD_WINDRES@,$BUILD_WINDRES,;t t
+-s,@BUILD_DLLWRAP@,$BUILD_DLLWRAP,;t t
+-s,@BUILD_MISC@,$BUILD_MISC,;t t
+-s,@OBJDUMP_DEFS@,$OBJDUMP_DEFS,;t t
+-s,@EMULATION@,$EMULATION,;t t
+-s,@EMULATION_VECTOR@,$EMULATION_VECTOR,;t t
+-s,@datarootdir@,$datarootdir,;t t
+-s,@docdir@,$docdir,;t t
+-s,@htmldir@,$htmldir,;t t
+-s,@LIBOBJS@,$LIBOBJS,;t t
+-s,@LTLIBOBJS@,$LTLIBOBJS,;t t
+-CEOF
+-
+-_ACEOF
+-
+-  cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Split the substitutions into bite-sized pieces for seds with
+-  # small command number limits, like on Digital OSF/1 and HP-UX.
+-  ac_max_sed_lines=48
+-  ac_sed_frag=1 # Number of current file.
+-  ac_beg=1 # First line for current file.
+-  ac_end=$ac_max_sed_lines # Line after last line for current file.
+-  ac_more_lines=:
+-  ac_sed_cmds=
+-  while $ac_more_lines; do
+-    if test $ac_beg -gt 1; then
+-      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    else
+-      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    fi
+-    if test ! -s $tmp/subs.frag; then
+-      ac_more_lines=false
+-    else
+-      # The purpose of the label and of the branching condition is to
+-      # speed up the sed processing (if there are no `@' at all, there
+-      # is no need to browse any of the substitutions).
+-      # These are the two extra sed commands mentioned above.
+-      (echo ':t
+-  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
+-      if test -z "$ac_sed_cmds"; then
+-      ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
+-      else
+-      ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
+-      fi
+-      ac_sed_frag=`expr $ac_sed_frag + 1`
+-      ac_beg=$ac_end
+-      ac_end=`expr $ac_end + $ac_max_sed_lines`
+-    fi
+-  done
+-  if test -z "$ac_sed_cmds"; then
+-    ac_sed_cmds=cat
++if test -n "$CONFIG_FILES"; then
++
++_ACEOF
++
++
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++SHELL!$SHELL$ac_delim
++PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim
++PACKAGE_NAME!$PACKAGE_NAME$ac_delim
++PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim
++PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim
++PACKAGE_STRING!$PACKAGE_STRING$ac_delim
++PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim
++exec_prefix!$exec_prefix$ac_delim
++prefix!$prefix$ac_delim
++program_transform_name!$program_transform_name$ac_delim
++bindir!$bindir$ac_delim
++sbindir!$sbindir$ac_delim
++libexecdir!$libexecdir$ac_delim
++datarootdir!$datarootdir$ac_delim
++datadir!$datadir$ac_delim
++sysconfdir!$sysconfdir$ac_delim
++sharedstatedir!$sharedstatedir$ac_delim
++localstatedir!$localstatedir$ac_delim
++includedir!$includedir$ac_delim
++oldincludedir!$oldincludedir$ac_delim
++docdir!$docdir$ac_delim
++infodir!$infodir$ac_delim
++htmldir!$htmldir$ac_delim
++dvidir!$dvidir$ac_delim
++pdfdir!$pdfdir$ac_delim
++psdir!$psdir$ac_delim
++libdir!$libdir$ac_delim
++localedir!$localedir$ac_delim
++mandir!$mandir$ac_delim
++DEFS!$DEFS$ac_delim
++ECHO_C!$ECHO_C$ac_delim
++ECHO_N!$ECHO_N$ac_delim
++ECHO_T!$ECHO_T$ac_delim
++LIBS!$LIBS$ac_delim
++build_alias!$build_alias$ac_delim
++host_alias!$host_alias$ac_delim
++target_alias!$target_alias$ac_delim
++build!$build$ac_delim
++build_cpu!$build_cpu$ac_delim
++build_vendor!$build_vendor$ac_delim
++build_os!$build_os$ac_delim
++host!$host$ac_delim
++host_cpu!$host_cpu$ac_delim
++host_vendor!$host_vendor$ac_delim
++host_os!$host_os$ac_delim
++target!$target$ac_delim
++target_cpu!$target_cpu$ac_delim
++target_vendor!$target_vendor$ac_delim
++target_os!$target_os$ac_delim
++CC!$CC$ac_delim
++CFLAGS!$CFLAGS$ac_delim
++LDFLAGS!$LDFLAGS$ac_delim
++CPPFLAGS!$CPPFLAGS$ac_delim
++ac_ct_CC!$ac_ct_CC$ac_delim
++EXEEXT!$EXEEXT$ac_delim
++OBJEXT!$OBJEXT$ac_delim
++INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
++INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim
++INSTALL_DATA!$INSTALL_DATA$ac_delim
++CYGPATH_W!$CYGPATH_W$ac_delim
++PACKAGE!$PACKAGE$ac_delim
++VERSION!$VERSION$ac_delim
++ACLOCAL!$ACLOCAL$ac_delim
++AUTOCONF!$AUTOCONF$ac_delim
++AUTOMAKE!$AUTOMAKE$ac_delim
++AUTOHEADER!$AUTOHEADER$ac_delim
++MAKEINFO!$MAKEINFO$ac_delim
++install_sh!$install_sh$ac_delim
++STRIP!$STRIP$ac_delim
++INSTALL_STRIP_PROGRAM!$INSTALL_STRIP_PROGRAM$ac_delim
++mkdir_p!$mkdir_p$ac_delim
++AWK!$AWK$ac_delim
++SET_MAKE!$SET_MAKE$ac_delim
++am__leading_dot!$am__leading_dot$ac_delim
++AMTAR!$AMTAR$ac_delim
++am__tar!$am__tar$ac_delim
++am__untar!$am__untar$ac_delim
++DEPDIR!$DEPDIR$ac_delim
++am__include!$am__include$ac_delim
++am__quote!$am__quote$ac_delim
++AMDEP_TRUE!$AMDEP_TRUE$ac_delim
++AMDEP_FALSE!$AMDEP_FALSE$ac_delim
++AMDEPBACKSLASH!$AMDEPBACKSLASH$ac_delim
++CCDEPMODE!$CCDEPMODE$ac_delim
++am__fastdepCC_TRUE!$am__fastdepCC_TRUE$ac_delim
++am__fastdepCC_FALSE!$am__fastdepCC_FALSE$ac_delim
++LN_S!$LN_S$ac_delim
++RANLIB!$RANLIB$ac_delim
++LIBTOOL!$LIBTOOL$ac_delim
++WARN_CFLAGS!$WARN_CFLAGS$ac_delim
++NO_WERROR!$NO_WERROR$ac_delim
++YACC!$YACC$ac_delim
++YFLAGS!$YFLAGS$ac_delim
++LEX!$LEX$ac_delim
++LEX_OUTPUT_ROOT!$LEX_OUTPUT_ROOT$ac_delim
++LEXLIB!$LEXLIB$ac_delim
++CPP!$CPP$ac_delim
++_ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+   fi
+-fi # test -n "$CONFIG_FILES"
++done
++
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
++_ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++CEOF$ac_eof
++_ACEOF
++
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++GREP!$GREP$ac_delim
++EGREP!$EGREP$ac_delim
++ALLOCA!$ALLOCA$ac_delim
++USE_NLS!$USE_NLS$ac_delim
++MSGFMT!$MSGFMT$ac_delim
++GMSGFMT!$GMSGFMT$ac_delim
++XGETTEXT!$XGETTEXT$ac_delim
++USE_INCLUDED_LIBINTL!$USE_INCLUDED_LIBINTL$ac_delim
++CATALOGS!$CATALOGS$ac_delim
++CATOBJEXT!$CATOBJEXT$ac_delim
++DATADIRNAME!$DATADIRNAME$ac_delim
++GMOFILES!$GMOFILES$ac_delim
++INSTOBJEXT!$INSTOBJEXT$ac_delim
++INTLDEPS!$INTLDEPS$ac_delim
++INTLLIBS!$INTLLIBS$ac_delim
++INTLOBJS!$INTLOBJS$ac_delim
++POFILES!$POFILES$ac_delim
++POSUB!$POSUB$ac_delim
++INCLUDE_LOCALE_H!$INCLUDE_LOCALE_H$ac_delim
++GT_NO!$GT_NO$ac_delim
++GT_YES!$GT_YES$ac_delim
++MKINSTALLDIRS!$MKINSTALLDIRS$ac_delim
++l!$l$ac_delim
++MAINTAINER_MODE_TRUE!$MAINTAINER_MODE_TRUE$ac_delim
++MAINTAINER_MODE_FALSE!$MAINTAINER_MODE_FALSE$ac_delim
++MAINT!$MAINT$ac_delim
++HDEFINES!$HDEFINES$ac_delim
++AR!$AR$ac_delim
++CC_FOR_BUILD!$CC_FOR_BUILD$ac_delim
++EXEEXT_FOR_BUILD!$EXEEXT_FOR_BUILD$ac_delim
++DEMANGLER_NAME!$DEMANGLER_NAME$ac_delim
++NLMCONV_DEFS!$NLMCONV_DEFS$ac_delim
++BUILD_NLMCONV!$BUILD_NLMCONV$ac_delim
++BUILD_SRCONV!$BUILD_SRCONV$ac_delim
++BUILD_DLLTOOL!$BUILD_DLLTOOL$ac_delim
++DLLTOOL_DEFS!$DLLTOOL_DEFS$ac_delim
++BUILD_WINDRES!$BUILD_WINDRES$ac_delim
++BUILD_DLLWRAP!$BUILD_DLLWRAP$ac_delim
++BUILD_MISC!$BUILD_MISC$ac_delim
++OBJDUMP_DEFS!$OBJDUMP_DEFS$ac_delim
++EMULATION!$EMULATION$ac_delim
++EMULATION_VECTOR!$EMULATION_VECTOR$ac_delim
++LIBOBJS!$LIBOBJS$ac_delim
++LTLIBOBJS!$LTLIBOBJS$ac_delim
++_ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 44; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
++  fi
++done
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-2.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end
++_ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++:end
++s/|#_!!_#|//g
++CEOF$ac_eof
+ _ACEOF
++
++
++# VPATH may cause trouble with some makes, so we remove $(srcdir),
++# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
++# trailing colons and then remove the whole line if VPATH becomes empty
++# (actually we leave an empty line to preserve line numbers).
++if test "x$srcdir" = x.; then
++  ac_vpsub='/^[        ]*VPATH[        ]*=/{
++s/:*\$(srcdir):*/:/
++s/:*\${srcdir}:*/:/
++s/:*@srcdir@:*/:/
++s/^\([^=]*=[   ]*\):*/\1/
++s/:*$//
++s/^[^=]*=[     ]*$//
++}'
++fi
++
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+-  case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++fi # test -n "$CONFIG_FILES"
++
++
++for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS
++do
++  case $ac_tag in
++  :[FHLC]) ac_mode=$ac_tag; continue;;
++  esac
++  case $ac_mode$ac_tag in
++  :[FHL]*:*);;
++  :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
++echo "$as_me: error: Invalid tag $ac_tag." >&2;}
++   { (exit 1); exit 1; }; };;
++  :[FH]-) ac_tag=-:-;;
++  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
++  esac
++  ac_save_IFS=$IFS
++  IFS=:
++  set x $ac_tag
++  IFS=$ac_save_IFS
++  shift
++  ac_file=$1
++  shift
++
++  case $ac_mode in
++  :L) ac_source=$1;;
++  :[FH])
++    ac_file_inputs=
++    for ac_f
++    do
++      case $ac_f in
++      -) ac_f="$tmp/stdin";;
++      *) # Look for the file first in the build tree, then in the source tree
++       # (if the path is not absolute).  The absolute path cannot be DOS-style,
++       # because $ac_f cannot contain `:'.
++       test -f "$ac_f" ||
++         case $ac_f in
++         [\\/$]*) false;;
++         *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
++         esac ||
++         { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
++echo "$as_me: error: cannot find input file: $ac_f" >&2;}
++   { (exit 1); exit 1; }; };;
++      esac
++      ac_file_inputs="$ac_file_inputs $ac_f"
++    done
++
++    # Let's still pretend it is `configure' which instantiates (i.e., don't
++    # use $as_me), people would be surprised to read:
++    #    /* config.h.  Generated by config.status.  */
++    configure_input="Generated from "`IFS=:
++        echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."
++    if test x"$ac_file" != x-; then
++      configure_input="$ac_file.  $configure_input"
++      { echo "$as_me:$LINENO: creating $ac_file" >&5
++echo "$as_me: creating $ac_file" >&6;}
++    fi
++
++    case $ac_tag in
++    *:-:* | *:-) cat >"$tmp/stdin";;
++    esac
++    ;;
+   esac
+-  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
+-  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
++  ac_dir=`$as_dirname -- "$ac_file" ||
+ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$ac_file" : 'X\(//\)[^/]' \| \
+        X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++  { as_dir="$ac_dir"
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+   ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  case $ac_mode in
++  :F)
++  #
++  # CONFIG_FILE
++  #
+   case $INSTALL in
+   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+-  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
++  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+   esac
++_ACEOF
+-  if test x"$ac_file" != x-; then
+-    { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-    rm -f "$ac_file"
+-  fi
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    configure_input=
+-  else
+-    configure_input="$ac_file.  "
+-  fi
+-  configure_input=$configure_input"Generated from `echo $ac_file_in |
+-                                   sed 's,.*/,,'` by configure."
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
++cat >>$CONFIG_STATUS <<\_ACEOF
++# If the template does not know about datarootdir, expand it.
++# FIXME: This hack should be removed a few years after 2.60.
++ac_datarootdir_hack=; ac_datarootdir_seen=
++
++case `sed -n '/datarootdir/ {
++  p
++  q
++}
++/@datadir@/p
++/@docdir@/p
++/@infodir@/p
++/@localedir@/p
++/@mandir@/p
++' $ac_file_inputs` in
++*datarootdir*) ac_datarootdir_seen=yes;;
++*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
++  { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
++echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
++_ACEOF
++cat >>$CONFIG_STATUS <<_ACEOF
++  ac_datarootdir_hack='
++  s&@datadir@&$datadir&g
++  s&@docdir@&$docdir&g
++  s&@infodir@&$infodir&g
++  s&@localedir@&$localedir&g
++  s&@mandir@&$mandir&g
++    s&\\\${datarootdir}&$datarootdir&g' ;;
++esac
+ _ACEOF
++
++# Neutralize VPATH when `$srcdir' = `.'.
++# Shell code in configure.ac might set extrasub.
++# FIXME: do we really want to maintain this feature?
+ cat >>$CONFIG_STATUS <<_ACEOF
+   sed "$ac_vpsub
+ $extrasub
+@@ -11790,248 +12317,130 @@ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+ :t
+ /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+-s,@configure_input@,$configure_input,;t t
+-s,@srcdir@,$ac_srcdir,;t t
+-s,@abs_srcdir@,$ac_abs_srcdir,;t t
+-s,@top_srcdir@,$ac_top_srcdir,;t t
+-s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+-s,@builddir@,$ac_builddir,;t t
+-s,@abs_builddir@,$ac_abs_builddir,;t t
+-s,@top_builddir@,$ac_top_builddir,;t t
+-s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
+-s,@INSTALL@,$ac_INSTALL,;t t
+-" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
+-  rm -f $tmp/stdin
+-  if test x"$ac_file" != x-; then
+-    mv $tmp/out $ac_file
+-  else
+-    cat $tmp/out
+-    rm -f $tmp/out
+-  fi
+-
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_HEADER section.
+-#
+-
+-# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
+-# NAME is the cpp macro being defined and VALUE is the value it is being given.
+-#
+-# ac_d sets the value in "#define NAME VALUE" lines.
+-ac_dA='s,^\([  ]*\)#\([        ]*define[       ][      ]*\)'
+-ac_dB='[       ].*$,\1#\2'
+-ac_dC=' '
+-ac_dD=',;t'
+-# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
+-ac_uA='s,^\([  ]*\)#\([        ]*\)undef\([    ][      ]*\)'
+-ac_uB='$,\1#\2define\3'
+-ac_uC=' '
+-ac_uD=',;t'
++s&@configure_input@&$configure_input&;t t
++s&@top_builddir@&$ac_top_builddir_sub&;t t
++s&@srcdir@&$ac_srcdir&;t t
++s&@abs_srcdir@&$ac_abs_srcdir&;t t
++s&@top_srcdir@&$ac_top_srcdir&;t t
++s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
++s&@builddir@&$ac_builddir&;t t
++s&@abs_builddir@&$ac_abs_builddir&;t t
++s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
++s&@INSTALL@&$ac_INSTALL&;t t
++$ac_datarootdir_hack
++" $ac_file_inputs | sed -f "$tmp/subs-1.sed" | sed -f "$tmp/subs-2.sed" >$tmp/out
++
++test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
++  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
++  { ac_out=`sed -n '/^[        ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
++  { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&5
++echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&2;}
+-for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
++  rm -f "$tmp/stdin"
+   case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++  -) cat "$tmp/out"; rm -f "$tmp/out";;
++  *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;
+   esac
++ ;;
++  :H)
++  #
++  # CONFIG_HEADER
++  #
++_ACEOF
++
++# Transform confdefs.h into a sed script `conftest.defines', that
++# substitutes the proper values into config.h.in to produce config.h.
++rm -f conftest.defines conftest.tail
++# First, append a space to every undef/define line, to ease matching.
++echo 's/$/ /' >conftest.defines
++# Then, protect against being on the right side of a sed subst, or in
++# an unquoted here document, in config.status.  If some macros were
++# called several times there might be several #defines for the same
++# symbol, which is useless.  But do not sort them, since the last
++# AC_DEFINE must be honored.
++ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
++# These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where
++# NAME is the cpp macro being defined, VALUE is the value it is being given.
++# PARAMS is the parameter list in the macro definition--in most cases, it's
++# just an empty string.
++ac_dA='s,^\\([         #]*\\)[^        ]*\\([  ]*'
++ac_dB='\\)[    (].*,\\1define\\2'
++ac_dC=' '
++ac_dD=' ,'
+-  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       # Do quote $f, to prevent DOS paths from being IFS'd.
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
+-  # Remove the trailing spaces.
+-  sed 's/[     ]*$//' $ac_file_inputs >$tmp/in
+-
+-_ACEOF
+-
+-# Transform confdefs.h into two sed scripts, `conftest.defines' and
+-# `conftest.undefs', that substitutes the proper values into
+-# config.h.in to produce config.h.  The first handles `#define'
+-# templates, and the second `#undef' templates.
+-# And first: Protect against being on the right side of a sed subst in
+-# config.status.  Protect against being in an unquoted here document
+-# in config.status.
+-rm -f conftest.defines conftest.undefs
+-# Using a here document instead of a string reduces the quoting nightmare.
+-# Putting comments in sed scripts is not portable.
+-#
+-# `end' is used to avoid that the second main sed command (meant for
+-# 0-ary CPP macros) applies to n-ary macro definitions.
+-# See the Autoconf documentation for `clear'.
+-cat >confdef2sed.sed <<\_ACEOF
+-s/[\\&,]/\\&/g
+-s,[\\$`],\\&,g
+-t clear
+-: clear
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
+-t end
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
+-: end
+-_ACEOF
+-# If some macros were called several times there might be several times
+-# the same #defines, which is useless.  Nevertheless, we may not want to
+-# sort them, since we want the *last* AC-DEFINE to be honored.
+-uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
+-sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
+-rm -f confdef2sed.sed
++uniq confdefs.h |
++  sed -n '
++      t rset
++      :rset
++      s/^[     ]*#[    ]*define[       ][      ]*//
++      t ok
++      d
++      :ok
++      s/[\\&,]/\\&/g
++      s/^\('"$ac_word_re"'\)\(([^()]*)\)[      ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p
++      s/^\('"$ac_word_re"'\)[  ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p
++  ' >>conftest.defines
+-# This sed command replaces #undef with comments.  This is necessary, for
++# Remove the space that was appended to ease matching.
++# Then replace #undef with comments.  This is necessary, for
+ # example, in the case of _POSIX_SOURCE, which is predefined and required
+ # on some systems where configure will not decide to define it.
+-cat >>conftest.undefs <<\_ACEOF
+-s,^[   ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
++# (The regexp can be short, since the line contains either #define or #undef.)
++echo 's/ $//
++s,^[   #]*u.*,/* & */,' >>conftest.defines
++
++# Break up conftest.defines:
++ac_max_sed_lines=50
++
++# First sed command is:        sed -f defines.sed $ac_file_inputs >"$tmp/out1"
++# Second one is:       sed -f defines.sed "$tmp/out1" >"$tmp/out2"
++# Third one will be:   sed -f defines.sed "$tmp/out2" >"$tmp/out1"
++# et cetera.
++ac_in='$ac_file_inputs'
++ac_out='"$tmp/out1"'
++ac_nxt='"$tmp/out2"'
++
++while :
++do
++  # Write a here document:
++    cat >>$CONFIG_STATUS <<_ACEOF
++    # First, check the format of the line:
++    cat >"\$tmp/defines.sed" <<\\CEOF
++/^[    ]*#[    ]*undef[        ][      ]*$ac_word_re[  ]*\$/b def
++/^[    ]*#[    ]*define[       ][      ]*$ac_word_re[(         ]/b def
++b
++:def
+ _ACEOF
+-
+-# Break up conftest.defines because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
+-echo '  if grep "^[    ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
+-echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
+-echo '  :' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.defines >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/defines.sed.
+-  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#define' lines.
+-  echo '/^[    ]*#[    ]*define/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
++  sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS
+   echo 'CEOF
+-  sed -f $tmp/defines.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
++    sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS
++  ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in
++  sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail
++  grep . conftest.tail >/dev/null || break
+   rm -f conftest.defines
+   mv conftest.tail conftest.defines
+ done
+-rm -f conftest.defines
+-echo '  fi # grep' >>$CONFIG_STATUS
+-echo >>$CONFIG_STATUS
+-
+-# Break up conftest.undefs because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.undefs >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/undefs.sed.
+-  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#undef'
+-  echo '/^[    ]*#[    ]*undef/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
+-  echo 'CEOF
+-  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
+-  rm -f conftest.undefs
+-  mv conftest.tail conftest.undefs
+-done
+-rm -f conftest.undefs
++rm -f conftest.defines conftest.tail
++echo "ac_result=$ac_in" >>$CONFIG_STATUS
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    echo "/* Generated by configure.  */" >$tmp/config.h
+-  else
+-    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
+-  fi
+-  cat $tmp/in >>$tmp/config.h
+-  rm -f $tmp/in
+   if test x"$ac_file" != x-; then
+-    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
++    echo "/* $configure_input  */" >"$tmp/config.h"
++    cat "$ac_result" >>"$tmp/config.h"
++    if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then
+       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
+ echo "$as_me: $ac_file is unchanged" >&6;}
+     else
+-      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_file" : 'X\(//\)[^/]' \| \
+-       X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-      { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+       rm -f $ac_file
+-      mv $tmp/config.h $ac_file
++      mv "$tmp/config.h" $ac_file
+     fi
+   else
+-    cat $tmp/config.h
+-    rm -f $tmp/config.h
++    echo "/* $configure_input  */"
++    cat "$ac_result"
+   fi
++  rm -f "$tmp/out12"
+ # Compute $ac_file's index in $config_headers.
+ _am_stamp_count=1
+ for _am_header in $config_headers :; do
+@@ -12042,135 +12451,39 @@ for _am_header in $config_headers :; do
+       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+   esac
+ done
+-echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
++echo "timestamp for $ac_file" >`$as_dirname -- $ac_file ||
+ $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X$ac_file : 'X\(//\)[^/]' \| \
+        X$ac_file : 'X\(//\)$' \| \
+-       X$ac_file : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X$ac_file : 'X\(/\)' \| . 2>/dev/null ||
+ echo X$ac_file |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`/stamp-h$_am_stamp_count
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_COMMANDS section.
+-#
+-for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
+-  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
+-  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
+-$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_dest" : 'X\(//\)[^/]' \| \
+-       X"$ac_dest" : 'X\(//\)$' \| \
+-       X"$ac_dest" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_dest" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+-  ac_builddir=.
+-
+-if test "$ac_dir" != .; then
+-  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
+-
+-case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
+-    ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
+-    ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`/stamp-h$_am_stamp_count
++ ;;
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  :C)  { echo "$as_me:$LINENO: executing $ac_file commands" >&5
++echo "$as_me: executing $ac_file commands" >&6;}
++ ;;
++  esac
+-  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
+-echo "$as_me: executing $ac_dest commands" >&6;}
+-  case $ac_dest in
+-    depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
++  case $ac_file$ac_mode in
++    "depfiles":C) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
+   # Strip MF so we end up with the name of the file.
+   mf=`echo "$mf" | sed -e 's/:.*$//'`
+   # Check whether this is an Automake generated Makefile or not.
+@@ -12180,18 +12493,29 @@ echo "$as_me: executing $ac_dest command
+   # each Makefile.in and add a new line on top of each file to say so.
+   # So let's grep whole file.
+   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
+-    dirpart=`(dirname "$mf") 2>/dev/null ||
++    dirpart=`$as_dirname -- "$mf" ||
+ $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$mf" : 'X\(//\)[^/]' \| \
+        X"$mf" : 'X\(//\)$' \| \
+-       X"$mf" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$mf" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   else
+     continue
+   fi
+@@ -12213,58 +12537,84 @@ echo X"$mf" |
+        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+     # Make sure the directory exists.
+     test -f "$dirpart/$file" && continue
+-    fdir=`(dirname "$file") 2>/dev/null ||
++    fdir=`$as_dirname -- "$file" ||
+ $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$file" : 'X\(//\)[^/]' \| \
+        X"$file" : 'X\(//\)$' \| \
+-       X"$file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    { if $as_mkdir_p; then
+-    mkdir -p $dirpart/$fdir
+-  else
+-    as_dir=$dirpart/$fdir
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++    { as_dir=$dirpart/$fdir
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
+-echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+     # echo "creating $dirpart/$file"
+     echo '# dummy' > "$dirpart/$file"
+   done
+ done
+  ;;
+-    default )
++    "default":C)
+ case "x$CONFIG_FILES" in
+ *) sed -e '/POTFILES =/r po/POTFILES' po/Makefile.in > po/Makefile ;;
+ esac
+  ;;
++
+   esac
+-done
+-_ACEOF
++done # for ac_tag
+-cat >>$CONFIG_STATUS <<\_ACEOF
+ { (exit 0); exit 0; }
+ _ACEOF
+diff -Nrup binutils-2.17/binutils/doc/Makefile.in binutils-2.17-atmel/binutils/doc/Makefile.in
+--- binutils-2.17/binutils/doc/Makefile.in     2006-06-03 06:45:50.000000000 +0200
++++ binutils-2.17-atmel/binutils/doc/Makefile.in       2007-02-20 16:07:21.000000000 +0100
+@@ -109,6 +109,7 @@ EXEEXT = @EXEEXT@
+ EXEEXT_FOR_BUILD = @EXEEXT_FOR_BUILD@
+ GMOFILES = @GMOFILES@
+ GMSGFMT = @GMSGFMT@
++GREP = @GREP@
+ GT_NO = @GT_NO@
+ GT_YES = @GT_YES@
+ HDEFINES = @HDEFINES@
+@@ -159,9 +160,8 @@ VERSION = @VERSION@
+ WARN_CFLAGS = @WARN_CFLAGS@
+ XGETTEXT = @XGETTEXT@
+ YACC = @YACC@
++YFLAGS = @YFLAGS@
+ ac_ct_CC = @ac_ct_CC@
+-ac_ct_RANLIB = @ac_ct_RANLIB@
+-ac_ct_STRIP = @ac_ct_STRIP@
+ am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+ am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+ am__include = @am__include@
+@@ -178,6 +178,7 @@ build_vendor = @build_vendor@
+ datadir = @datadir@
+ datarootdir = @datarootdir@
+ docdir = @docdir@
++dvidir = @dvidir@
+ exec_prefix = @exec_prefix@
+ host = @host@
+ host_alias = @host_alias@
+@@ -191,12 +192,15 @@ install_sh = @install_sh@
+ l = @l@
+ libdir = @libdir@
+ libexecdir = @libexecdir@
++localedir = @localedir@
+ localstatedir = @localstatedir@
+ mandir = @mandir@
+ mkdir_p = @mkdir_p@
+ oldincludedir = @oldincludedir@
++pdfdir = @pdfdir@
+ prefix = @prefix@
+ program_transform_name = @program_transform_name@
++psdir = @psdir@
+ sbindir = @sbindir@
+ sharedstatedir = @sharedstatedir@
+ sysconfdir = @sysconfdir@
+@@ -368,10 +372,13 @@ dist-info: $(INFO_DEPS)
+           $(srcdir)/*) base=`echo "$$base" | sed "s|^$$srcdirstrip/||"`;; \
+         esac; \
+         if test -f $$base; then d=.; else d=$(srcdir); fi; \
+-        for file in $$d/$$base*; do \
+-          relfile=`expr "$$file" : "$$d/\(.*\)"`; \
+-          test -f $(distdir)/$$relfile || \
+-            cp -p $$file $(distdir)/$$relfile; \
++        base_i=`echo "$$base" | sed 's|\.info$$||;s|$$|.i|'`; \
++        for file in $$d/$$base $$d/$$base-[0-9] $$d/$$base-[0-9][0-9] $$d/$$base_i[0-9] $$d/$$base_i[0-9][0-9]; do \
++          if test -f $$file; then \
++            relfile=`expr "$$file" : "$$d/\(.*\)"`; \
++            test -f $(distdir)/$$relfile || \
++              cp -p $$file $(distdir)/$$relfile; \
++          else :; fi; \
+         done; \
+       done
+diff -Nrup binutils-2.17/binutils/Makefile.am binutils-2.17-atmel/binutils/Makefile.am
+--- binutils-2.17/binutils/Makefile.am 2006-04-06 23:49:26.000000000 +0200
++++ binutils-2.17-atmel/binutils/Makefile.am   2007-02-12 15:37:09.000000000 +0100
+@@ -511,7 +511,7 @@ readelf.o: readelf.c dwarf.h ../bfd/bfd.
+   $(INCDIR)/symcat.h $(INCDIR)/elf/dwarf2.h $(INCDIR)/elf/common.h \
+   $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/alpha.h \
+   $(INCDIR)/elf/reloc-macros.h $(INCDIR)/elf/arc.h $(INCDIR)/elf/arm.h \
+-  $(INCDIR)/elf/avr.h $(INCDIR)/elf/bfin.h $(INCDIR)/elf/cris.h \
++  $(INCDIR)/elf/avr.h $(INCDIR)/elf/avr32.h $(INCDIR)/elf/bfin.h $(INCDIR)/elf/cris.h \
+   $(INCDIR)/elf/d10v.h $(INCDIR)/elf/d30v.h $(INCDIR)/elf/dlx.h \
+   $(INCDIR)/elf/fr30.h $(INCDIR)/elf/frv.h $(INCDIR)/elf/h8.h \
+   $(INCDIR)/elf/hppa.h $(INCDIR)/elf/i386.h $(INCDIR)/elf/i370.h \
+diff -Nrup binutils-2.17/binutils/Makefile.in binutils-2.17-atmel/binutils/Makefile.in
+--- binutils-2.17/binutils/Makefile.in 2006-06-02 04:21:08.000000000 +0200
++++ binutils-2.17-atmel/binutils/Makefile.in   2007-02-20 16:07:22.000000000 +0100
+@@ -266,6 +266,7 @@ EXEEXT = @EXEEXT@
+ EXEEXT_FOR_BUILD = @EXEEXT_FOR_BUILD@
+ GMOFILES = @GMOFILES@
+ GMSGFMT = @GMSGFMT@
++GREP = @GREP@
+ GT_NO = @GT_NO@
+ GT_YES = @GT_YES@
+ HDEFINES = @HDEFINES@
+@@ -316,9 +317,8 @@ VERSION = @VERSION@
+ WARN_CFLAGS = @WARN_CFLAGS@
+ XGETTEXT = @XGETTEXT@
+ YACC = `if [ -f ../bison/bison ]; then echo ../bison/bison -y -L$(srcdir)/../bison/; else echo @YACC@; fi`
++YFLAGS = -d
+ ac_ct_CC = @ac_ct_CC@
+-ac_ct_RANLIB = @ac_ct_RANLIB@
+-ac_ct_STRIP = @ac_ct_STRIP@
+ am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+ am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+ am__include = @am__include@
+@@ -335,6 +335,7 @@ build_vendor = @build_vendor@
+ datadir = @datadir@
+ datarootdir = @datarootdir@
+ docdir = @docdir@
++dvidir = @dvidir@
+ exec_prefix = @exec_prefix@
+ host = @host@
+ host_alias = @host_alias@
+@@ -348,12 +349,15 @@ install_sh = @install_sh@
+ l = @l@
+ libdir = @libdir@
+ libexecdir = @libexecdir@
++localedir = @localedir@
+ localstatedir = @localstatedir@
+ mandir = @mandir@
+ mkdir_p = @mkdir_p@
+ oldincludedir = @oldincludedir@
++pdfdir = @pdfdir@
+ prefix = @prefix@
+ program_transform_name = @program_transform_name@
++psdir = @psdir@
+ sbindir = @sbindir@
+ sharedstatedir = @sharedstatedir@
+ sysconfdir = @sysconfdir@
+@@ -365,7 +369,6 @@ target_vendor = @target_vendor@
+ AUTOMAKE_OPTIONS = cygnus dejagnu
+ SUBDIRS = doc po
+ tooldir = $(exec_prefix)/$(target_alias)
+-YFLAGS = -d
+ AM_CFLAGS = $(WARN_CFLAGS)
+ # these two are almost the same program
+@@ -1264,7 +1267,7 @@ readelf.o: readelf.c dwarf.h ../bfd/bfd.
+   $(INCDIR)/symcat.h $(INCDIR)/elf/dwarf2.h $(INCDIR)/elf/common.h \
+   $(INCDIR)/elf/external.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/alpha.h \
+   $(INCDIR)/elf/reloc-macros.h $(INCDIR)/elf/arc.h $(INCDIR)/elf/arm.h \
+-  $(INCDIR)/elf/avr.h $(INCDIR)/elf/bfin.h $(INCDIR)/elf/cris.h \
++  $(INCDIR)/elf/avr.h $(INCDIR)/elf/avr32.h $(INCDIR)/elf/bfin.h $(INCDIR)/elf/cris.h \
+   $(INCDIR)/elf/d10v.h $(INCDIR)/elf/d30v.h $(INCDIR)/elf/dlx.h \
+   $(INCDIR)/elf/fr30.h $(INCDIR)/elf/frv.h $(INCDIR)/elf/h8.h \
+   $(INCDIR)/elf/hppa.h $(INCDIR)/elf/i386.h $(INCDIR)/elf/i370.h \
+diff -Nrup binutils-2.17/binutils/readelf.c binutils-2.17-atmel/binutils/readelf.c
+--- binutils-2.17/binutils/readelf.c   2006-03-10 18:20:28.000000000 +0100
++++ binutils-2.17-atmel/binutils/readelf.c     2007-02-12 15:37:09.000000000 +0100
+@@ -71,6 +71,7 @@
+ #include "elf/arc.h"
+ #include "elf/arm.h"
+ #include "elf/avr.h"
++#include "elf/avr32.h"
+ #include "elf/bfin.h"
+ #include "elf/cris.h"
+ #include "elf/d10v.h"
+@@ -590,6 +591,7 @@ guess_is_rela (unsigned long e_machine)
+     case EM_MCORE:
+     case EM_IA_64:
+     case EM_AVR:
++    case EM_AVR32:
+     case EM_AVR_OLD:
+     case EM_CRIS:
+     case EM_860:
+@@ -959,6 +961,10 @@ dump_relocations (FILE *file,
+         rtype = elf_avr_reloc_type (type);
+         break;
++      case EM_AVR32:
++        rtype = elf_avr32_reloc_type (type);
++        break;
++
+       case EM_OLD_SPARCV9:
+       case EM_SPARC32PLUS:
+       case EM_SPARCV9:
+@@ -1670,6 +1676,7 @@ get_machine_name (unsigned e_machine)
+     case EM_VAX:              return "Digital VAX";
+     case EM_AVR_OLD:
+     case EM_AVR:              return "Atmel AVR 8-bit microcontroller";
++    case EM_AVR32:            return "Atmel AVR32";
+     case EM_CRIS:             return "Axis Communications 32-bit embedded processor";
+     case EM_JAVELIN:          return "Infineon Technologies 32-bit embedded cpu";
+     case EM_FIREPATH:         return "Element 14 64-bit DSP processor";
+diff -Nrup binutils-2.17/configure binutils-2.17-atmel/configure
+--- binutils-2.17/configure    2006-04-06 23:49:25.000000000 +0200
++++ binutils-2.17-atmel/configure      2007-02-20 16:06:36.000000000 +0100
+@@ -899,7 +899,7 @@ host_libs="intl mmalloc libiberty opcode
+ # know that we are building the simulator.
+ # binutils, gas and ld appear in that order because it makes sense to run
+ # "make check" in that particular order.
+-host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
++host_tools="byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
+ # libgcj represents the runtime libraries only used by gcj.
+ libgcj="target-libffi \
+@@ -1064,6 +1064,9 @@ unsupported_languages=
+ # exist yet.
+ case "${host}" in
++  avr32*-*-*)
++    noconfigdirs="$noconfigdirs readline gdb"
++    ;;
+   hppa*64*-*-*)
+     noconfigdirs="$noconfigdirs byacc"
+     ;;
+@@ -1863,7 +1866,7 @@ else
+   # 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:1867: checking for $ac_word" >&5
++echo "configure:1870: 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
+@@ -1893,7 +1896,7 @@ if test -z "$CC"; then
+   # 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:1897: checking for $ac_word" >&5
++echo "configure:1900: 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
+@@ -1944,7 +1947,7 @@ fi
+       # 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:1948: checking for $ac_word" >&5
++echo "configure:1951: 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
+@@ -1976,7 +1979,7 @@ fi
+ fi
+ echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
+-echo "configure:1980: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
++echo "configure:1983: 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.
+@@ -1987,12 +1990,12 @@ cross_compiling=$ac_cv_prog_cc_cross
+ cat > conftest.$ac_ext << EOF
+-#line 1991 "configure"
++#line 1994 "configure"
+ #include "confdefs.h"
+ main(){return(0);}
+ EOF
+-if { (eval echo configure:1996: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
++if { (eval echo configure:1999: \"$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
+@@ -2018,12 +2021,12 @@ if test $ac_cv_prog_cc_works = no; 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:2022: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
++echo "configure:2025: 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:2027: checking whether we are using GNU C" >&5
++echo "configure:2030: 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
+@@ -2032,7 +2035,7 @@ else
+   yes;
+ #endif
+ EOF
+-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:2036: \"$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:2039: \"$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
+@@ -2051,7 +2054,7 @@ ac_test_CFLAGS="${CFLAGS+set}"
+ ac_save_CFLAGS="$CFLAGS"
+ CFLAGS=
+ echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
+-echo "configure:2055: checking whether ${CC-cc} accepts -g" >&5
++echo "configure:2058: 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
+@@ -2118,7 +2121,7 @@ fi
+ # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:2122: checking for $ac_word" >&5
++echo "configure:2125: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_GNATBIND'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -2150,7 +2153,7 @@ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "gnatbind", so it can be a program name with args.
+ set dummy gnatbind; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:2154: checking for $ac_word" >&5
++echo "configure:2157: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_GNATBIND'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -2183,7 +2186,7 @@ fi
+ fi
+ echo $ac_n "checking whether compiler driver understands Ada""... $ac_c" 1>&6
+-echo "configure:2187: checking whether compiler driver understands Ada" >&5
++echo "configure:2190: checking whether compiler driver understands Ada" >&5
+ if eval "test \"`echo '$''{'acx_cv_cc_gcc_supports_ada'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -2215,7 +2218,7 @@ else
+ fi
+ echo $ac_n "checking how to compare bootstrapped objects""... $ac_c" 1>&6
+-echo "configure:2219: checking how to compare bootstrapped objects" >&5
++echo "configure:2222: checking how to compare bootstrapped objects" >&5
+ if eval "test \"`echo '$''{'gcc_cv_prog_cmp_skip'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -2313,9 +2316,9 @@ saved_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS $gmpinc"
+ # Check GMP actually works
+ echo $ac_n "checking for correct version of gmp.h""... $ac_c" 1>&6
+-echo "configure:2317: checking for correct version of gmp.h" >&5
++echo "configure:2320: checking for correct version of gmp.h" >&5
+ cat > conftest.$ac_ext <<EOF
+-#line 2319 "configure"
++#line 2322 "configure"
+ #include "confdefs.h"
+ #include "gmp.h"
+ int main() {
+@@ -2326,7 +2329,7 @@ choke me
+ ; return 0; }
+ EOF
+-if { (eval echo configure:2330: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
++if { (eval echo configure:2333: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+   rm -rf conftest*
+   echo "$ac_t""yes" 1>&6
+ else
+@@ -2339,12 +2342,12 @@ rm -f conftest*
+ if test x"$have_gmp" = xyes; then
+   echo $ac_n "checking for MPFR""... $ac_c" 1>&6
+-echo "configure:2343: checking for MPFR" >&5
++echo "configure:2346: checking for MPFR" >&5
+   saved_LIBS="$LIBS"
+   LIBS="$LIBS $gmplibs"
+   cat > conftest.$ac_ext <<EOF
+-#line 2348 "configure"
++#line 2351 "configure"
+ #include "confdefs.h"
+ #include <gmp.h>
+ #include <mpfr.h>
+@@ -2352,7 +2355,7 @@ int main() {
+ mpfr_t n; mpfr_init(n);
+ ; return 0; }
+ EOF
+-if { (eval echo configure:2356: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
++if { (eval echo configure:2359: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+   rm -rf conftest*
+   echo "$ac_t""yes" 1>&6
+ else
+@@ -3403,7 +3406,7 @@ do
+ # 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:3407: checking for $ac_word" >&5
++echo "configure:3410: 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
+@@ -3443,7 +3446,7 @@ do
+ # 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:3447: checking for $ac_word" >&5
++echo "configure:3450: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_BISON'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3482,7 +3485,7 @@ do
+ # 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:3486: checking for $ac_word" >&5
++echo "configure:3489: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_M4'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3521,7 +3524,7 @@ do
+ # 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:3525: checking for $ac_word" >&5
++echo "configure:3528: 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
+@@ -3561,7 +3564,7 @@ do
+ # 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:3565: checking for $ac_word" >&5
++echo "configure:3568: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_FLEX'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3600,7 +3603,7 @@ do
+ # 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:3604: checking for $ac_word" >&5
++echo "configure:3607: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_MAKEINFO'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3653,7 +3656,7 @@ do
+ # 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:3657: checking for $ac_word" >&5
++echo "configure:3660: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_EXPECT'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3694,7 +3697,7 @@ do
+ # 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:3698: checking for $ac_word" >&5
++echo "configure:3701: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_RUNTEST'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3742,7 +3745,7 @@ test -n "$target_alias" && ncn_target_to
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:3746: checking for $ac_word" >&5
++echo "configure:3749: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3773,7 +3776,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:3777: checking for $ac_word" >&5
++echo "configure:3780: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3817,7 +3820,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:3821: checking for $ac_word" >&5
++echo "configure:3824: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3848,7 +3851,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:3852: checking for $ac_word" >&5
++echo "configure:3855: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3892,7 +3895,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:3896: checking for $ac_word" >&5
++echo "configure:3899: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3923,7 +3926,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:3927: checking for $ac_word" >&5
++echo "configure:3930: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3967,7 +3970,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:3971: checking for $ac_word" >&5
++echo "configure:3974: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_LD'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -3998,7 +4001,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4002: checking for $ac_word" >&5
++echo "configure:4005: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_LD'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4042,7 +4045,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4046: checking for $ac_word" >&5
++echo "configure:4049: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_LIPO'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4073,7 +4076,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4077: checking for $ac_word" >&5
++echo "configure:4080: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_LIPO'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4117,7 +4120,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4121: checking for $ac_word" >&5
++echo "configure:4124: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_NM'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4148,7 +4151,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4152: checking for $ac_word" >&5
++echo "configure:4155: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_NM'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4192,7 +4195,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4196: checking for $ac_word" >&5
++echo "configure:4199: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4223,7 +4226,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4227: checking for $ac_word" >&5
++echo "configure:4230: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4262,7 +4265,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4266: checking for $ac_word" >&5
++echo "configure:4269: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4293,7 +4296,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4297: checking for $ac_word" >&5
++echo "configure:4300: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4332,7 +4335,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4336: checking for $ac_word" >&5
++echo "configure:4339: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_WINDRES'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4363,7 +4366,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4367: checking for $ac_word" >&5
++echo "configure:4370: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_WINDRES'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4407,7 +4410,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4411: checking for $ac_word" >&5
++echo "configure:4414: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_OBJCOPY'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4438,7 +4441,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4442: checking for $ac_word" >&5
++echo "configure:4445: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_OBJCOPY'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4482,7 +4485,7 @@ fi
+     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4486: checking for $ac_word" >&5
++echo "configure:4489: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4513,7 +4516,7 @@ fi
+     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4517: checking for $ac_word" >&5
++echo "configure:4520: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4577,7 +4580,7 @@ fi
+  if test -n "$with_build_time_tools"; then
+   for ncn_progname in cc gcc; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:4581: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:4584: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -4594,7 +4597,7 @@ if test -z "$ac_cv_prog_CC_FOR_TARGET"; 
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4598: checking for $ac_word" >&5
++echo "configure:4601: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_CC_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4625,7 +4628,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4629: checking for $ac_word" >&5
++echo "configure:4632: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_CC_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4668,7 +4671,7 @@ fi
+  if test -n "$with_build_time_tools"; then
+   for ncn_progname in c++ g++ cxx gxx; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:4672: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:4675: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -4685,7 +4688,7 @@ if test -z "$ac_cv_prog_CXX_FOR_TARGET";
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4689: checking for $ac_word" >&5
++echo "configure:4692: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_CXX_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4716,7 +4719,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4720: checking for $ac_word" >&5
++echo "configure:4723: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_CXX_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4759,7 +4762,7 @@ fi
+  if test -n "$with_build_time_tools"; then
+   for ncn_progname in gcc; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:4763: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:4766: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -4776,7 +4779,7 @@ if test -z "$ac_cv_prog_GCC_FOR_TARGET";
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4780: checking for $ac_word" >&5
++echo "configure:4783: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_GCC_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4807,7 +4810,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4811: checking for $ac_word" >&5
++echo "configure:4814: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_GCC_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4845,7 +4848,7 @@ fi
+  if test -n "$with_build_time_tools"; then
+   for ncn_progname in gcj; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:4849: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:4852: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -4862,7 +4865,7 @@ if test -z "$ac_cv_prog_GCJ_FOR_TARGET";
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4866: checking for $ac_word" >&5
++echo "configure:4869: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_GCJ_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4893,7 +4896,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4897: checking for $ac_word" >&5
++echo "configure:4900: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_GCJ_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4936,7 +4939,7 @@ fi
+  if test -n "$with_build_time_tools"; then
+   for ncn_progname in gfortran; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:4940: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:4943: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -4953,7 +4956,7 @@ if test -z "$ac_cv_prog_GFORTRAN_FOR_TAR
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4957: checking for $ac_word" >&5
++echo "configure:4960: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_GFORTRAN_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -4984,7 +4987,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:4988: checking for $ac_word" >&5
++echo "configure:4991: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_GFORTRAN_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5091,7 +5094,7 @@ rm conftest.c
+ if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for ar in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5095: checking for ar in $with_build_time_tools" >&5
++echo "configure:5098: checking for ar in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/ar; then
+       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
+       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
+@@ -5109,7 +5112,7 @@ if test -z "$ac_cv_path_AR_FOR_TARGET" ;
+   # Extract the first word of "ar", so it can be a program name with args.
+ set dummy ar; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5113: checking for $ac_word" >&5
++echo "configure:5116: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_AR_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5146,7 +5149,7 @@ if test -z "$ac_cv_path_AR_FOR_TARGET" ;
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in ar; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5150: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:5153: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -5163,7 +5166,7 @@ if test -z "$ac_cv_prog_AR_FOR_TARGET"; 
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5167: checking for $ac_word" >&5
++echo "configure:5170: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_AR_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5194,7 +5197,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5198: checking for $ac_word" >&5
++echo "configure:5201: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_AR_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5244,7 +5247,7 @@ fi
+ if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for as in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5248: checking for as in $with_build_time_tools" >&5
++echo "configure:5251: checking for as in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/as; then
+       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
+       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
+@@ -5262,7 +5265,7 @@ if test -z "$ac_cv_path_AS_FOR_TARGET" ;
+   # Extract the first word of "as", so it can be a program name with args.
+ set dummy as; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5266: checking for $ac_word" >&5
++echo "configure:5269: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_AS_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5299,7 +5302,7 @@ if test -z "$ac_cv_path_AS_FOR_TARGET" ;
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in as; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5303: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:5306: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -5316,7 +5319,7 @@ if test -z "$ac_cv_prog_AS_FOR_TARGET"; 
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5320: checking for $ac_word" >&5
++echo "configure:5323: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_AS_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5347,7 +5350,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5351: checking for $ac_word" >&5
++echo "configure:5354: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_AS_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5397,7 +5400,7 @@ fi
+ if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for dlltool in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5401: checking for dlltool in $with_build_time_tools" >&5
++echo "configure:5404: checking for dlltool in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/dlltool; then
+       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
+       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
+@@ -5415,7 +5418,7 @@ if test -z "$ac_cv_path_DLLTOOL_FOR_TARG
+   # Extract the first word of "dlltool", so it can be a program name with args.
+ set dummy dlltool; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5419: checking for $ac_word" >&5
++echo "configure:5422: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_DLLTOOL_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5452,7 +5455,7 @@ if test -z "$ac_cv_path_DLLTOOL_FOR_TARG
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in dlltool; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5456: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:5459: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -5469,7 +5472,7 @@ if test -z "$ac_cv_prog_DLLTOOL_FOR_TARG
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5473: checking for $ac_word" >&5
++echo "configure:5476: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5500,7 +5503,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5504: checking for $ac_word" >&5
++echo "configure:5507: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5550,7 +5553,7 @@ fi
+ if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for ld in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5554: checking for ld in $with_build_time_tools" >&5
++echo "configure:5557: checking for ld in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/ld; then
+       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
+       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
+@@ -5568,7 +5571,7 @@ if test -z "$ac_cv_path_LD_FOR_TARGET" ;
+   # Extract the first word of "ld", so it can be a program name with args.
+ set dummy ld; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5572: checking for $ac_word" >&5
++echo "configure:5575: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_LD_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5605,7 +5608,7 @@ if test -z "$ac_cv_path_LD_FOR_TARGET" ;
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in ld; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5609: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:5612: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -5622,7 +5625,7 @@ if test -z "$ac_cv_prog_LD_FOR_TARGET"; 
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5626: checking for $ac_word" >&5
++echo "configure:5629: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_LD_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5653,7 +5656,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5657: checking for $ac_word" >&5
++echo "configure:5660: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_LD_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5703,7 +5706,7 @@ fi
+ if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for lipo in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5707: checking for lipo in $with_build_time_tools" >&5
++echo "configure:5710: checking for lipo in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/lipo; then
+       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
+       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
+@@ -5721,7 +5724,7 @@ if test -z "$ac_cv_path_LIPO_FOR_TARGET"
+   # Extract the first word of "lipo", so it can be a program name with args.
+ set dummy lipo; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5725: checking for $ac_word" >&5
++echo "configure:5728: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_LIPO_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5758,7 +5761,7 @@ if test -z "$ac_cv_path_LIPO_FOR_TARGET"
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in lipo; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5762: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:5765: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -5775,7 +5778,7 @@ if test -z "$ac_cv_prog_LIPO_FOR_TARGET"
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5779: checking for $ac_word" >&5
++echo "configure:5782: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_LIPO_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5806,7 +5809,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5810: checking for $ac_word" >&5
++echo "configure:5813: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_LIPO_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5856,7 +5859,7 @@ fi
+ if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for nm in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5860: checking for nm in $with_build_time_tools" >&5
++echo "configure:5863: checking for nm in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/nm; then
+       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
+       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
+@@ -5874,7 +5877,7 @@ if test -z "$ac_cv_path_NM_FOR_TARGET" ;
+   # Extract the first word of "nm", so it can be a program name with args.
+ set dummy nm; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5878: checking for $ac_word" >&5
++echo "configure:5881: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_NM_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5911,7 +5914,7 @@ if test -z "$ac_cv_path_NM_FOR_TARGET" ;
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in nm; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:5915: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:5918: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -5928,7 +5931,7 @@ if test -z "$ac_cv_prog_NM_FOR_TARGET"; 
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5932: checking for $ac_word" >&5
++echo "configure:5935: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_NM_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -5959,7 +5962,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:5963: checking for $ac_word" >&5
++echo "configure:5966: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_NM_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6009,7 +6012,7 @@ fi
+ if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for objdump in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:6013: checking for objdump in $with_build_time_tools" >&5
++echo "configure:6016: checking for objdump in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/objdump; then
+       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
+       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
+@@ -6027,7 +6030,7 @@ if test -z "$ac_cv_path_OBJDUMP_FOR_TARG
+   # Extract the first word of "objdump", so it can be a program name with args.
+ set dummy objdump; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6031: checking for $ac_word" >&5
++echo "configure:6034: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_OBJDUMP_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6064,7 +6067,7 @@ if test -z "$ac_cv_path_OBJDUMP_FOR_TARG
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in objdump; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:6068: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:6071: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -6081,7 +6084,7 @@ if test -z "$ac_cv_prog_OBJDUMP_FOR_TARG
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6085: checking for $ac_word" >&5
++echo "configure:6088: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6112,7 +6115,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6116: checking for $ac_word" >&5
++echo "configure:6119: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6162,7 +6165,7 @@ fi
+ if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for ranlib in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:6166: checking for ranlib in $with_build_time_tools" >&5
++echo "configure:6169: checking for ranlib in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/ranlib; then
+       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
+       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
+@@ -6180,7 +6183,7 @@ if test -z "$ac_cv_path_RANLIB_FOR_TARGE
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6184: checking for $ac_word" >&5
++echo "configure:6187: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_RANLIB_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6217,7 +6220,7 @@ if test -z "$ac_cv_path_RANLIB_FOR_TARGE
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in ranlib; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:6221: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:6224: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -6234,7 +6237,7 @@ if test -z "$ac_cv_prog_RANLIB_FOR_TARGE
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6238: checking for $ac_word" >&5
++echo "configure:6241: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_RANLIB_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6265,7 +6268,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6269: checking for $ac_word" >&5
++echo "configure:6272: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_RANLIB_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6315,7 +6318,7 @@ fi
+ if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for strip in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:6319: checking for strip in $with_build_time_tools" >&5
++echo "configure:6322: checking for strip in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/strip; then
+       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
+       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
+@@ -6333,7 +6336,7 @@ if test -z "$ac_cv_path_STRIP_FOR_TARGET
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6337: checking for $ac_word" >&5
++echo "configure:6340: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_STRIP_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6370,7 +6373,7 @@ if test -z "$ac_cv_path_STRIP_FOR_TARGET
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in strip; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:6374: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:6377: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -6387,7 +6390,7 @@ if test -z "$ac_cv_prog_STRIP_FOR_TARGET
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6391: checking for $ac_word" >&5
++echo "configure:6394: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_STRIP_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6418,7 +6421,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6422: checking for $ac_word" >&5
++echo "configure:6425: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_STRIP_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6468,7 +6471,7 @@ fi
+ if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
+   if test -n "$with_build_time_tools"; then
+     echo $ac_n "checking for windres in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:6472: checking for windres in $with_build_time_tools" >&5
++echo "configure:6475: checking for windres in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/windres; then
+       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
+       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
+@@ -6486,7 +6489,7 @@ if test -z "$ac_cv_path_WINDRES_FOR_TARG
+   # Extract the first word of "windres", so it can be a program name with args.
+ set dummy windres; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6490: checking for $ac_word" >&5
++echo "configure:6493: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_path_WINDRES_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6523,7 +6526,7 @@ if test -z "$ac_cv_path_WINDRES_FOR_TARG
+    if test -n "$with_build_time_tools"; then
+   for ncn_progname in windres; do
+     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
+-echo "configure:6527: checking for ${ncn_progname} in $with_build_time_tools" >&5
++echo "configure:6530: checking for ${ncn_progname} in $with_build_time_tools" >&5
+     if test -x $with_build_time_tools/${ncn_progname}; then
+       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+       echo "$ac_t""yes" 1>&6
+@@ -6540,7 +6543,7 @@ if test -z "$ac_cv_prog_WINDRES_FOR_TARG
+       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6544: checking for $ac_word" >&5
++echo "configure:6547: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_WINDRES_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6571,7 +6574,7 @@ fi
+       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
+ set dummy ${ncn_progname}; ac_word=$2
+ echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+-echo "configure:6575: checking for $ac_word" >&5
++echo "configure:6578: checking for $ac_word" >&5
+ if eval "test \"`echo '$''{'ac_cv_prog_WINDRES_FOR_TARGET'+set}'`\" = set"; then
+   echo $ac_n "(cached) $ac_c" 1>&6
+ else
+@@ -6619,7 +6622,7 @@ fi
+ RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
+ echo $ac_n "checking where to find the target ar""... $ac_c" 1>&6
+-echo "configure:6623: checking where to find the target ar" >&5
++echo "configure:6626: checking where to find the target ar" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6652,7 +6655,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target as""... $ac_c" 1>&6
+-echo "configure:6656: checking where to find the target as" >&5
++echo "configure:6659: checking where to find the target as" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6685,7 +6688,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target cc""... $ac_c" 1>&6
+-echo "configure:6689: checking where to find the target cc" >&5
++echo "configure:6692: checking where to find the target cc" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6718,7 +6721,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target c++""... $ac_c" 1>&6
+-echo "configure:6722: checking where to find the target c++" >&5
++echo "configure:6725: checking where to find the target c++" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6754,7 +6757,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target c++ for libstdc++""... $ac_c" 1>&6
+-echo "configure:6758: checking where to find the target c++ for libstdc++" >&5
++echo "configure:6761: checking where to find the target c++ for libstdc++" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6790,7 +6793,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target dlltool""... $ac_c" 1>&6
+-echo "configure:6794: checking where to find the target dlltool" >&5
++echo "configure:6797: checking where to find the target dlltool" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6823,7 +6826,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target gcc""... $ac_c" 1>&6
+-echo "configure:6827: checking where to find the target gcc" >&5
++echo "configure:6830: checking where to find the target gcc" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6856,7 +6859,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target gcj""... $ac_c" 1>&6
+-echo "configure:6860: checking where to find the target gcj" >&5
++echo "configure:6863: checking where to find the target gcj" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6892,7 +6895,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target gfortran""... $ac_c" 1>&6
+-echo "configure:6896: checking where to find the target gfortran" >&5
++echo "configure:6899: checking where to find the target gfortran" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6928,7 +6931,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target ld""... $ac_c" 1>&6
+-echo "configure:6932: checking where to find the target ld" >&5
++echo "configure:6935: checking where to find the target ld" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6961,7 +6964,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target lipo""... $ac_c" 1>&6
+-echo "configure:6965: checking where to find the target lipo" >&5
++echo "configure:6968: checking where to find the target lipo" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -6984,7 +6987,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target nm""... $ac_c" 1>&6
+-echo "configure:6988: checking where to find the target nm" >&5
++echo "configure:6991: checking where to find the target nm" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -7017,7 +7020,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target objdump""... $ac_c" 1>&6
+-echo "configure:7021: checking where to find the target objdump" >&5
++echo "configure:7024: checking where to find the target objdump" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -7050,7 +7053,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target ranlib""... $ac_c" 1>&6
+-echo "configure:7054: checking where to find the target ranlib" >&5
++echo "configure:7057: checking where to find the target ranlib" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -7083,7 +7086,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target strip""... $ac_c" 1>&6
+-echo "configure:7087: checking where to find the target strip" >&5
++echo "configure:7090: checking where to find the target strip" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -7116,7 +7119,7 @@ else
+   fi
+ fi
+ echo $ac_n "checking where to find the target windres""... $ac_c" 1>&6
+-echo "configure:7120: checking where to find the target windres" >&5
++echo "configure:7123: checking where to find the target windres" >&5
+ if test "x${build}" != "x${host}" ; then
+   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
+     # We already found the complete path
+@@ -7177,7 +7180,7 @@ fi
+ echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
+-echo "configure:7181: checking whether to enable maintainer-specific portions of Makefiles" >&5
++echo "configure:7184: 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"
+@@ -7334,34 +7337,15 @@ trap 'rm -f $CONFIG_STATUS conftest*; ex
+ # Transform confdefs.h into DEFS.
+ # Protect against shell expansion while executing Makefile rules.
+ # Protect against Makefile macro expansion.
+-#
+-# If the first sed substitution is executed (which looks for macros that
+-# take arguments), then we branch to the quote section.  Otherwise,
+-# look for a macro that doesn't take arguments.
+-cat >confdef2opt.sed <<\_ACEOF
+-t clear
+-: clear
+-s,^[  ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
+-t quote
+-s,^[  ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
+-t quote
+-d
+-: quote
+-s,[   `~#$^&*(){}\\|;'"<>?],\\&,g
+-s,\[,\\&,g
+-s,\],\\&,g
+-s,\$,$$,g
+-p
+-_ACEOF
+-# We use echo to avoid assuming a particular line-breaking character.
+-# The extra dot is to prevent the shell from consuming trailing
+-# line-breaks from the sub-command output.  A line-break within
+-# single-quotes doesn't work because, if this script is created in a
+-# platform that uses two characters for line-breaks (e.g., DOS), tr
+-# would break.
+-ac_LF_and_DOT=`echo; echo .`
+-DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
+-rm -f confdef2opt.sed
++cat > conftest.defs <<\EOF
++s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%-D\1=\2%g
++s%[   `~#$^&*(){}\\|;'"<>?]%\\&%g
++s%\[%\\&%g
++s%\]%\\&%g
++s%\$%$$%g
++EOF
++DEFS=`sed -f conftest.defs confdefs.h | tr '\012' ' '`
++rm -f conftest.defs
+ # Without the "./", some shells look in PATH for config.status.
+diff -Nrup binutils-2.17/configure.in binutils-2.17-atmel/configure.in
+--- binutils-2.17/configure.in 2006-06-23 20:19:53.000000000 +0200
++++ binutils-2.17-atmel/configure.in   2007-02-12 15:37:09.000000000 +0100
+@@ -269,6 +269,9 @@ unsupported_languages=
+ # exist yet.
+ case "${host}" in
++  avr32*-*-*)
++    noconfigdirs="$noconfigdirs readline gdb"
++    ;;
+   hppa*64*-*-*)
+     noconfigdirs="$noconfigdirs byacc"
+     ;;
+diff -Nrup binutils-2.17/gas/as.c binutils-2.17-atmel/gas/as.c
+--- binutils-2.17/gas/as.c     2006-02-09 01:07:41.000000000 +0100
++++ binutils-2.17-atmel/gas/as.c       2007-02-12 15:37:09.000000000 +0100
+@@ -439,10 +439,10 @@ parse_args (int * pargc, char *** pargv)
+        the end of the preceeding line so that it is simpler to
+        selectively add and remove lines from this list.  */
+     {"alternate", no_argument, NULL, OPTION_ALTERNATE}
+-    /* The entry for "a" is here to prevent getopt_long_only() from
+-       considering that -a is an abbreviation for --alternate.  This is
+-       necessary because -a=<FILE> is a valid switch but getopt would
+-       normally reject it since --alternate does not take an argument.  */
++    /* The next two entries are here to prevent getopt_long_only() from
++       considering that -a or -al is an abbreviation for --alternate.
++       This is necessary because -a=<FILE> is a valid switch but getopt
++       would normally reject it since --alternate does not take an argument.  */
+     ,{"a", optional_argument, NULL, 'a'}
+     /* Handle -al=<FILE>.  */
+     ,{"al", optional_argument, NULL, OPTION_AL}
+@@ -795,8 +795,15 @@ the GNU General Public License.  This pr
+       case 'a':
+         if (optarg)
+           {
+-            if (optarg != old_argv[optind] && optarg[-1] == '=')
+-              --optarg;
++            /* If optarg is part of the -a switch and not a separate argument
++               in its own right, then scan backwards to the just after the -a.
++               This means skipping over both '=' and 'l' which might have been
++               taken to be part of the -a switch itself.  */
++            if (optarg != old_argv[optind])
++              {
++                while (optarg[-1] == '=' || optarg[-1] == 'l')
++                  --optarg;
++              }
+             if (md_parse_option (optc, optarg) != 0)
+               break;
+@@ -1189,7 +1196,7 @@ main (int argc, char ** argv)
+     keep_it = 0;
+   if (!keep_it)
+-    unlink_if_ordinary (out_file_name);
++    unlink (out_file_name);
+   input_scrub_end ();
+diff -Nrup binutils-2.17/gas/config/bfin-aux.h binutils-2.17-atmel/gas/config/bfin-aux.h
+--- binutils-2.17/gas/config/bfin-aux.h        2005-09-30 17:05:06.000000000 +0200
++++ binutils-2.17-atmel/gas/config/bfin-aux.h  2007-02-12 15:37:09.000000000 +0100
+@@ -1,151 +1,151 @@
+-/* bfin-aux.h ADI Blackfin Header file for gas\r
+-   Copyright 2005\r
+-   Free Software Foundation, Inc.\r
+-\r
+-   This file is part of GAS, the GNU Assembler.\r
+-\r
+-   GAS is free software; you can redistribute it and/or modify\r
+-   it under the terms of the GNU General Public License as published by\r
+-   the Free Software Foundation; either version 2, or (at your option)\r
+-   any later version.\r
+-\r
+-   GAS is distributed in the hope that it will be useful,\r
+-   but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
+-   GNU General Public License for more details.\r
+-\r
+-   You should have received a copy of the GNU General Public License\r
+-   along with GAS; see the file COPYING.  If not, write to the Free\r
+-   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA\r
+-   02110-1301, USA.  */\r
+-\r
+-#include "bfin-defs.h"\r
+-\r
+-#define REG_T Register *\r
+-\r
+-INSTR_T\r
+-bfin_gen_dsp32mac (int op1, int mm, int mmod, int w1, int p,\r
+-              int h01, int h11, int h00, int h10,\r
+-            int op0, REG_T dst, REG_T src0, REG_T src1, int w0);\r
+-\r
+-INSTR_T\r
+-bfin_gen_dsp32mult (int op1, int mm, int mmod, int w1, int p,\r
+-               int h01, int h11, int h00, int h10,\r
+-             int op0, REG_T dst, REG_T src0, REG_T src1, int w0);\r
+-\r
+-INSTR_T\r
+-bfin_gen_dsp32alu (int HL, int aopcde, int aop, int s, int x,\r
+-              REG_T dst0, REG_T dst1, REG_T src0, REG_T src1);\r
+-\r
+-INSTR_T\r
+-bfin_gen_dsp32shift (int sopcde, REG_T dst0, REG_T src0, REG_T src1,\r
+-                int sop, int hls);\r
+-\r
+-INSTR_T\r
+-bfin_gen_dsp32shiftimm (int sopcde, REG_T dst0, int immag, REG_T src1,\r
+-                   int sop, int hls);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ldimmhalf (REG_T reg, int h, int s, int z, Expr_Node *hword,\r
+-               int reloc);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ldstidxi (REG_T ptr, REG_T reg, int w, int sz, int z,\r
+-              Expr_Node *offset);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ldst (REG_T ptr, REG_T reg, int aop, int sz, int z, int w);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ldstii (REG_T ptr, REG_T reg, Expr_Node *offset, int w, int op);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ldstiifp (REG_T reg, Expr_Node *offset, int w);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ldstpmod (REG_T ptr, REG_T reg, int aop, int w, REG_T idx);\r
+-\r
+-INSTR_T\r
+-bfin_gen_dspldst (REG_T i, REG_T reg, int aop, int w, int m);\r
+-\r
+-INSTR_T\r
+-bfin_gen_alu2op (REG_T dst, REG_T src, int opc);\r
+-\r
+-INSTR_T\r
+-bfin_gen_compi2opd (REG_T dst, int src, int op);\r
+-\r
+-INSTR_T\r
+-bfin_gen_compi2opp (REG_T dst, int src, int op);\r
+-\r
+-INSTR_T\r
+-bfin_gen_dagmodik (REG_T i, int op);\r
+-\r
+-INSTR_T\r
+-bfin_gen_dagmodim (REG_T i, REG_T m, int op, int br);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ptr2op (REG_T dst, REG_T src, int opc);\r
+-\r
+-INSTR_T\r
+-bfin_gen_logi2op (int dst, int src, int opc);\r
+-\r
+-INSTR_T\r
+-bfin_gen_comp3op (REG_T src0, REG_T src1, REG_T dst, int opc);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ccmv (REG_T src, REG_T dst, int t);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ccflag (REG_T x, int y, int opc, int i, int g);\r
+-\r
+-INSTR_T\r
+-bfin_gen_cc2stat (int cbit, int op, int d);\r
+-\r
+-INSTR_T\r
+-bfin_gen_regmv (REG_T src, REG_T dst);\r
+-\r
+-INSTR_T\r
+-bfin_gen_cc2dreg (int op, REG_T reg);\r
+-\r
+-INSTR_T\r
+-bfin_gen_brcc (int t, int b, Expr_Node *offset);\r
+-\r
+-INSTR_T\r
+-bfin_gen_ujump (Expr_Node *offset);\r
+-\r
+-INSTR_T\r
+-bfin_gen_cactrl (REG_T reg, int a, int op);\r
+-\r
+-INSTR_T\r
+-bfin_gen_progctrl (int prgfunc, int poprnd);\r
+-\r
+-INSTR_T\r
+-bfin_gen_loopsetup (Expr_Node *soffset, REG_T c, int rop,\r
+-               Expr_Node *eoffset, REG_T reg);\r
+-\r
+-INSTR_T\r
+-bfin_gen_loop (Expr_Node *expr, REG_T reg, int rop, REG_T preg);\r
+-\r
+-INSTR_T\r
+-bfin_gen_pushpopmultiple (int dr, int pr, int d, int p, int w);\r
+-\r
+-INSTR_T\r
+-bfin_gen_pushpopreg (REG_T reg, int w);\r
+-\r
+-INSTR_T\r
+-bfin_gen_calla (Expr_Node *addr, int s);\r
+-\r
+-INSTR_T\r
+-bfin_gen_linkage (int r, int framesize);\r
+-\r
+-INSTR_T\r
+-bfin_gen_pseudodbg (int fn, int reg, int grp);\r
+-\r
+-INSTR_T\r
+-bfin_gen_pseudodbg_assert (int dbgop, REG_T regtest, int expected);\r
+-\r
+-bfd_boolean\r
+-bfin_resource_conflict (INSTR_T dsp32, INSTR_T dsp16_grp1, INSTR_T dsp16_grp2);\r
+-\r
+-INSTR_T\r
+-bfin_gen_multi_instr (INSTR_T dsp32, INSTR_T dsp16_grp1, INSTR_T dsp16_grp2);\r
++/* bfin-aux.h ADI Blackfin Header file for gas
++   Copyright 2005
++   Free Software Foundation, Inc.
++
++   This file is part of GAS, the GNU Assembler.
++
++   GAS is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2, or (at your option)
++   any later version.
++
++   GAS is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with GAS; see the file COPYING.  If not, write to the Free
++   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
++   02110-1301, USA.  */
++
++#include "bfin-defs.h"
++
++#define REG_T Register *
++
++INSTR_T
++bfin_gen_dsp32mac (int op1, int mm, int mmod, int w1, int p,
++              int h01, int h11, int h00, int h10,
++            int op0, REG_T dst, REG_T src0, REG_T src1, int w0);
++
++INSTR_T
++bfin_gen_dsp32mult (int op1, int mm, int mmod, int w1, int p,
++               int h01, int h11, int h00, int h10,
++             int op0, REG_T dst, REG_T src0, REG_T src1, int w0);
++
++INSTR_T
++bfin_gen_dsp32alu (int HL, int aopcde, int aop, int s, int x,
++              REG_T dst0, REG_T dst1, REG_T src0, REG_T src1);
++
++INSTR_T
++bfin_gen_dsp32shift (int sopcde, REG_T dst0, REG_T src0, REG_T src1,
++                int sop, int hls);
++
++INSTR_T
++bfin_gen_dsp32shiftimm (int sopcde, REG_T dst0, int immag, REG_T src1,
++                   int sop, int hls);
++
++INSTR_T
++bfin_gen_ldimmhalf (REG_T reg, int h, int s, int z, Expr_Node *hword,
++               int reloc);
++
++INSTR_T
++bfin_gen_ldstidxi (REG_T ptr, REG_T reg, int w, int sz, int z,
++              Expr_Node *offset);
++
++INSTR_T
++bfin_gen_ldst (REG_T ptr, REG_T reg, int aop, int sz, int z, int w);
++
++INSTR_T
++bfin_gen_ldstii (REG_T ptr, REG_T reg, Expr_Node *offset, int w, int op);
++
++INSTR_T
++bfin_gen_ldstiifp (REG_T reg, Expr_Node *offset, int w);
++
++INSTR_T
++bfin_gen_ldstpmod (REG_T ptr, REG_T reg, int aop, int w, REG_T idx);
++
++INSTR_T
++bfin_gen_dspldst (REG_T i, REG_T reg, int aop, int w, int m);
++
++INSTR_T
++bfin_gen_alu2op (REG_T dst, REG_T src, int opc);
++
++INSTR_T
++bfin_gen_compi2opd (REG_T dst, int src, int op);
++
++INSTR_T
++bfin_gen_compi2opp (REG_T dst, int src, int op);
++
++INSTR_T
++bfin_gen_dagmodik (REG_T i, int op);
++
++INSTR_T
++bfin_gen_dagmodim (REG_T i, REG_T m, int op, int br);
++
++INSTR_T
++bfin_gen_ptr2op (REG_T dst, REG_T src, int opc);
++
++INSTR_T
++bfin_gen_logi2op (int dst, int src, int opc);
++
++INSTR_T
++bfin_gen_comp3op (REG_T src0, REG_T src1, REG_T dst, int opc);
++
++INSTR_T
++bfin_gen_ccmv (REG_T src, REG_T dst, int t);
++
++INSTR_T
++bfin_gen_ccflag (REG_T x, int y, int opc, int i, int g);
++
++INSTR_T
++bfin_gen_cc2stat (int cbit, int op, int d);
++
++INSTR_T
++bfin_gen_regmv (REG_T src, REG_T dst);
++
++INSTR_T
++bfin_gen_cc2dreg (int op, REG_T reg);
++
++INSTR_T
++bfin_gen_brcc (int t, int b, Expr_Node *offset);
++
++INSTR_T
++bfin_gen_ujump (Expr_Node *offset);
++
++INSTR_T
++bfin_gen_cactrl (REG_T reg, int a, int op);
++
++INSTR_T
++bfin_gen_progctrl (int prgfunc, int poprnd);
++
++INSTR_T
++bfin_gen_loopsetup (Expr_Node *soffset, REG_T c, int rop,
++               Expr_Node *eoffset, REG_T reg);
++
++INSTR_T
++bfin_gen_loop (Expr_Node *expr, REG_T reg, int rop, REG_T preg);
++
++INSTR_T
++bfin_gen_pushpopmultiple (int dr, int pr, int d, int p, int w);
++
++INSTR_T
++bfin_gen_pushpopreg (REG_T reg, int w);
++
++INSTR_T
++bfin_gen_calla (Expr_Node *addr, int s);
++
++INSTR_T
++bfin_gen_linkage (int r, int framesize);
++
++INSTR_T
++bfin_gen_pseudodbg (int fn, int reg, int grp);
++
++INSTR_T
++bfin_gen_pseudodbg_assert (int dbgop, REG_T regtest, int expected);
++
++bfd_boolean
++bfin_resource_conflict (INSTR_T dsp32, INSTR_T dsp16_grp1, INSTR_T dsp16_grp2);
++
++INSTR_T
++bfin_gen_multi_instr (INSTR_T dsp32, INSTR_T dsp16_grp1, INSTR_T dsp16_grp2);
+diff -Nrup binutils-2.17/gas/config/tc-avr32.c binutils-2.17-atmel/gas/config/tc-avr32.c
+--- binutils-2.17/gas/config/tc-avr32.c        1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/config/tc-avr32.c  2007-02-12 15:37:09.000000000 +0100
+@@ -0,0 +1,4714 @@
++/* Assembler implementation for AVR32.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   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 "as.h"
++#include "safe-ctype.h"
++#include "subsegs.h"
++#include "symcat.h"
++#include "opcodes/avr32-opc.h"
++#include "opcodes/avr32-asm.h"
++#include "elf/avr32.h"
++#include "dwarf2dbg.h"
++
++#define xDEBUG
++#define xOPC_CONSISTENCY_CHECK
++
++#ifdef DEBUG
++# define pr_debug(fmt, args...) fprintf(stderr, fmt, ##args)
++#else
++# define pr_debug(fmt, args...)
++#endif
++
++/* 3 MSB of instruction word indicate group. Group 7 -> extended */
++#define AVR32_COMPACT_P(opcode) ((opcode[0] & 0xe0) != 0xe0)
++
++#define streq(a, b)           (strcmp(a, b) == 0)
++#define skip_whitespace(str)  do { while(*(str) == ' ') ++(str); } while(0)
++
++/* Flags given on the command line */
++static int avr32_pic  = FALSE;
++int linkrelax = FALSE;
++int avr32_iarcompat   = FALSE;
++
++/* This array holds the chars that always start a comment. */
++const char comment_chars[]            = "#";
++
++/* This array holds the chars that only start a comment at the
++   beginning of a line.  We must include '#' here because the compiler
++   may produce #APP and #NO_APP in its output.  */
++const char line_comment_chars[]               = "#";
++
++/* These may be used instead of newline (same as ';' in C).  */
++const char line_separator_chars[]     = ";";
++
++/* Chars that can be used to separate mantissa from exponent in
++   floating point numbers.  */
++const char EXP_CHARS[]                        = "eE";
++
++/* Chars that mean this number is a floating point constant.  */
++const char FLT_CHARS[]                        = "dD";
++
++/* Pre-defined "_GLOBAL_OFFSET_TABLE_"  */
++symbolS *GOT_symbol;
++
++static struct hash_control *avr32_mnemonic_htab;
++
++struct avr32_ifield_data
++{
++  bfd_vma value;
++  /* FIXME: Get rid of align_order and complain. complain is never
++     used, align_order is used in one place.  Try to use the relax
++     table instead.  */
++  unsigned int align_order;
++};
++
++struct avr32_insn
++{
++  const struct avr32_syntax *syntax;
++  expressionS immediate;
++  int pcrel;
++  int force_extended;
++  unsigned int next_slot;
++  bfd_reloc_code_real_type r_type;
++  struct avr32_ifield_data field_value[AVR32_MAX_FIELDS];
++};
++
++static struct avr32_insn current_insn;
++
++/* The target specific pseudo-ops we support. */
++static void s_rseg (int);
++static void s_cpool(int);
++
++const pseudo_typeS md_pseudo_table[] =
++{
++  /* Make sure that .word is 32 bits */
++  { "word", cons, 4 },
++  { "file", (void (*) PARAMS ((int))) dwarf2_directive_file, 0 },
++  { "loc", dwarf2_directive_loc, 0 },
++
++  /* .lcomm requires an explicit alignment parameter */
++  { "lcomm", s_lcomm, 1 },
++
++  /* AVR32-specific pseudo-ops */
++  { "cpool", s_cpool, 0},
++
++  /* IAR compatible pseudo-ops */
++  { "program", s_ignore, 0 },
++  { "public", s_globl, 0 },
++  { "extern", s_ignore, 0 },
++  { "module", s_ignore, 0 },
++  { "rseg", s_rseg, 0 },
++  { "dc8", cons, 1 },
++  { "dc16", cons, 2 },
++  { "dc32", cons, 4 },
++
++  { NULL, NULL, 0 }
++};
++
++/* Questionable stuff starts here */
++
++enum avr32_opinfo {
++  AVR32_OPINFO_NONE = BFD_RELOC_NONE,
++  AVR32_OPINFO_GOT,
++  AVR32_OPINFO_TLSGD,
++  AVR32_OPINFO_HI,
++  AVR32_OPINFO_LO,
++};
++
++enum avr32_arch {
++  ARCH_TYPE_AP,
++  ARCH_TYPE_UC
++};
++
++struct arch_type_s
++{
++  /* Architecture name */
++  char *name;
++  /* Instruction Set Architecture Flags */
++  unsigned long isa_flags;
++};
++
++struct part_type_s
++{
++  /* Part name */
++  char *name;
++  /* Architecture type */
++  unsigned int arch;
++};
++
++static struct arch_type_s arch_types[] =
++{
++  {"ap", AVR32_V1 | AVR32_SIMD | AVR32_DSP | AVR32_PICO},
++  {"uc", AVR32_V1 | AVR32_DSP | AVR32_RMW},
++  {"all-insn", AVR32_V1 | AVR32_SIMD | AVR32_DSP | AVR32_RMW | AVR32_FP | AVR32_PICO},
++  {NULL, 0}
++};
++
++static struct part_type_s part_types[] = {
++  {"ap7000", ARCH_TYPE_AP},
++  {"ap7010", ARCH_TYPE_AP},
++  {"ap7020", ARCH_TYPE_AP},
++  {"uc3a0256", ARCH_TYPE_UC},
++  {"uc3a0512", ARCH_TYPE_UC},
++  {"uc3a1128", ARCH_TYPE_UC},
++  {"uc3a1256", ARCH_TYPE_UC},
++  {"uc3a1512", ARCH_TYPE_UC},
++  {NULL, 0}
++};
++
++/* Current architecture type.  */
++static struct arch_type_s default_arch = {"all-insn", AVR32_V1 | AVR32_SIMD | AVR32_DSP | AVR32_RMW | AVR32_FP | AVR32_PICO };
++static struct arch_type_s *avr32_arch = &default_arch;
++
++/* Display nicely formatted list of known part- and architecture names.  */
++
++static void
++show_arch_list (FILE *stream)
++{
++  int i, x;
++
++  fprintf (stream, _("Known architecture names:"));
++  x = 1000;
++
++  for (i = 0; arch_types[i].name; i++)
++    {
++      int len = strlen (arch_types[i].name);
++
++      x += len + 1;
++
++      if (x < 75)
++      fprintf (stream, " %s", arch_types[i].name);
++      else
++      {
++        fprintf (stream, "\n  %s", arch_types[i].name);
++        x = len + 2;
++      }
++    }
++
++  fprintf (stream, "\n");
++}
++
++static void
++show_part_list (FILE *stream)
++{
++  int i, x;
++
++  fprintf (stream, _("Known part names:"));
++  x = 1000;
++
++  for (i = 0; part_types[i].name; i++)
++    {
++      int len = strlen(part_types[i].name);
++
++      x += len + 1;
++
++      if (x < 75)
++      fprintf (stream, " %s", part_types[i].name);
++      else
++      {
++        fprintf(stream, "\n  %s", part_types[i].name);
++        x = len + 2;
++      }
++    }
++
++  fprintf (stream, "\n");
++}
++
++const char *md_shortopts = "";
++struct option md_longopts[] =
++{
++#define OPTION_ARCH           (OPTION_MD_BASE)
++#define OPTION_PART           (OPTION_ARCH + 1)
++#define OPTION_IAR            (OPTION_PART + 1)
++#define OPTION_PIC            (OPTION_IAR + 1)
++#define OPTION_NOPIC          (OPTION_PIC + 1)
++#define OPTION_LINKRELAX      (OPTION_NOPIC + 1)
++#define OPTION_NOLINKRELAX    (OPTION_LINKRELAX + 1)
++  {"march",           required_argument, NULL, OPTION_ARCH},
++  {"mpart",           required_argument, NULL, OPTION_PART},
++  {"iar",             no_argument, NULL, OPTION_IAR},
++  {"pic",             no_argument, NULL, OPTION_PIC},
++  {"no-pic",          no_argument, NULL, OPTION_NOPIC},
++  {"linkrelax",               no_argument, NULL, OPTION_LINKRELAX},
++  {"no-linkrelax",    no_argument, NULL, OPTION_NOLINKRELAX},
++  /* deprecated alias for -mpart=xxx */
++  {"mcpu",            required_argument, NULL, OPTION_PART},
++  {NULL,              no_argument, NULL, 0}
++};
++
++size_t md_longopts_size = sizeof (md_longopts);
++
++void
++md_show_usage (FILE *stream)
++{
++  fprintf (stream,
++         _(
++"AVR32 options:\n"
++"-march=[arch-name]      Select cpu architecture. [Default `all-insn']\n"
++"-mpart=[part-name]      Select specific part. [Default `none']\n"
++"--pic                   Produce Position-Independent Code\n"
++"--no-pic                Don't produce Position-Independent Code\n"
++"--linkrelax             Produce output suitable for linker relaxing\n"
++"--no-linkrelax          Don't produce output suitable for linker relaxing\n"));
++  show_arch_list(stream);
++}
++
++int
++md_parse_option (int c, char *arg ATTRIBUTE_UNUSED)
++{
++  switch (c)
++    {
++    case OPTION_ARCH:
++      {
++      int i;
++      char *s = alloca (strlen (arg) + 1);
++
++      {
++        char *t = s;
++        char *arg1 = arg;
++
++        do
++          *t = TOLOWER (*arg1++);
++        while (*t++);
++      }
++
++      for (i = 0; arch_types[i].name; ++i)
++        if (strcmp (arch_types[i].name, s) == 0)
++          break;
++
++      if (!arch_types[i].name)
++        {
++          show_arch_list (stderr);
++          as_fatal (_("unknown architecture: %s\n"), arg);
++        }
++
++        avr32_arch = &arch_types[i];
++      break;
++      }
++    case OPTION_PART:
++      {
++      int i;
++      char *s = alloca (strlen (arg) + 1);
++      char *t = s;
++      char *p = arg;
++
++      /* If arch type has already been set, don't bother.
++         -march= always overrides -mpart=  */
++      if (avr32_arch != &default_arch)
++        break;
++
++      do
++        *t = TOLOWER (*p++);
++      while (*t++);
++
++      for (i = 0; part_types[i].name; ++i)
++        if (strcmp (part_types[i].name, s) == 0)
++          break;
++
++      if (!part_types[i].name)
++        {
++          show_part_list (stderr);
++          as_fatal (_("unknown part: %s\n"), arg);
++        }
++
++      avr32_arch = &arch_types[part_types[i].arch];
++      break;
++      }
++    case OPTION_IAR:
++      avr32_iarcompat = 1;
++      break;
++    case OPTION_PIC:
++      avr32_pic = 1;
++      break;
++    case OPTION_NOPIC:
++      avr32_pic = 0;
++      break;
++    case OPTION_LINKRELAX:
++      linkrelax = 1;
++      break;
++    case OPTION_NOLINKRELAX:
++      linkrelax = 0;
++      break;
++    default:
++      return 0;
++    }
++  return 1;
++}
++
++/* Can't use symbol_new here, so have to create a symbol and then at
++   a later date assign it a value. Thats what these functions do.
++
++   Shamelessly stolen from ARM.  */
++
++static void
++symbol_locate (symbolS *    symbolP,
++             const char * name,       /* It is copied, the caller can modify.  */
++             segT         segment,    /* Segment identifier (SEG_<something>).  */
++             valueT       valu,       /* Symbol value.  */
++             fragS *      frag)       /* Associated fragment.  */
++{
++  unsigned int name_length;
++  char * preserved_copy_of_name;
++
++  name_length = strlen (name) + 1;   /* +1 for \0.  */
++  obstack_grow (&notes, name, name_length);
++  preserved_copy_of_name = obstack_finish (&notes);
++#ifdef STRIP_UNDERSCORE
++  if (preserved_copy_of_name[0] == '_')
++    preserved_copy_of_name++;
++#endif
++
++#ifdef tc_canonicalize_symbol_name
++  preserved_copy_of_name =
++    tc_canonicalize_symbol_name (preserved_copy_of_name);
++#endif
++
++  S_SET_NAME (symbolP, preserved_copy_of_name);
++
++  S_SET_SEGMENT (symbolP, segment);
++  S_SET_VALUE (symbolP, valu);
++  symbol_clear_list_pointers (symbolP);
++
++  symbol_set_frag (symbolP, frag);
++
++  /* Link to end of symbol chain.  */
++  {
++    extern int symbol_table_frozen;
++
++    if (symbol_table_frozen)
++      abort ();
++  }
++
++  symbol_append (symbolP, symbol_lastP, & symbol_rootP, & symbol_lastP);
++
++  obj_symbol_new_hook (symbolP);
++
++#ifdef tc_symbol_new_hook
++  tc_symbol_new_hook (symbolP);
++#endif
++
++#ifdef DEBUG_SYMS
++  verify_symbol_chain (symbol_rootP, symbol_lastP);
++#endif /* DEBUG_SYMS  */
++}
++
++struct cpool_entry
++{
++  int                 refcount;
++  offsetT             offset;
++  expressionS         exp;
++};
++
++struct cpool
++{
++  struct cpool                *next;
++  int                 used;
++  struct cpool_entry  *literals;
++  unsigned int                padding;
++  unsigned int                next_free_entry;
++  unsigned int                id;
++  symbolS             *symbol;
++  segT                        section;
++  subsegT             sub_section;
++};
++
++struct cpool *cpool_list = NULL;
++
++static struct cpool *
++find_cpool(segT section, subsegT sub_section)
++{
++  struct cpool *pool;
++
++  for (pool = cpool_list; pool != NULL; pool = pool->next)
++    {
++      if (!pool->used
++        && pool->section == section
++        && pool->sub_section == sub_section)
++      break;
++    }
++
++  return pool;
++}
++
++static struct cpool *
++find_or_make_cpool(segT section, subsegT sub_section)
++{
++  static unsigned int next_cpool_id = 0;
++  struct cpool *pool;
++
++  pool = find_cpool(section, sub_section);
++
++  if (!pool)
++    {
++      pool = xmalloc(sizeof(*pool));
++      if (!pool)
++      return NULL;
++
++      pool->used = 0;
++      pool->literals = NULL;
++      pool->padding = 0;
++      pool->next_free_entry = 0;
++      pool->section = section;
++      pool->sub_section = sub_section;
++      pool->next = cpool_list;
++      pool->symbol = NULL;
++
++      cpool_list = pool;
++    }
++
++  /* NULL symbol means that the pool is new or has just been emptied.  */
++  if (!pool->symbol)
++    {
++      pool->symbol = symbol_create(FAKE_LABEL_NAME, undefined_section,
++                                 0, &zero_address_frag);
++      pool->id = next_cpool_id++;
++    }
++
++  return pool;
++}
++
++static struct cpool *
++add_to_cpool(expressionS *exp, unsigned int *index, int ref)
++{
++  struct cpool *pool;
++  unsigned int entry;
++
++  pool = find_or_make_cpool(now_seg, now_subseg);
++
++  /* Check if this constant is already in the pool.  */
++  for (entry = 0; entry < pool->next_free_entry; entry++)
++    {
++      if ((pool->literals[entry].exp.X_op == exp->X_op)
++        && (exp->X_op == O_constant)
++        && (pool->literals[entry].exp.X_add_number
++            == exp->X_add_number)
++        && (pool->literals[entry].exp.X_unsigned
++            == exp->X_unsigned))
++      break;
++
++      if ((pool->literals[entry].exp.X_op == exp->X_op)
++        && (exp->X_op == O_symbol)
++        && (pool->literals[entry].exp.X_add_number
++            == exp->X_add_number)
++        && (pool->literals[entry].exp.X_add_symbol
++            == exp->X_add_symbol)
++        && (pool->literals[entry].exp.X_op_symbol
++            == exp->X_op_symbol))
++      break;
++    }
++
++  /* Create an entry if we didn't find a match */
++  if (entry == pool->next_free_entry)
++    {
++      pool->literals = xrealloc(pool->literals,
++                              sizeof(struct cpool_entry) * (entry + 1));
++      pool->literals[entry].exp = *exp;
++      pool->literals[entry].refcount = 0;
++      pool->next_free_entry++;
++    }
++
++  if (index)
++    *index = entry;
++  if (ref)
++    pool->literals[entry].refcount++;
++
++  return pool;
++}
++
++struct avr32_operand
++{
++  int id;
++  int is_signed;
++  int is_pcrel;
++  int align_order;
++  int (*match)(char *str);
++  void (*parse)(const struct avr32_operand *op, char *str, int opindex);
++};
++
++static int
++match_anything(char *str ATTRIBUTE_UNUSED)
++{
++  return 1;
++}
++
++static int
++match_intreg(char *str)
++{
++  int regid, ret = 1;
++
++  regid = avr32_parse_intreg(str);
++  if (regid < 0)
++    ret = 0;
++
++  pr_debug("match_intreg: `%s': %d\n", str, ret);
++
++  return ret;
++}
++
++static int
++match_intreg_predec(char *str)
++{
++  int regid;
++
++  if (str[0] != '-' || str[1] != '-')
++    return 0;
++
++  regid = avr32_parse_intreg(str + 2);
++  if (regid < 0)
++    return 0;
++
++  return 1;
++}
++
++static int
++match_intreg_postinc(char *str)
++{
++  int regid, ret = 1;
++  char *p, c;
++
++  for (p = str; *p; p++)
++    if (*p == '+')
++      break;
++
++  if (p[0] != '+' || p[1] != '+')
++    return 0;
++
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  if (regid < 0)
++    ret = 0;
++
++  *p = c;
++  return ret;
++}
++
++static int
++match_intreg_lsl(char *str)
++{
++  int regid, ret = 1;
++  char *p, c;
++
++  for (p = str; *p; p++)
++    if (*p == '<')
++      break;
++
++  if (p[0] && p[1] != '<')
++    return 0;
++
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  if (regid < 0)
++    ret = 0;
++
++  *p = c;
++  return ret;
++}
++
++static int
++match_intreg_lsr(char *str)
++{
++  int regid, ret = 1;
++  char *p, c;
++
++  for (p = str; *p; p++)
++    if (*p == '>')
++      break;
++
++  if (p[0] && p[1] != '>')
++    return 0;
++
++  c = *p, *p = 0;
++
++  regid = avr32_parse_intreg(str);
++  if (regid < 0)
++    ret = 0;
++
++  *p = c;
++  return ret;
++}
++
++static int
++match_intreg_part(char *str)
++{
++  int regid, ret = 1;
++  char *p, c;
++
++  for (p = str; *p; p++)
++    if (*p == ':')
++      break;
++
++  if (p[0] != ':' || !ISPRINT(p[1]) || p[2] != '\0')
++    return 0;
++
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  if (regid < 0)
++    ret = 0;
++
++  *p = c;
++
++  return ret;
++}
++
++#define match_intreg_disp match_anything
++
++static int
++match_intreg_index(char *str)
++{
++  int regid, ret = 1;
++  char *p, *end, c;
++
++  for (p = str; *p; p++)
++    if (*p == '[')
++      break;
++
++  /* don't allow empty displacement here (it makes no sense) */
++  if (p[0] != '[')
++    return 0;
++
++  for (end = p + 1; *end; end++) ;
++  if (*(--end) != ']')
++    return 0;
++
++  c = *end, *end = 0;
++  if (!match_intreg_lsl(p + 1))
++    ret = 0;
++  *end = c;
++
++  if (ret)
++    {
++      c = *p, *p = 0;
++      regid = avr32_parse_intreg(str);
++      if (regid < 0)
++      ret = 0;
++      *p = c;
++    }
++
++  return ret;
++}
++
++static int
++match_intreg_xindex(char *str)
++{
++  int regid, ret = 1;
++  char *p, *end, c;
++
++  for (p = str; *p; p++)
++    if (*p == '[')
++      break;
++
++  /* empty displacement makes no sense here either */
++  if (p[0] != '[')
++    return 0;
++
++  for (end = p + 1; *end; end++)
++    if (*end == '<')
++      break;
++
++  if (!streq(end, "<<2]"))
++    return 0;
++
++  c = *end, *end = 0;
++  if (!match_intreg_part(p + 1))
++    ret = 0;
++  *end = c;
++
++  if (ret)
++    {
++      c = *p, *p = 0;
++      regid = avr32_parse_intreg(str);
++      if (regid < 0)
++      ret = 0;
++      *p = c;
++    }
++
++  return ret;
++}
++
++/* The PC_UDISP_W operator may show up as a label or as a pc[disp]
++   expression.  So there's no point in attempting to match this...  */
++#define match_pc_disp match_anything
++
++static int
++match_sp(char *str)
++{
++  /* SP in any form will do */
++  return avr32_parse_intreg(str) == AVR32_REG_SP;
++}
++
++static int
++match_sp_disp(char *str)
++{
++  int regid, ret = 1;
++  char *p, c;
++
++  for (p = str; *p; p++)
++    if (*p == '[')
++      break;
++
++  /* allow empty displacement, meaning zero */
++  if (p[0] == '[')
++    {
++      char *end;
++      for (end = p + 1; *end; end++) ;
++      if (end[-1] != ']')
++      return 0;
++    }
++
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  if (regid != AVR32_REG_SP)
++    ret = 0;
++
++  *p = c;
++  return ret;
++}
++
++static int
++match_cpno(char *str)
++{
++  if (strncasecmp(str, "cp", 2) != 0)
++    return 0;
++  return 1;
++}
++
++static int
++match_cpreg(char *str)
++{
++  if (strncasecmp(str, "cr", 2) != 0)
++    return 0;
++  return 1;
++}
++
++/* We allow complex expressions, and register names may show up as
++   symbols.  Just make sure immediate expressions are always matched
++   last.  */
++#define match_const           match_anything
++#define match_jmplabel                match_anything
++#define match_number          match_anything
++
++/* Mnemonics that take reglists never accept anything else */
++#define match_reglist8                match_anything
++#define match_reglist9                match_anything
++#define match_reglist16               match_anything
++#define match_reglist_ldm     match_anything
++#define match_reglist_cp8     match_anything
++#define match_reglist_cpd8    match_anything
++
++/* Ditto for retval, jospinc and mcall */
++#define match_retval          match_anything
++#define match_jospinc         match_anything
++#define match_mcall           match_anything
++
++/* COH is used to select between two different syntaxes */
++static int
++match_coh(char *str)
++{
++  return strcasecmp(str, "coh") == 0;
++}
++
++static int
++match_fpreg(char *str)
++{
++  unsigned long regid;
++  char *endptr;
++
++  if ((str[0] != 'f' && str[0] != 'F')
++      || (str[1] != 'r' && str[1] != 'R'))
++    return 0;
++
++  str += 2;
++  regid = strtoul(str, &endptr, 10);
++  if (!*str || *endptr)
++    return 0;
++
++  return 1;
++}
++
++static int
++match_picoreg(char *str)
++{
++  int regid;
++
++  regid = avr32_parse_picoreg(str);
++  if (regid < 0)
++    return 0;
++  return 1;
++}
++
++#define match_pico_reglist_w  match_anything
++#define match_pico_reglist_d  match_anything
++
++static int
++match_pico_in(char *str)
++{
++  unsigned long regid;
++  char *end;
++
++  if (strncasecmp(str, "in", 2) != 0)
++    return 0;
++
++  str += 2;
++  regid = strtoul(str, &end, 10);
++  if (!*str || *end)
++    return 0;
++
++  return 1;
++}
++
++static int
++match_pico_out0(char *str)
++{
++  if (strcasecmp(str, "out0") != 0)
++    return 0;
++  return 1;
++}
++
++static int
++match_pico_out1(char *str)
++{
++  if (strcasecmp(str, "out1") != 0)
++    return 0;
++  return 1;
++}
++
++static int
++match_pico_out2(char *str)
++{
++  if (strcasecmp(str, "out2") != 0)
++    return 0;
++  return 1;
++}
++
++static int
++match_pico_out3(char *str)
++{
++  if (strcasecmp(str, "out3") != 0)
++    return 0;
++  return 1;
++}
++
++static void parse_nothing(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++                        char *str ATTRIBUTE_UNUSED,
++                        int opindex ATTRIBUTE_UNUSED)
++{
++  /* Do nothing (this is used for "match-only" operands like COH) */
++}
++
++static void
++parse_const(const struct avr32_operand *op, char *str,
++          int opindex ATTRIBUTE_UNUSED)
++{
++  expressionS *exp = &current_insn.immediate;
++  expressionS *sym_exp;
++  int slot;
++  char *save;
++
++  pr_debug("parse_const: `%s' (signed: %d, pcrel: %d, align: %d)\n",
++         str, op->is_signed, op->is_pcrel, op->align_order);
++
++  save = input_line_pointer;
++  input_line_pointer = str;
++
++  expression(exp);
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].align_order = op->align_order;
++  current_insn.pcrel = op->is_pcrel;
++
++  switch (exp->X_op)
++    {
++    case O_illegal:
++      as_bad(_("illegal operand"));
++      break;
++    case O_absent:
++      as_bad(_("missing operand"));
++      break;
++    case O_constant:
++      pr_debug("  -> constant: %ld\n", (long)exp->X_add_number);
++      current_insn.field_value[slot].value = exp->X_add_number;
++      break;
++    case O_uminus:
++      pr_debug("  -> uminus\n");
++      sym_exp = symbol_get_value_expression(exp->X_add_symbol);
++      switch (sym_exp->X_op) {
++      case O_subtract:
++      pr_debug("     -> subtract: switching operands\n");
++      exp->X_op_symbol = sym_exp->X_add_symbol;
++      exp->X_add_symbol = sym_exp->X_op_symbol;
++      exp->X_op = O_subtract;
++      /* TODO: Remove the old X_add_symbol */
++      break;
++      default:
++      as_bad(_("Expression too complex\n"));
++      break;
++      }
++      break;
++#if 0
++    case O_subtract:
++      /* Any expression subtracting a symbol from the current section
++       can be made PC-relative by adding the right offset.  */
++      if (S_GET_SEGMENT(exp->X_op_symbol) == now_seg)
++      current_insn.pcrel = TRUE;
++      pr_debug("  -> subtract: pcrel? %s\n",
++             current_insn.pcrel ? "yes" : "no");
++      /* fall through */
++#endif
++    default:
++      pr_debug("  -> (%p <%d> %p + %d)\n",
++             exp->X_add_symbol, exp->X_op, exp->X_op_symbol,
++             exp->X_add_number);
++      current_insn.field_value[slot].value = 0;
++      break;
++    }
++
++  input_line_pointer = save;
++}
++
++static void
++parse_jmplabel(const struct avr32_operand *op, char *str,
++             int opindex ATTRIBUTE_UNUSED)
++{
++  expressionS *exp = &current_insn.immediate;
++  int slot;
++  char *save;
++
++  pr_debug("parse_jmplabel: `%s' (signed: %d, pcrel: %d, align: %d)\n",
++         str, op->is_signed, op->is_pcrel, op->align_order);
++
++  save = input_line_pointer;
++  input_line_pointer = str;
++
++  expression(exp);
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].align_order = op->align_order;
++  current_insn.pcrel = TRUE;
++
++  switch (exp->X_op)
++    {
++    case O_illegal:
++      as_bad(_("illegal operand"));
++      break;
++    case O_absent:
++      as_bad(_("missing operand"));
++      break;
++    case O_constant:
++      pr_debug("  -> constant: %ld\n", (long)exp->X_add_number);
++      current_insn.field_value[slot].value = exp->X_add_number;
++      current_insn.pcrel = 0;
++      break;
++    default:
++      pr_debug("  -> (%p <%d> %p + %d)\n",
++             exp->X_add_symbol, exp->X_op, exp->X_op_symbol,
++             exp->X_add_number);
++      current_insn.field_value[slot].value = 0;
++      break;
++    }
++
++  input_line_pointer = save;
++}
++
++static void
++parse_intreg(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++           char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  int regid, slot;
++
++  pr_debug("parse_intreg: `%s'\n", str);
++
++  regid = avr32_parse_intreg(str);
++  assert(regid >= 0);
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++  current_insn.field_value[slot].align_order = op->align_order;
++}
++
++static void
++parse_intreg_predec(const struct avr32_operand *op, char *str, int opindex)
++{
++  parse_intreg(op, str + 2, opindex);
++}
++
++static void
++parse_intreg_postinc(const struct avr32_operand *op, char *str, int opindex)
++{
++  char *p, c;
++
++  pr_debug("parse_intreg_postinc: `%s'\n", str);
++
++  for (p = str; *p != '+'; p++) ;
++
++  c = *p, *p = 0;
++  parse_intreg(op, str, opindex);
++  *p = c;
++}
++
++static void
++parse_intreg_shift(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++                 char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  int regid, slot, shift = 0;
++  char *p, c;
++  char shiftop;
++
++  pr_debug("parse Ry<<sa: `%s'\n", str);
++
++  for (p = str; *p; p++)
++    if (*p == '<' || *p == '>')
++      break;
++
++  shiftop = *p;
++
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  assert(regid >= 0);
++  *p = c;
++
++  if (c)
++    {
++      if (p[0] != shiftop || p[1] != shiftop)
++      as_bad(_("expected shift operator in `%s'"), p);
++      else
++      {
++        expressionS exp;
++        char *saved;
++
++        saved = input_line_pointer;
++        input_line_pointer = p + 2;
++        expression(&exp);
++        input_line_pointer = saved;
++
++        if (exp.X_op != O_constant)
++          as_bad(_("shift amount must be a numeric constant"));
++        else
++          shift = exp.X_add_number;
++      }
++    }
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = shift;
++}
++
++/* The match() function selected the right opcode, so it doesn't
++   matter which way we shift any more.  */
++#define parse_intreg_lsl      parse_intreg_shift
++#define parse_intreg_lsr      parse_intreg_shift
++
++static void
++parse_intreg_part(const struct avr32_operand *op, char *str,
++                int opindex ATTRIBUTE_UNUSED)
++{
++  static const char bparts[] = { 'b', 'l', 'u', 't' };
++  static const char hparts[] = { 'b', 't' };
++  unsigned int slot, sel;
++  int regid;
++  char *p, c;
++
++  pr_debug("parse reg:part `%s'\n", str);
++
++  for (p = str; *p; p++)
++    if (*p == ':')
++      break;
++
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  assert(regid >= 0);
++  *p = c;
++
++  assert(c == ':');
++
++  if (op->align_order)
++    {
++      for (sel = 0; sel < sizeof(hparts); sel++)
++      if (TOLOWER(p[1]) == hparts[sel])
++        break;
++
++      if (sel >= sizeof(hparts))
++      {
++        as_bad(_("invalid halfword selector `%c' (must be either b or t)"),
++               p[1]);
++        sel = 0;
++      }
++    }
++  else
++    {
++      for (sel = 0; sel < sizeof(bparts); sel++)
++      if (TOLOWER(p[1]) == bparts[sel])
++        break;
++
++      if (sel >= sizeof(bparts))
++      {
++        as_bad(_("invalid byte selector `%c' (must be one of b,l,u,t)"),
++               p[1]);
++        sel = 0;
++      }
++    }
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = sel;
++}
++
++/* This is the parser for "Rp[displacement]" expressions.  In addition
++   to the "official" syntax, we accept a label as a replacement for
++   the register expression.  This syntax implies Rp=PC and the
++   displacement is the pc-relative distance to the label.  */
++static void
++parse_intreg_disp(const struct avr32_operand *op, char *str, int opindex)
++{
++  expressionS *exp = &current_insn.immediate;
++  int slot, regid;
++  char *save, *p, c;
++
++  pr_debug("parse_intreg_disp: `%s' (signed: %d, pcrel: %d, align: %d)\n",
++         str, op->is_signed, op->is_pcrel, op->align_order);
++
++  for (p = str; *p; p++)
++    if (*p == '[')
++      break;
++
++  slot = current_insn.next_slot++;
++
++  /* First, check if we have a valid register either before '[' or as
++     the sole expression.  If so, we use the Rp[disp] syntax.  */
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  *p = c;
++
++  if (regid >= 0)
++    {
++      current_insn.field_value[slot].value = regid;
++
++      slot = current_insn.next_slot++;
++      current_insn.field_value[slot].align_order = op->align_order;
++
++      if (c == '[')
++      {
++        save = input_line_pointer;
++        input_line_pointer = p + 1;
++
++        expression(exp);
++
++        if (*input_line_pointer != ']')
++          as_bad(_("junk after displacement expression"));
++
++        input_line_pointer = save;
++
++        switch (exp->X_op)
++          {
++          case O_illegal:
++            as_bad(_("illegal displacement expression"));
++            break;
++          case O_absent:
++            as_bad(_("missing displacement expression"));
++            break;
++          case O_constant:
++            pr_debug("  -> constant: %ld\n", exp->X_add_number);
++            current_insn.field_value[slot].value = exp->X_add_number;
++            break;
++#if 0
++          case O_subtract:
++            if (S_GET_SEGMENT(exp->X_op_symbol) == now_seg)
++              current_insn.pcrel = TRUE;
++            pr_debug("  -> subtract: pcrel? %s\n",
++                     current_insn.pcrel ? "yes" : "no");
++            /* fall through */
++#endif
++          default:
++            pr_debug("  -> (%p <%d> %p + %d)\n",
++                     exp->X_add_symbol, exp->X_op, exp->X_op_symbol,
++                     exp->X_add_number);
++            current_insn.field_value[slot].value = 0;
++          }
++      }
++      else
++      {
++        exp->X_op = O_constant;
++        exp->X_add_number = 0;
++        current_insn.field_value[slot].value = 0;
++      }
++    }
++  else
++    {
++      /* Didn't find a valid register.  Try parsing it as a label.  */
++      current_insn.field_value[slot].value = AVR32_REG_PC;
++      parse_jmplabel(op, str, opindex);
++    }
++}
++
++static void
++parse_intreg_index(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++                 char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  int slot, regid;
++  char *p, *end, c;
++
++  for (p = str; *p; p++)
++    if (*p == '[')
++      break;
++
++  assert(*p);
++
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  assert(regid >= 0);
++  *p = c;
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++
++  p++;
++  for (end = p; *end; end++)
++    if (*end == ']' || *end == '<')
++      break;
++
++  assert(*end);
++
++  c = *end, *end = 0;
++  regid = avr32_parse_intreg(p);
++  assert(regid >= 0);
++  *end = c;
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = 0;
++
++  if (*end == '<')
++    {
++      expressionS exp;
++      char *save;
++
++      p = end + 2;
++      for (end = p; *end; end++)
++      if (*end == ']')
++        break;
++
++      assert(*end == ']');
++
++      c = *end, *end = 0;
++      save = input_line_pointer;
++      input_line_pointer = p;
++      expression(&exp);
++
++      if (*input_line_pointer)
++      as_bad(_("junk after shift expression"));
++
++      *end = c;
++      input_line_pointer = save;
++
++      if (exp.X_op == O_constant)
++      current_insn.field_value[slot].value = exp.X_add_number;
++      else
++      as_bad(_("shift expression too complex"));
++    }
++}
++
++static void
++parse_intreg_xindex(const struct avr32_operand *op, char *str, int opindex)
++{
++  int slot, regid;
++  char *p, *end, c;
++
++  for (p = str; *p; p++)
++    if (*p == '[')
++      break;
++
++  assert(*p);
++
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  assert(regid >= 0);
++  *p = c;
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++
++  p++;
++  for (end = p; *end; end++)
++    if (*end == '<')
++      break;
++
++  assert(*end);
++
++  c = *end, *end = 0;
++  parse_intreg_part(op, p, opindex);
++  *end = c;
++}
++
++static void
++parse_pc_disp(const struct avr32_operand *op, char *str, int opindex)
++{
++  char *p, c;
++
++  for (p = str; *p; p++)
++    if (*p == '[')
++      break;
++
++  /* The lddpc instruction comes in two different syntax variants:
++       lddpc reg, expression
++       lddpc reg, pc[disp]
++     If the operand contains a '[', we use the second form.  */
++  if (*p)
++    {
++      int regid;
++
++      c = *p, *p = 0;
++      regid = avr32_parse_intreg(str);
++      *p = c;
++      if (regid == AVR32_REG_PC)
++      {
++        char *end;
++
++        for (end = ++p; *end; end++) ;
++        if (*(--end) != ']')
++          as_bad(_("unrecognized form of instruction: `%s'"), str);
++        else
++          {
++            c = *end, *end = 0;
++            parse_const(op, p, opindex);
++            *end = c;
++            current_insn.pcrel = 0;
++          }
++      }
++      else
++      as_bad(_("unrecognized form of instruction: `%s'"), str);
++    }
++  else
++    {
++      parse_jmplabel(op, str, opindex);
++    }
++}
++
++static void parse_sp(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++                   char *str ATTRIBUTE_UNUSED,
++                   int opindex ATTRIBUTE_UNUSED)
++{
++  int slot;
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = AVR32_REG_SP;
++}
++
++static void
++parse_sp_disp(const struct avr32_operand *op, char *str, int opindex)
++{
++  char *p, c;
++
++  for (; *str; str++)
++    if (*str == '[')
++      break;
++
++  assert(*str);
++
++  for (p = ++str; *p; p++)
++    if (*p == ']')
++      break;
++
++  c = *p, *p = 0;
++  parse_const(op, str, opindex);
++  *p = c;
++}
++
++static void
++parse_cpno(const struct avr32_operand *op ATTRIBUTE_UNUSED, char *str,
++         int opindex ATTRIBUTE_UNUSED)
++{
++  int slot;
++
++  str += 2;
++  if (*str == '#')
++    str++;
++  if (*str < '0' || *str > '7' || str[1])
++    as_bad(_("invalid coprocessor `%s'"), str);
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = *str - '0';
++}
++
++static void
++parse_cpreg(const struct avr32_operand *op, char *str,
++          int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned int crid;
++  int slot;
++  char *endptr;
++
++  str += 2;
++  crid = strtoul(str, &endptr, 10);
++  if (*endptr || crid > 15 || crid & ((1 << op->align_order) - 1))
++    as_bad(_("invalid coprocessor register `%s'"), str);
++
++  crid >>= op->align_order;
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = crid;
++}
++
++static void
++parse_number(const struct avr32_operand *op, char *str,
++           int opindex ATTRIBUTE_UNUSED)
++{
++  expressionS exp;
++  int slot;
++  char *save;
++
++  save = input_line_pointer;
++  input_line_pointer = str;
++  expression(&exp);
++  input_line_pointer = save;
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].align_order = op->align_order;
++
++  if (exp.X_op == O_constant)
++      current_insn.field_value[slot].value = exp.X_add_number;
++  else
++      as_bad(_("invalid numeric expression `%s'"), str);
++}
++
++static void
++parse_reglist8(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++             char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regmask;
++  unsigned long value = 0;
++  int slot;
++  char *tail;
++
++  regmask = avr32_parse_reglist(str, &tail);
++  if (*tail)
++    as_bad(_("invalid register list `%s'"), str);
++  else
++    {
++      if (avr32_make_regmask8(regmask, &value))
++      as_bad(_("register list `%s' doesn't fit"), str);
++    }
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = value;
++}
++
++static int
++parse_reglist_tail(char *str, unsigned long regmask)
++{
++  expressionS exp;
++  char *save, *p, c;
++  int regid;
++
++  for (p = str + 1; *p; p++)
++    if (*p == '=')
++      break;
++
++  if (!*p)
++    {
++      as_bad(_("invalid register list `%s'"), str);
++      return -2;
++    }
++
++  c = *p, *p = 0;
++  regid = avr32_parse_intreg(str);
++  *p = c;
++
++  if (regid != 12)
++    {
++      as_bad(_("invalid register list `%s'"), str);
++      return -2;
++    }
++
++  /* If we have an assignment, we must pop PC and we must _not_
++     pop LR or R12 */
++  if (!(regmask & (1 << AVR32_REG_PC)))
++    {
++      as_bad(_("return value specified for non-return instruction"));
++      return -2;
++    }
++  else if (regmask & ((1 << AVR32_REG_R12) | (1 << AVR32_REG_LR)))
++    {
++      as_bad(_("can't pop LR or R12 when specifying return value"));
++      return -2;
++    }
++
++  save = input_line_pointer;
++  input_line_pointer = p + 1;
++  expression(&exp);
++  input_line_pointer = save;
++
++  if (exp.X_op != O_constant
++      || exp.X_add_number < -1
++      || exp.X_add_number > 1)
++    {
++      as_bad(_("invalid return value `%s'"), str);
++      return -2;
++    }
++
++  return exp.X_add_number;
++}
++
++static void
++parse_reglist9(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++             char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regmask;
++  unsigned long value = 0, kbit = 0;
++  int slot;
++  char *tail;
++
++  regmask = avr32_parse_reglist(str, &tail);
++  /* printf("parsed reglist16: %04lx, tail: `%s'\n", regmask, tail); */
++  if (*tail)
++    {
++      int retval;
++
++      retval = parse_reglist_tail(tail, regmask);
++
++      switch (retval)
++      {
++      case -1:
++        regmask |= 1 << AVR32_REG_LR;
++        break;
++      case 0:
++        break;
++      case 1:
++        regmask |= 1 << AVR32_REG_R12;
++        break;
++      default:
++        break;
++      }
++
++      kbit = 1;
++    }
++
++  if (avr32_make_regmask8(regmask, &value))
++    as_bad(_("register list `%s' doesn't fit"), str);
++
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = (value << 1) | kbit;
++}
++
++static void
++parse_reglist16(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++              char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regmask;
++  int slot;
++  char *tail;
++
++  regmask = avr32_parse_reglist(str, &tail);
++  if (*tail)
++    as_bad(_("invalid register list `%s'"), str);
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regmask;
++}
++
++static void
++parse_reglist_ldm(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++                char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regmask;
++  int slot, rp, w_bit = 0;
++  char *tail, *p, c;
++
++  for (p = str; *p && *p != ','; p++)
++    if (*p == '+')
++      break;
++
++  c = *p, *p = 0;
++  rp = avr32_parse_intreg(str);
++  *p = c;
++  if (rp < 0)
++    {
++      as_bad(_("invalid destination register in `%s'"), str);
++      return;
++    }
++
++  if (p[0] == '+' && p[1] == '+')
++    {
++      w_bit = 1;
++      p += 2;
++    }
++
++  if (*p != ',')
++    {
++      as_bad(_("expected `,' after destination register in `%s'"), str);
++      return;
++    }
++
++  str = p + 1;
++  regmask = avr32_parse_reglist(str, &tail);
++  if (*tail)
++    {
++      int retval;
++
++      if (rp != AVR32_REG_SP)
++      {
++        as_bad(_("junk at end of line: `%s'"), tail);
++        return;
++      }
++
++      rp = AVR32_REG_PC;
++
++      retval = parse_reglist_tail(tail, regmask);
++
++      switch (retval)
++      {
++      case -1:
++        regmask |= 1 << AVR32_REG_LR;
++        break;
++      case 0:
++        break;
++      case 1:
++        regmask |= 1 << AVR32_REG_R12;
++        break;
++      default:
++        return;
++      }
++    }
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = rp;
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = w_bit;
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regmask;
++}
++
++static void
++parse_reglist_cp8(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++                char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regmask;
++  int slot, h_bit = 0;
++  char *tail;
++
++  regmask = avr32_parse_cpreglist(str, &tail);
++  if (*tail)
++    as_bad(_("junk at end of line: `%s'"), tail);
++  else if (regmask & 0xffUL)
++    {
++      if (regmask & 0xff00UL)
++      as_bad(_("register list `%s' doesn't fit"), str);
++      regmask &= 0xff;
++    }
++  else if (regmask & 0xff00UL)
++    {
++      regmask >>= 8;
++      h_bit = 1;
++    }
++  else
++    as_warn(_("register list is empty"));
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regmask;
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = h_bit;
++}
++
++static void
++parse_reglist_cpd8(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++                 char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regmask, regmask_d = 0;
++  int slot, i;
++  char *tail;
++
++  regmask = avr32_parse_cpreglist(str, &tail);
++  if (*tail)
++    as_bad(_("junk at end of line: `%s'"), tail);
++
++  for (i = 0; i < 8; i++)
++    {
++      if (regmask & 1)
++      {
++        if (!(regmask & 2))
++          {
++            as_bad(_("register list `%s' doesn't fit"), str);
++            break;
++          }
++        regmask_d |= 1 << i;
++      }
++      else if (regmask & 2)
++      {
++        as_bad(_("register list `%s' doesn't fit"), str);
++        break;
++      }
++
++      regmask >>= 2;
++    }
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regmask_d;
++}
++
++static void
++parse_retval(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++           char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  int regid, slot;
++
++  regid = avr32_parse_intreg(str);
++  if (regid < 0)
++    {
++      expressionS exp;
++      char *save;
++
++      regid = 0;
++
++      save = input_line_pointer;
++      input_line_pointer = str;
++      expression(&exp);
++      input_line_pointer = save;
++
++      if (exp.X_op != O_constant)
++      as_bad(_("invalid return value `%s'"), str);
++      else
++      switch (exp.X_add_number)
++        {
++        case -1:
++          regid = AVR32_REG_LR;
++          break;
++        case 0:
++          regid = AVR32_REG_SP;
++          break;
++        case 1:
++          regid = AVR32_REG_PC;
++          break;
++        default:
++          as_bad(_("invalid return value `%s'"), str);
++          break;
++        }
++    }
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++}
++
++#define parse_mcall parse_intreg_disp
++
++static void
++parse_jospinc(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++            char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  expressionS exp;
++  int slot;
++  char *save;
++
++  save = input_line_pointer;
++  input_line_pointer = str;
++  expression(&exp);
++  input_line_pointer = save;
++
++  slot = current_insn.next_slot++;
++
++  if (exp.X_op == O_constant)
++    {
++      if (exp.X_add_number > 0)
++      exp.X_add_number--;
++      current_insn.field_value[slot].value = exp.X_add_number;
++    }
++  else
++    as_bad(_("invalid numeric expression `%s'"), str);
++}
++
++#define parse_coh             parse_nothing
++
++static void
++parse_fpreg(const struct avr32_operand *op,
++          char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regid;
++  int slot;
++
++  regid = strtoul(str + 2, NULL, 10);
++
++  if ((regid >= 16) || (regid & ((1 << op->align_order) - 1)))
++    as_bad(_("invalid floating-point register `%s'"), str);
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++  current_insn.field_value[slot].align_order = op->align_order;
++}
++
++static void
++parse_picoreg(const struct avr32_operand *op,
++            char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regid;
++  int slot;
++
++  regid = avr32_parse_picoreg(str);
++  if (regid & ((1 << op->align_order) - 1))
++    as_bad(_("invalid double-word PiCo register `%s'"), str);
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++  current_insn.field_value[slot].align_order = op->align_order;
++}
++
++static void
++parse_pico_reglist_w(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++                   char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regmask;
++  int slot, h_bit = 0;
++  char *tail;
++
++  regmask = avr32_parse_pico_reglist(str, &tail);
++  if (*tail)
++    as_bad(_("junk at end of line: `%s'"), tail);
++
++  if (regmask & 0x00ffUL)
++    {
++      if (regmask & 0xff00UL)
++      as_bad(_("register list `%s' doesn't fit"), str);
++      regmask &= 0x00ffUL;
++    }
++  else if (regmask & 0xff00UL)
++    {
++      regmask >>= 8;
++      h_bit = 1;
++    }
++  else
++    as_warn(_("register list is empty"));
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regmask;
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = h_bit;
++}
++
++static void
++parse_pico_reglist_d(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++                   char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regmask, regmask_d = 0;
++  int slot, i;
++  char *tail;
++
++  regmask = avr32_parse_pico_reglist(str, &tail);
++  if (*tail)
++    as_bad(_("junk at end of line: `%s'"), tail);
++
++  for (i = 0; i < 8; i++)
++    {
++      if (regmask & 1)
++      {
++        if (!(regmask & 2))
++          {
++            as_bad(_("register list `%s' doesn't fit"), str);
++            break;
++          }
++        regmask_d |= 1 << i;
++      }
++      else if (regmask & 2)
++      {
++        as_bad(_("register list `%s' doesn't fit"), str);
++        break;
++      }
++
++      regmask >>= 2;
++    }
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regmask_d;
++}
++
++static void
++parse_pico_in(const struct avr32_operand *op ATTRIBUTE_UNUSED,
++            char *str, int opindex ATTRIBUTE_UNUSED)
++{
++  unsigned long regid;
++  int slot;
++
++  regid = strtoul(str + 2, NULL, 10);
++
++  if (regid >= 12)
++    as_bad(_("invalid PiCo IN register `%s'"), str);
++
++  slot = current_insn.next_slot++;
++  current_insn.field_value[slot].value = regid;
++  current_insn.field_value[slot].align_order = 0;
++}
++
++#define parse_pico_out0               parse_nothing
++#define parse_pico_out1               parse_nothing
++#define parse_pico_out2               parse_nothing
++#define parse_pico_out3               parse_nothing
++
++#define OP(name, sgn, pcrel, align, func) \
++  { AVR32_OPERAND_##name, sgn, pcrel, align, match_##func, parse_##func }
++
++struct avr32_operand avr32_operand_table[] = {
++  OP(INTREG, 0, 0, 0, intreg),
++  OP(INTREG_PREDEC, 0, 0, 0, intreg_predec),
++  OP(INTREG_POSTINC, 0, 0, 0, intreg_postinc),
++  OP(INTREG_LSL, 0, 0, 0, intreg_lsl),
++  OP(INTREG_LSR, 0, 0, 0, intreg_lsr),
++  OP(INTREG_BSEL, 0, 0, 0, intreg_part),
++  OP(INTREG_HSEL, 0, 0, 1, intreg_part),
++  OP(INTREG_SDISP, 1, 0, 0, intreg_disp),
++  OP(INTREG_SDISP_H, 1, 0, 1, intreg_disp),
++  OP(INTREG_SDISP_W, 1, 0, 2, intreg_disp),
++  OP(INTREG_UDISP, 0, 0, 0, intreg_disp),
++  OP(INTREG_UDISP_H, 0, 0, 1, intreg_disp),
++  OP(INTREG_UDISP_W, 0, 0, 2, intreg_disp),
++  OP(INTREG_INDEX, 0, 0, 0, intreg_index),
++  OP(INTREG_XINDEX, 0, 0, 0, intreg_xindex),
++  OP(DWREG, 0, 0, 1, intreg),
++  OP(PC_UDISP_W, 0, 1, 2, pc_disp),
++  OP(SP, 0, 0, 0, sp),
++  OP(SP_UDISP_W, 0, 0, 2, sp_disp),
++  OP(CPNO, 0, 0, 0, cpno),
++  OP(CPREG, 0, 0, 0, cpreg),
++  OP(CPREG_D, 0, 0, 1, cpreg),
++  OP(UNSIGNED_CONST, 0, 0, 0, const),
++  OP(UNSIGNED_CONST_W, 0, 0, 2, const),
++  OP(SIGNED_CONST, 1, 0, 0, const),
++  OP(SIGNED_CONST_W, 1, 0, 2, const),
++  OP(JMPLABEL, 1, 1, 1, jmplabel),
++  OP(UNSIGNED_NUMBER, 0, 0, 0, number),
++  OP(UNSIGNED_NUMBER_W, 0, 0, 2, number),
++  OP(REGLIST8, 0, 0, 0, reglist8),
++  OP(REGLIST9, 0, 0, 0, reglist9),
++  OP(REGLIST16, 0, 0, 0, reglist16),
++  OP(REGLIST_LDM, 0, 0, 0, reglist_ldm),
++  OP(REGLIST_CP8, 0, 0, 0, reglist_cp8),
++  OP(REGLIST_CPD8, 0, 0, 0, reglist_cpd8),
++  OP(RETVAL, 0, 0, 0, retval),
++  OP(MCALL, 1, 0, 2, mcall),
++  OP(JOSPINC, 0, 0, 0, jospinc),
++  OP(COH, 0, 0, 0, coh),
++  OP(FPREG_S, 0, 0, 0, fpreg),
++  OP(FPREG_D, 0, 0, 1, fpreg),
++  OP(PICO_REG_W, 0, 0, 0, picoreg),
++  OP(PICO_REG_D, 0, 0, 1, picoreg),
++  OP(PICO_REGLIST_W, 0, 0, 0, pico_reglist_w),
++  OP(PICO_REGLIST_D, 0, 0, 0, pico_reglist_d),
++  OP(PICO_IN, 0, 0, 0, pico_in),
++  OP(PICO_OUT0, 0, 0, 0, pico_out0),
++  OP(PICO_OUT1, 0, 0, 0, pico_out1),
++  OP(PICO_OUT2, 0, 0, 0, pico_out2),
++  OP(PICO_OUT3, 0, 0, 0, pico_out3),
++};
++
++symbolS *
++md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
++{
++  pr_debug("md_undefined_symbol: %s\n", name);
++  return 0;
++}
++
++struct avr32_relax_type
++{
++  long lower_bound;
++  long upper_bound;
++  unsigned char align;
++  unsigned char length;
++  signed short next;
++};
++
++#define EMPTY { 0, 0, 0, 0, -1 }
++#define C(lower, upper, align, next)                  \
++  { (lower), (upper), (align), 2, AVR32_OPC_##next }
++#define E(lower, upper, align)                                \
++  { (lower), (upper), (align), 4, -1 }
++
++static const struct avr32_relax_type avr32_relax_table[] =
++  {
++    /* 0 */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY,
++    E(0, 65535, 0), E(0, 65535, 0), E(0, 65535, 0), E(0, 65535, 0),
++    EMPTY,
++    /* 16 */
++    EMPTY, EMPTY, EMPTY, EMPTY,
++
++    C(-256, 254, 1, BREQ2), C(-256, 254, 1, BRNE2),
++    C(-256, 254, 1, BRCC2), C(-256, 254, 1, BRCS2),
++    C(-256, 254, 1, BRGE2), C(-256, 254, 1, BRLT2),
++    C(-256, 254, 1, BRMI2), C(-256, 254, 1, BRPL2),
++    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),
++    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),
++    /* 32 */
++    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),
++    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),
++    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),
++    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),
++    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),
++    E(-2097152, 2097150, 1), E(-2097152, 2097150, 1),
++
++    EMPTY, EMPTY, EMPTY, EMPTY,
++    /* 48 */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY,
++
++    C(-32, 31, 0, CP_W3), E(-1048576, 1048575, 0),
++
++    EMPTY, EMPTY, EMPTY,
++    /* 64: csrfcz */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    E(0, 65535, 0), E(0, 65535, 0),
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    E(-32768, 32767, 0),
++    /* 80: LD_SB2 */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++
++    C(0, 7, 0, LD_UB4), E(-32768, 32767, 0),
++
++    EMPTY,
++    EMPTY, EMPTY,
++
++    C(0, 14, 1, LD_SH4), E(-32768, 32767, 0),
++
++    EMPTY, EMPTY, EMPTY,
++
++    C(0, 14, 1, LD_UH4), E(-32768, 32767, 0),
++
++    EMPTY, EMPTY, EMPTY, EMPTY,
++
++    C(0, 124, 2, LD_W4), E(-32768, 32767, 0),
++
++    E(0, 1020, 2),    /* LDC_D1 */
++    EMPTY, EMPTY,
++    E(0, 1020, 2),    /* LDC_W1 */
++    EMPTY, EMPTY,
++    E(0, 16380, 2),   /* LDC0_D */
++    E(0, 16380, 2),   /* LDC0_W */
++    EMPTY, EMPTY, EMPTY, EMPTY,
++
++    C(0, 508, 2, LDDPC_EXT), E(-32768, 32767, 0),
++
++    EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    /* 128: MACHH_W */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    E(-131072, 131068, 2),    /* MCALL */
++    E(0, 1020, 2),            /* MFDR */
++    E(0, 1020, 2),            /* MFSR */
++    EMPTY, EMPTY,
++
++    C(-128, 127, 0, MOV2), E(-1048576, 1048575, 0),
++
++    EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++
++    E(-128, 127, 0),          /* MOVEQ2 */
++    E(-128, 127, 0),          /* MOVNE2 */
++    E(-128, 127, 0),          /* MOVCC2 */
++    E(-128, 127, 0),          /* 160: MOVCS2 */
++    E(-128, 127, 0),          /* MOVGE2 */
++    E(-128, 127, 0),          /* MOVLT2 */
++    E(-128, 127, 0),          /* MOVMI2 */
++    E(-128, 127, 0),          /* MOVPL2 */
++    E(-128, 127, 0),          /* MOVLS2 */
++    E(-128, 127, 0),          /* MOVGT2 */
++    E(-128, 127, 0),          /* MOVLE2 */
++    E(-128, 127, 0),          /* MOVHI2 */
++    E(-128, 127, 0),          /* MOVVS2 */
++    E(-128, 127, 0),          /* MOVVC2 */
++    E(-128, 127, 0),          /* MOVQS2 */
++    E(-128, 127, 0),          /* MOVAL2 */
++
++    E(0, 1020, 2),            /* MTDR */
++    E(0, 1020, 2),            /* MTSR */
++    EMPTY,
++    EMPTY,
++    E(-128, 127, 0),          /* MUL3 */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    /* 192: MVCR_W */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    E(0, 65535, 0), E(0, 65535, 0),
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    /* 224: PASR_H */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    /* 256: PUNPCKSB_H */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++
++    C(-1024, 1022, 1, RCALL2), E(-2097152, 2097150, 1),
++
++    EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY,
++
++    C(-1024, 1022, 1, BRAL),
++
++    EMPTY, EMPTY, EMPTY,
++    E(-128, 127, 0),          /* RSUB2 */
++    /* 288: SATADD_H */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    E(0, 255, 0),             /* SLEEP */
++    EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    /* 320: ST_B2 */
++    EMPTY, EMPTY,
++    C(0, 7, 0, ST_B4), E(-32768, 32767, 0),
++    EMPTY, EMPTY, EMPTY, EMPTY,
++    E(-32768, 32767, 0),
++    EMPTY, EMPTY, EMPTY,
++    C(0, 14, 1, ST_H4), E(-32768, 32767, 0),
++    EMPTY, EMPTY,
++    EMPTY,
++    C(0, 60, 2, ST_W4), E(-32768, 32767, 0),
++    E(0, 1020, 2),    /* STC_D1 */
++    EMPTY, EMPTY,
++    E(0, 1020, 2),    /* STC_W1 */
++    EMPTY, EMPTY,
++    E(0, 16380, 2),   /* STC0_D */
++    E(0, 16380, 2),   /* STC0_W */
++
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    /* 352: STDSP */
++    EMPTY, EMPTY,
++    E(0, 1020, 2),    /* STHH_W1 */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    EMPTY, EMPTY, EMPTY,
++    E(-32768, 32767, 0),
++    C(-512, 508, 2, SUB4),
++    C(-128, 127, 0, SUB4), E(-1048576, 1048576, 0),
++    /* SUB{cond} */
++    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),
++    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),
++    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),
++    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),
++    /* SUBF{cond} */
++    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),
++    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),
++    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),
++    E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0), E(-128, 127, 0),
++    EMPTY,
++
++    /* 400: SWAP_B */
++    EMPTY, EMPTY, EMPTY,
++    E(0, 255, 0),     /* SYNC */
++    EMPTY, EMPTY, EMPTY, EMPTY,
++    /* 408: TST */
++    EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
++    /* 416: EXTRACT_B */
++    EMPTY, EMPTY, EMPTY, EMPTY,
++  };
++
++#undef E
++#undef C
++#undef EMPTY
++
++#define AVR32_RS_NONE (-1)
++
++#define avr32_rs_size(state) (avr32_relax_table[(state)].length)
++#define avr32_rs_align(state) (avr32_relax_table[(state)].align)
++#define relax_more(state) (avr32_relax_table[(state)].next)
++
++#define opc_initial_substate(opc) ((opc)->id)
++
++static int need_relax(int subtype, offsetT distance)
++{
++  offsetT upper_bound, lower_bound;
++
++  upper_bound = avr32_relax_table[subtype].upper_bound;
++  lower_bound = avr32_relax_table[subtype].lower_bound;
++
++  if (distance & ((1 << avr32_rs_align(subtype)) - 1))
++    return 1;
++  if ((distance > upper_bound) || (distance < lower_bound))
++    return 1;
++
++  return 0;
++}
++
++enum {
++  LDA_SUBTYPE_MOV1,
++  LDA_SUBTYPE_MOV2,
++  LDA_SUBTYPE_SUB,
++  LDA_SUBTYPE_LDDPC,
++  LDA_SUBTYPE_LDW,
++  LDA_SUBTYPE_GOTLOAD,
++  LDA_SUBTYPE_GOTLOAD_LARGE,
++};
++
++enum {
++  CALL_SUBTYPE_RCALL1,
++  CALL_SUBTYPE_RCALL2,
++  CALL_SUBTYPE_MCALL_CP,
++  CALL_SUBTYPE_MCALL_GOT,
++  CALL_SUBTYPE_MCALL_LARGE,
++};
++
++#define LDA_INITIAL_SIZE      (avr32_pic ? 4 : 2)
++#define CALL_INITIAL_SIZE     2
++
++#define need_reloc(sym, seg, pcrel)                                   \
++  (!(S_IS_DEFINED(sym)                                                        \
++     && ((pcrel && S_GET_SEGMENT(sym) == seg)                         \
++       || (!pcrel && S_GET_SEGMENT(sym) == absolute_section)))        \
++   || S_FORCE_RELOC(sym, 1))
++
++/* Return an initial guess of the length by which a fragment must grow to
++   hold a branch to reach its destination.
++   Also updates fr_type/fr_subtype as necessary.
++
++   Called just before doing relaxation.
++   Any symbol that is now undefined will not become defined.
++   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
++   0 value.  */
++
++static int
++avr32_default_estimate_size_before_relax (fragS *fragP, segT segment)
++{
++  int growth = 0;
++
++  assert(fragP);
++  assert(fragP->fr_symbol);
++
++  if (fragP->tc_frag_data.force_extended
++      || need_reloc(fragP->fr_symbol, segment, fragP->tc_frag_data.pcrel))
++    {
++      int largest_state = fragP->fr_subtype;
++      while (relax_more(largest_state) != AVR32_RS_NONE)
++      largest_state = relax_more(largest_state);
++      growth = avr32_rs_size(largest_state) - fragP->fr_var;
++    }
++  else
++    {
++      growth = avr32_rs_size(fragP->fr_subtype) - fragP->fr_var;
++    }
++
++  pr_debug("%s:%d: md_estimate_size_before_relax: %d\n",
++         fragP->fr_file, fragP->fr_line, growth);
++
++  return growth;
++}
++
++static int
++avr32_lda_estimate_size_before_relax(fragS *fragP, segT segment ATTRIBUTE_UNUSED)
++{
++  return fragP->fr_var - LDA_INITIAL_SIZE;
++}
++
++static int
++avr32_call_estimate_size_before_relax(fragS *fragP, segT segment ATTRIBUTE_UNUSED)
++{
++  return fragP->fr_var - CALL_INITIAL_SIZE;
++}
++
++static int
++avr32_cpool_estimate_size_before_relax(fragS *fragP,
++                                     segT segment ATTRIBUTE_UNUSED)
++{
++  return fragP->fr_var;
++}
++
++/* This macro may be defined to relax a frag. GAS will call this with the
++ * segment, the frag, and the change in size of all previous frags;
++ * md_relax_frag should return the change in size of the frag. */
++static long
++avr32_default_relax_frag (segT segment, fragS *fragP, long stretch)
++{
++  int state, next_state;
++  symbolS *symbolP;   /* The target symbol */
++  long growth = 0;
++
++  state = next_state = fragP->fr_subtype;
++
++  symbolP = fragP->fr_symbol;
++
++  if (fragP->tc_frag_data.force_extended
++      || need_reloc(symbolP, segment, fragP->tc_frag_data.pcrel))
++    {
++      /* Symbol must be resolved by the linker. Emit the largest
++       possible opcode. */
++      while (relax_more(next_state) != AVR32_RS_NONE)
++      next_state = relax_more(next_state);
++    }
++  else
++    {
++      addressT address;       /* The address of fragP */
++      addressT target;        /* The address of the target symbol */
++      offsetT distance;       /* The distance between the insn and the symbol */
++      fragS *sym_frag;
++
++      address = fragP->fr_address;
++      target = fragP->fr_offset;
++      symbolP = fragP->fr_symbol;
++      sym_frag = symbol_get_frag(symbolP);
++
++      address += fragP->fr_fix - fragP->fr_var;
++      target += S_GET_VALUE(symbolP);
++
++      if (stretch != 0
++        && sym_frag->relax_marker != fragP->relax_marker
++        && S_GET_SEGMENT(symbolP) == segment)
++      /* if it was correctly aligned before, make sure it stays aligned */
++      target += stretch & (~0UL << avr32_rs_align(state));
++
++      if (fragP->tc_frag_data.pcrel)
++      distance = target - (address & (~0UL << avr32_rs_align(state)));
++      else
++      distance = target;
++
++      pr_debug("%s:%d: relax more? 0x%x - 0x%x = 0x%x (%d), align %d\n",
++             fragP->fr_file, fragP->fr_line, target, address,
++             distance, distance, avr32_rs_align(state));
++
++      if (need_relax(state, distance))
++      {
++        if (relax_more(state) != AVR32_RS_NONE)
++          next_state = relax_more(state);
++        pr_debug("%s:%d: relax more %d -> %d (%d - %d, align %d)\n",
++                 fragP->fr_file, fragP->fr_line, state, next_state,
++                 target, address, avr32_rs_align(state));
++      }
++    }
++
++  growth = avr32_rs_size(next_state) - avr32_rs_size(state);
++  fragP->fr_subtype = next_state;
++
++  pr_debug("%s:%d: md_relax_frag: growth=%d, subtype=%d, opc=0x%08lx\n",
++         fragP->fr_file, fragP->fr_line, growth, fragP->fr_subtype,
++         avr32_opc_table[next_state].value);
++
++  return growth;
++}
++
++static long
++avr32_lda_relax_frag(segT segment, fragS *fragP, long stretch)
++{
++  struct cpool *pool= NULL;
++  unsigned int entry = 0;
++  addressT address, target;
++  offsetT distance;
++  symbolS *symbolP;
++  fragS *sym_frag;
++  long old_size, new_size;
++
++  symbolP = fragP->fr_symbol;
++  old_size = fragP->fr_var;
++  if (!avr32_pic)
++    {
++      pool = fragP->tc_frag_data.pool;
++      entry = fragP->tc_frag_data.pool_entry;
++    }
++
++  address = fragP->fr_address;
++  address += fragP->fr_fix - LDA_INITIAL_SIZE;
++
++  if (!S_IS_DEFINED(symbolP) || S_FORCE_RELOC(symbolP, 1))
++    goto relax_max;
++
++  target = fragP->fr_offset;
++  sym_frag = symbol_get_frag(symbolP);
++  target += S_GET_VALUE(symbolP);
++
++  if (sym_frag->relax_marker != fragP->relax_marker
++      && S_GET_SEGMENT(symbolP) == segment)
++    target += stretch;
++
++  distance = target - address;
++
++  pr_debug("lda_relax_frag: target: %d, address: %d, var: %d\n",
++         target, address, fragP->fr_var);
++
++  if (!avr32_pic && S_GET_SEGMENT(symbolP) == absolute_section
++      && target <= 127 && (offsetT)target >= -128)
++    {
++      if (fragP->fr_subtype == LDA_SUBTYPE_LDDPC
++        || fragP->fr_subtype == LDA_SUBTYPE_LDW)
++      pool->literals[entry].refcount--;
++      new_size = 2;
++      fragP->fr_subtype = LDA_SUBTYPE_MOV1;
++    }
++  else if (!avr32_pic && S_GET_SEGMENT(symbolP) == absolute_section
++         && target <= 1048575 && (offsetT)target >= -1048576)
++    {
++      if (fragP->fr_subtype == LDA_SUBTYPE_LDDPC
++        || fragP->fr_subtype == LDA_SUBTYPE_LDW)
++      pool->literals[entry].refcount--;
++      new_size = 4;
++      fragP->fr_subtype = LDA_SUBTYPE_MOV2;
++    }
++  else if (!linkrelax && S_GET_SEGMENT(symbolP) == segment
++         /* the field will be negated, so this is really -(-32768)
++            and -(32767) */
++         && distance <= 32768 && distance >= -32767)
++    {
++      if (!avr32_pic
++        && (fragP->fr_subtype == LDA_SUBTYPE_LDDPC
++            || fragP->fr_subtype == LDA_SUBTYPE_LDW))
++      pool->literals[entry].refcount--;
++      new_size = 4;
++      fragP->fr_subtype = LDA_SUBTYPE_SUB;
++    }
++  else
++    {
++    relax_max:
++      if (avr32_pic)
++      {
++        if (linkrelax)
++          {
++            new_size = 8;
++            fragP->fr_subtype = LDA_SUBTYPE_GOTLOAD_LARGE;
++          }
++        else
++          {
++            new_size = 4;
++            fragP->fr_subtype = LDA_SUBTYPE_GOTLOAD;
++          }
++      }
++      else
++      {
++        if (fragP->fr_subtype != LDA_SUBTYPE_LDDPC
++            && fragP->fr_subtype != LDA_SUBTYPE_LDW)
++          pool->literals[entry].refcount++;
++
++        sym_frag = symbol_get_frag(pool->symbol);
++        target = (sym_frag->fr_address + sym_frag->fr_fix
++                  + pool->padding + pool->literals[entry].offset);
++
++        pr_debug("cpool sym address: 0x%lx\n",
++                 sym_frag->fr_address + sym_frag->fr_fix);
++
++        know(pool->section == segment);
++
++        if (sym_frag->relax_marker != fragP->relax_marker)
++          target += stretch;
++
++        distance = target - address;
++        if (distance <= 508 && distance >= 0)
++          {
++            new_size = 2;
++            fragP->fr_subtype = LDA_SUBTYPE_LDDPC;
++          }
++        else
++          {
++            new_size = 4;
++            fragP->fr_subtype = LDA_SUBTYPE_LDW;
++          }
++
++        pr_debug("lda_relax_frag (cpool): target=0x%lx, address=0x%lx, refcount=%d\n",
++                 target, address, pool->literals[entry].refcount);
++      }
++    }
++
++  fragP->fr_var = new_size;
++
++  pr_debug("%s:%d: lda: relax pass done. subtype: %d, growth: %ld\n",
++         fragP->fr_file, fragP->fr_line,
++         fragP->fr_subtype, new_size - old_size);
++
++  return new_size - old_size;
++}
++
++static long
++avr32_call_relax_frag(segT segment, fragS *fragP, long stretch)
++{
++  struct cpool *pool = NULL;
++  unsigned int entry = 0;
++  addressT address, target;
++  offsetT distance;
++  symbolS *symbolP;
++  fragS *sym_frag;
++  long old_size, new_size;
++
++  symbolP = fragP->fr_symbol;
++  old_size = fragP->fr_var;
++  if (!avr32_pic)
++    {
++      pool = fragP->tc_frag_data.pool;
++      entry = fragP->tc_frag_data.pool_entry;
++    }
++
++  address = fragP->fr_address;
++  address += fragP->fr_fix - CALL_INITIAL_SIZE;
++
++  if (need_reloc(symbolP, segment, 1))
++    {
++      pr_debug("call: must emit reloc\n");
++      goto relax_max;
++    }
++
++  target = fragP->fr_offset;
++  sym_frag = symbol_get_frag(symbolP);
++  target += S_GET_VALUE(symbolP);
++
++  if (sym_frag->relax_marker != fragP->relax_marker
++      && S_GET_SEGMENT(symbolP) == segment)
++    target += stretch;
++
++  distance = target - address;
++
++  if (distance <= 1022 && distance >= -1024)
++    {
++      pr_debug("call: distance is %d, emitting short rcall\n", distance);
++      if (!avr32_pic && fragP->fr_subtype == CALL_SUBTYPE_MCALL_CP)
++      pool->literals[entry].refcount--;
++      new_size = 2;
++      fragP->fr_subtype = CALL_SUBTYPE_RCALL1;
++    }
++  else if (distance <= 2097150 && distance >= -2097152)
++    {
++      pr_debug("call: distance is %d, emitting long rcall\n", distance);
++      if (!avr32_pic && fragP->fr_subtype == CALL_SUBTYPE_MCALL_CP)
++      pool->literals[entry].refcount--;
++      new_size = 4;
++      fragP->fr_subtype = CALL_SUBTYPE_RCALL2;
++    }
++  else
++    {
++      pr_debug("call: distance %d too far, emitting something big\n", distance);
++
++    relax_max:
++      if (avr32_pic)
++      {
++        if (linkrelax)
++          {
++            new_size = 10;
++            fragP->fr_subtype = CALL_SUBTYPE_MCALL_LARGE;
++          }
++        else
++          {
++            new_size = 4;
++            fragP->fr_subtype = CALL_SUBTYPE_MCALL_GOT;
++          }
++      }
++      else
++      {
++        if (fragP->fr_subtype != CALL_SUBTYPE_MCALL_CP)
++          pool->literals[entry].refcount++;
++
++        new_size = 4;
++        fragP->fr_subtype = CALL_SUBTYPE_MCALL_CP;
++      }
++    }
++
++  fragP->fr_var = new_size;
++
++  pr_debug("%s:%d: call: relax pass done, growth: %d, fr_var: %d\n",
++         fragP->fr_file, fragP->fr_line,
++         new_size - old_size, fragP->fr_var);
++
++  return new_size - old_size;
++}
++
++static long
++avr32_cpool_relax_frag(segT segment ATTRIBUTE_UNUSED,
++                     fragS *fragP,
++                     long stretch ATTRIBUTE_UNUSED)
++{
++  struct cpool *pool;
++  addressT address;
++  long old_size, new_size;
++  unsigned int entry;
++
++  pool = fragP->tc_frag_data.pool;
++  address = fragP->fr_address + fragP->fr_fix;
++  old_size = fragP->fr_var;
++  new_size = 0;
++
++  for (entry = 0; entry < pool->next_free_entry; entry++)
++    {
++      if (pool->literals[entry].refcount > 0)
++      {
++        pool->literals[entry].offset = new_size;
++        new_size += 4;
++      }
++    }
++
++  fragP->fr_var = new_size;
++
++  return new_size - old_size;
++}
++
++/* *fragP has been relaxed to its final size, and now needs to have
++   the bytes inside it modified to conform to the new size.
++
++   Called after relaxation is finished.
++   fragP->fr_type == rs_machine_dependent.
++   fragP->fr_subtype is the subtype of what the address relaxed to.  */
++
++static void
++avr32_default_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
++                          segT segment ATTRIBUTE_UNUSED,
++                          fragS *fragP)
++{
++  const struct avr32_opcode *opc;
++  const struct avr32_ifield *ifield;
++  bfd_reloc_code_real_type r_type;
++  symbolS *symbolP;
++  fixS *fixP;
++  bfd_vma value;
++  int subtype;
++
++  opc = &avr32_opc_table[fragP->fr_subtype];
++  ifield = opc->fields[opc->var_field];
++  symbolP = fragP->fr_symbol;
++  subtype = fragP->fr_subtype;
++  r_type = opc->reloc_type;
++
++  /* Clear the opcode bits and the bits belonging to the relaxed
++     field.  We assume all other fields stay the same.  */
++  value = bfd_getb32(fragP->fr_opcode);
++  value &= ~(opc->mask | ifield->mask);
++
++  /* Insert the new opcode */
++  value |= opc->value;
++  bfd_putb32(value, fragP->fr_opcode);
++
++  fragP->fr_fix += opc->size - fragP->fr_var;
++
++  if (fragP->tc_frag_data.reloc_info != AVR32_OPINFO_NONE)
++    {
++      switch (fragP->tc_frag_data.reloc_info)
++      {
++      case AVR32_OPINFO_HI:
++        r_type = BFD_RELOC_HI16;
++        break;
++      case AVR32_OPINFO_LO:
++        r_type = BFD_RELOC_LO16;
++        break;
++      case AVR32_OPINFO_GOT:
++        switch (r_type)
++          {
++          case BFD_RELOC_AVR32_18W_PCREL:
++            r_type = BFD_RELOC_AVR32_GOT18SW;
++            break;
++          case BFD_RELOC_AVR32_16S:
++            r_type = BFD_RELOC_AVR32_GOT16S;
++            break;
++          default:
++            BAD_CASE(r_type);
++            break;
++          }
++        break;
++      default:
++        BAD_CASE(fragP->tc_frag_data.reloc_info);
++        break;
++      }
++    }
++
++  pr_debug("%s:%d: convert_frag: new %s fixup\n",
++         fragP->fr_file, fragP->fr_line,
++         bfd_get_reloc_code_name(r_type));
++
++#if 1
++  fixP = fix_new_exp(fragP, fragP->fr_fix - opc->size, opc->size,
++                   &fragP->tc_frag_data.exp,
++                   fragP->tc_frag_data.pcrel, r_type);
++#else
++  fixP = fix_new(fragP, fragP->fr_fix - opc->size, opc->size, symbolP,
++               fragP->fr_offset, fragP->tc_frag_data.pcrel, r_type);
++#endif
++
++  /* Revert fix_new brain damage. "dot_value" is the value of PC at
++     the point of the fixup, relative to the frag address.  fix_new()
++     and friends think they are only being called during the assembly
++     pass, not during relaxation or similar, so fx_dot_value, fx_file
++     and fx_line are all initialized to the wrong value.  But we don't
++     know the size of the fixup until now, so we really can't live up
++     to the assumptions these functions make about the target.  What
++     do these functions think the "where" and "frag" argument mean
++     anyway?  */
++  fixP->fx_dot_value = fragP->fr_fix - opc->size;
++  fixP->fx_file = fragP->fr_file;
++  fixP->fx_line = fragP->fr_line;
++
++  fixP->tc_fix_data.ifield = ifield;
++  fixP->tc_fix_data.align = avr32_rs_align(subtype);
++  fixP->tc_fix_data.min = avr32_relax_table[subtype].lower_bound;
++  fixP->tc_fix_data.max = avr32_relax_table[subtype].upper_bound;
++}
++
++static void
++avr32_lda_convert_frag(bfd *abfd ATTRIBUTE_UNUSED,
++                     segT segment ATTRIBUTE_UNUSED,
++                     fragS *fragP)
++{
++  const struct avr32_opcode *opc;
++  const struct avr32_ifield *ifield;
++  bfd_reloc_code_real_type r_type;
++  expressionS exp;
++  struct cpool *pool;
++  fixS *fixP;
++  bfd_vma value;
++  int regid, pcrel = 0, align = 0;
++  char *p;
++
++  r_type = BFD_RELOC_NONE;
++  regid = fragP->tc_frag_data.reloc_info;
++  p = fragP->fr_opcode;
++  exp.X_add_symbol = fragP->fr_symbol;
++  exp.X_add_number = fragP->fr_offset;
++  exp.X_op = O_symbol;
++
++  pr_debug("%s:%d: lda_convert_frag, subtype: %d, fix: %d, var: %d, regid: %d\n",
++         fragP->fr_file, fragP->fr_line,
++         fragP->fr_subtype, fragP->fr_fix, fragP->fr_var, regid);
++
++  switch (fragP->fr_subtype)
++    {
++    case LDA_SUBTYPE_MOV1:
++      opc = &avr32_opc_table[AVR32_OPC_MOV1];
++      opc->fields[0]->insert(opc->fields[0], p, regid);
++      ifield = opc->fields[1];
++      r_type = opc->reloc_type;
++      break;
++    case LDA_SUBTYPE_MOV2:
++      opc = &avr32_opc_table[AVR32_OPC_MOV2];
++      opc->fields[0]->insert(opc->fields[0], p, regid);
++      ifield = opc->fields[1];
++      r_type = opc->reloc_type;
++      break;
++    case LDA_SUBTYPE_SUB:
++      opc = &avr32_opc_table[AVR32_OPC_SUB5];
++      opc->fields[0]->insert(opc->fields[0], p, regid);
++      opc->fields[1]->insert(opc->fields[1], p, AVR32_REG_PC);
++      ifield = opc->fields[2];
++      r_type = BFD_RELOC_AVR32_16N_PCREL;
++
++      /* Pretend that SUB5 isn't a "negated" pcrel expression for now.
++       We'll have to fix it up later when we know whether to
++       generate a reloc for it (in which case the linker will negate
++       it, so we shouldn't). */
++      pcrel = 1;
++      break;
++    case LDA_SUBTYPE_LDDPC:
++      opc = &avr32_opc_table[AVR32_OPC_LDDPC];
++      align = 2;
++      r_type = BFD_RELOC_AVR32_9W_CP;
++      goto cpool_common;
++    case LDA_SUBTYPE_LDW:
++      opc = &avr32_opc_table[AVR32_OPC_LDDPC_EXT];
++      r_type = BFD_RELOC_AVR32_16_CP;
++    cpool_common:
++      opc->fields[0]->insert(opc->fields[0], p, regid);
++      ifield = opc->fields[1];
++      pool = fragP->tc_frag_data.pool;
++      exp.X_add_symbol = pool->symbol;
++      exp.X_add_number = pool->literals[fragP->tc_frag_data.pool_entry].offset;
++      pcrel = 1;
++      break;
++    case LDA_SUBTYPE_GOTLOAD_LARGE:
++      /* ld.w Rd, r6[Rd << 2] (last) */
++      opc = &avr32_opc_table[AVR32_OPC_LD_W5];
++      bfd_putb32(opc->value, p + 4);
++      opc->fields[0]->insert(opc->fields[0], p + 4, regid);
++      opc->fields[1]->insert(opc->fields[1], p + 4, 6);
++      opc->fields[2]->insert(opc->fields[2], p + 4, regid);
++      opc->fields[3]->insert(opc->fields[3], p + 4, 2);
++
++      /* mov Rd, (got_offset / 4) */
++      opc = &avr32_opc_table[AVR32_OPC_MOV2];
++      opc->fields[0]->insert(opc->fields[0], p, regid);
++      ifield = opc->fields[1];
++      r_type = BFD_RELOC_AVR32_LDA_GOT;
++      break;
++    case LDA_SUBTYPE_GOTLOAD:
++      opc = &avr32_opc_table[AVR32_OPC_LD_W4];
++      opc->fields[0]->insert(opc->fields[0], p, regid);
++      opc->fields[1]->insert(opc->fields[1], p, 6);
++      ifield = opc->fields[2];
++      if (r_type == BFD_RELOC_NONE)
++      r_type = BFD_RELOC_AVR32_GOT16S;
++      break;
++    default:
++      BAD_CASE(fragP->fr_subtype);
++    }
++
++  value = bfd_getb32(p);
++  value &= ~(opc->mask | ifield->mask);
++  value |= opc->value;
++  bfd_putb32(value, p);
++
++  fragP->fr_fix += fragP->fr_var - LDA_INITIAL_SIZE;
++
++  if (fragP->fr_next
++      && ((offsetT)(fragP->fr_next->fr_address - fragP->fr_address)
++        != fragP->fr_fix))
++    {
++      fprintf(stderr, "LDA frag: fr_fix is wrong! fragP->fr_var = %ld, r_type = %s\n",
++            fragP->fr_var, bfd_get_reloc_code_name(r_type));
++      abort();
++    }
++
++  fixP = fix_new_exp(fragP, fragP->fr_fix - fragP->fr_var, fragP->fr_var,
++                   &exp, pcrel, r_type);
++
++  /* Revert fix_new brain damage. "dot_value" is the value of PC at
++     the point of the fixup, relative to the frag address.  fix_new()
++     and friends think they are only being called during the assembly
++     pass, not during relaxation or similar, so fx_dot_value, fx_file
++     and fx_line are all initialized to the wrong value.  But we don't
++     know the size of the fixup until now, so we really can't live up
++     to the assumptions these functions make about the target.  What
++     do these functions think the "where" and "frag" argument mean
++     anyway?  */
++  fixP->fx_dot_value = fragP->fr_fix - opc->size;
++  fixP->fx_file = fragP->fr_file;
++  fixP->fx_line = fragP->fr_line;
++
++  fixP->tc_fix_data.ifield = ifield;
++  fixP->tc_fix_data.align = align;
++  /* these are only used if the fixup can actually be resolved */
++  fixP->tc_fix_data.min = -32768;
++  fixP->tc_fix_data.max = 32767;
++}
++
++static void
++avr32_call_convert_frag(bfd *abfd ATTRIBUTE_UNUSED,
++                     segT segment ATTRIBUTE_UNUSED,
++                     fragS *fragP)
++{
++  const struct avr32_opcode *opc = NULL;
++  const struct avr32_ifield *ifield;
++  bfd_reloc_code_real_type r_type;
++  symbolS *symbol;
++  offsetT offset;
++  fixS *fixP;
++  bfd_vma value;
++  int pcrel = 0, align = 0;
++  char *p;
++
++  symbol = fragP->fr_symbol;
++  offset = fragP->fr_offset;
++  r_type = BFD_RELOC_NONE;
++  p = fragP->fr_opcode;
++
++  pr_debug("%s:%d: call_convert_frag, subtype: %d, fix: %d, var: %d\n",
++         fragP->fr_file, fragP->fr_line,
++         fragP->fr_subtype, fragP->fr_fix, fragP->fr_var);
++
++  switch (fragP->fr_subtype)
++    {
++    case CALL_SUBTYPE_RCALL1:
++      opc = &avr32_opc_table[AVR32_OPC_RCALL1];
++      /* fall through */
++    case CALL_SUBTYPE_RCALL2:
++      if (!opc)
++      opc = &avr32_opc_table[AVR32_OPC_RCALL2];
++      ifield = opc->fields[0];
++      r_type = opc->reloc_type;
++      pcrel = 1;
++      align = 1;
++      break;
++    case CALL_SUBTYPE_MCALL_CP:
++      opc = &avr32_opc_table[AVR32_OPC_MCALL];
++      opc->fields[0]->insert(opc->fields[0], p, AVR32_REG_PC);
++      ifield = opc->fields[1];
++      r_type = BFD_RELOC_AVR32_CPCALL;
++      symbol = fragP->tc_frag_data.pool->symbol;
++      offset = fragP->tc_frag_data.pool->literals[fragP->tc_frag_data.pool_entry].offset;
++      assert(fragP->tc_frag_data.pool->literals[fragP->tc_frag_data.pool_entry].refcount > 0);
++      pcrel = 1;
++      align = 2;
++      break;
++    case CALL_SUBTYPE_MCALL_GOT:
++      opc = &avr32_opc_table[AVR32_OPC_MCALL];
++      opc->fields[0]->insert(opc->fields[0], p, 6);
++      ifield = opc->fields[1];
++      r_type = BFD_RELOC_AVR32_GOT18SW;
++      break;
++    case CALL_SUBTYPE_MCALL_LARGE:
++      assert(fragP->fr_var == 10);
++      /* ld.w lr, r6[lr << 2] */
++      opc = &avr32_opc_table[AVR32_OPC_LD_W5];
++      bfd_putb32(opc->value, p + 4);
++      opc->fields[0]->insert(opc->fields[0], p + 4, AVR32_REG_LR);
++      opc->fields[1]->insert(opc->fields[1], p + 4, 6);
++      opc->fields[2]->insert(opc->fields[2], p + 4, AVR32_REG_LR);
++      opc->fields[3]->insert(opc->fields[3], p + 4, 2);
++
++      /* icall lr */
++      opc = &avr32_opc_table[AVR32_OPC_ICALL];
++      bfd_putb16(opc->value >> 16, p + 8);
++      opc->fields[0]->insert(opc->fields[0], p + 8, AVR32_REG_LR);
++
++      /* mov lr, (got_offset / 4) */
++      opc = &avr32_opc_table[AVR32_OPC_MOV2];
++      opc->fields[0]->insert(opc->fields[0], p, AVR32_REG_LR);
++      ifield = opc->fields[1];
++      r_type = BFD_RELOC_AVR32_GOTCALL;
++      break;
++    default:
++      BAD_CASE(fragP->fr_subtype);
++    }
++
++  /* Insert the opcode and clear the variable ifield */
++  value = bfd_getb32(p);
++  value &= ~(opc->mask | ifield->mask);
++  value |= opc->value;
++  bfd_putb32(value, p);
++
++  fragP->fr_fix += fragP->fr_var - CALL_INITIAL_SIZE;
++
++  if (fragP->fr_next
++      && ((offsetT)(fragP->fr_next->fr_address - fragP->fr_address)
++        != fragP->fr_fix))
++    {
++      fprintf(stderr, "%s:%d: fr_fix %lu is wrong! fr_var=%lu, r_type=%s\n",
++            fragP->fr_file, fragP->fr_line,
++            fragP->fr_fix, fragP->fr_var, bfd_get_reloc_code_name(r_type));
++      fprintf(stderr, "fr_fix should be %ld. next frag is %s:%d\n",
++            (offsetT)(fragP->fr_next->fr_address - fragP->fr_address),
++            fragP->fr_next->fr_file, fragP->fr_next->fr_line);
++    }
++
++  fixP = fix_new(fragP, fragP->fr_fix - fragP->fr_var, fragP->fr_var,
++               symbol, offset, pcrel, r_type);
++
++  /* Revert fix_new brain damage. "dot_value" is the value of PC at
++     the point of the fixup, relative to the frag address.  fix_new()
++     and friends think they are only being called during the assembly
++     pass, not during relaxation or similar, so fx_dot_value, fx_file
++     and fx_line are all initialized to the wrong value.  But we don't
++     know the size of the fixup until now, so we really can't live up
++     to the assumptions these functions make about the target.  What
++     do these functions think the "where" and "frag" argument mean
++     anyway?  */
++  fixP->fx_dot_value = fragP->fr_fix - opc->size;
++  fixP->fx_file = fragP->fr_file;
++  fixP->fx_line = fragP->fr_line;
++
++  fixP->tc_fix_data.ifield = ifield;
++  fixP->tc_fix_data.align = align;
++  /* these are only used if the fixup can actually be resolved */
++  fixP->tc_fix_data.min = -2097152;
++  fixP->tc_fix_data.max = 2097150;
++}
++
++static void
++avr32_cpool_convert_frag(bfd *abfd ATTRIBUTE_UNUSED,
++                       segT segment ATTRIBUTE_UNUSED,
++                       fragS *fragP)
++{
++  struct cpool *pool;
++  addressT address;
++  unsigned int entry;
++  char *p;
++  char sym_name[20];
++
++  /* Did we get rid of the frag altogether? */
++  if (!fragP->fr_var)
++    return;
++
++  pool = fragP->tc_frag_data.pool;
++  address = fragP->fr_address + fragP->fr_fix;
++  p = fragP->fr_literal + fragP->fr_fix;
++
++  sprintf(sym_name, "$$cp_\002%x", pool->id);
++  symbol_locate(pool->symbol, sym_name, pool->section, fragP->fr_fix, fragP);
++  symbol_table_insert(pool->symbol);
++
++  for (entry = 0; entry < pool->next_free_entry; entry++)
++    {
++      if (pool->literals[entry].refcount > 0)
++      {
++        fix_new_exp(fragP, fragP->fr_fix, 4, &pool->literals[entry].exp,
++                    FALSE, BFD_RELOC_AVR32_32_CPENT);
++        fragP->fr_fix += 4;
++      }
++    }
++}
++
++static struct avr32_relaxer avr32_default_relaxer = {
++  .estimate_size      = avr32_default_estimate_size_before_relax,
++  .relax_frag         = avr32_default_relax_frag,
++  .convert_frag               = avr32_default_convert_frag,
++};
++static struct avr32_relaxer avr32_lda_relaxer = {
++  .estimate_size      = avr32_lda_estimate_size_before_relax,
++  .relax_frag         = avr32_lda_relax_frag,
++  .convert_frag               = avr32_lda_convert_frag,
++};
++static struct avr32_relaxer avr32_call_relaxer = {
++  .estimate_size      = avr32_call_estimate_size_before_relax,
++  .relax_frag         = avr32_call_relax_frag,
++  .convert_frag               = avr32_call_convert_frag,
++};
++static struct avr32_relaxer avr32_cpool_relaxer = {
++  .estimate_size      = avr32_cpool_estimate_size_before_relax,
++  .relax_frag         = avr32_cpool_relax_frag,
++  .convert_frag               = avr32_cpool_convert_frag,
++};
++
++static void s_cpool(int arg ATTRIBUTE_UNUSED)
++{
++  struct cpool *pool;
++  unsigned int max_size;
++  char *buf;
++
++  pool = find_cpool(now_seg, now_subseg);
++  if (!pool || !pool->symbol || pool->next_free_entry == 0)
++    return;
++
++  /* Make sure the constant pool is properly aligned */
++  frag_align_code(2, 0);
++
++  /* Assume none of the entries are discarded, and that we need the
++     maximum amount of alignment.  But we're not going to allocate
++     anything up front. */
++  max_size = pool->next_free_entry * 4 + 2;
++  frag_grow(max_size);
++  buf = frag_more(0);
++
++  frag_now->tc_frag_data.relaxer = &avr32_cpool_relaxer;
++  frag_now->tc_frag_data.pool = pool;
++
++  symbol_set_frag(pool->symbol, frag_now);
++
++  /* Assume zero initial size, allowing other relaxers to be
++     optimistic about things.  */
++  frag_var(rs_machine_dependent, max_size, 0,
++         0, pool->symbol, 0, NULL);
++
++  /* Mark the pool as empty.  */
++  pool->used = 1;
++}
++
++/* The location from which a PC relative jump should be calculated,
++   given a PC relative reloc.  */
++
++long
++md_pcrel_from_section (fixS *fixP, segT sec)
++{
++  pr_debug("pcrel_from_section, fx_offset = %d\n", fixP->fx_offset);
++
++  if (fixP->fx_addsy != NULL
++      && (! S_IS_DEFINED (fixP->fx_addsy)
++          || S_GET_SEGMENT (fixP->fx_addsy) != sec
++        || S_FORCE_RELOC(fixP->fx_addsy, 1)))
++    {
++      pr_debug("Unknown pcrel symbol: %s\n", S_GET_NAME(fixP->fx_addsy));
++
++      /* The symbol is undefined (or is defined but not in this section).
++       Let the linker figure it out.  */
++      return 0;
++    }
++
++  pr_debug("pcrel from %x + %x, symbol: %s (%x)\n",
++         fixP->fx_frag->fr_address, fixP->fx_where,
++         fixP->fx_addsy?S_GET_NAME(fixP->fx_addsy):"(null)",
++         fixP->fx_addsy?S_GET_VALUE(fixP->fx_addsy):0);
++
++  return ((fixP->fx_frag->fr_address + fixP->fx_where)
++        & (~0UL << fixP->tc_fix_data.align));
++}
++
++valueT
++md_section_align (segT segment, valueT size)
++{
++  int align = bfd_get_section_alignment (stdoutput, segment);
++  return ((size + (1 << align) - 1) & (-1 << align));
++}
++
++static int syntax_matches(const struct avr32_syntax *syntax,
++                        char *str)
++{
++  int i;
++
++  pr_debug("syntax %d matches `%s'?\n", syntax->id, str);
++
++  if (syntax->nr_operands < 0)
++    {
++      struct avr32_operand *op;
++      int optype;
++
++      for (i = 0; i < (-syntax->nr_operands - 1); i++)
++      {
++        char *p;
++        char c;
++
++        optype = syntax->operand[i];
++        assert(optype < AVR32_NR_OPERANDS);
++        op = &avr32_operand_table[optype];
++
++        for (p = str; *p; p++)
++          if (*p == ',')
++            break;
++
++        if (p == str)
++          return 0;
++
++        c = *p;
++        *p = 0;
++
++        if (!op->match(str))
++          {
++            *p = c;
++            return 0;
++          }
++
++        str = p;
++        *p = c;
++        if (c)
++          str++;
++      }
++
++      optype = syntax->operand[i];
++      assert(optype < AVR32_NR_OPERANDS);
++      op = &avr32_operand_table[optype];
++
++      if (!op->match(str))
++      return 0;
++      return 1;
++    }
++
++  for (i = 0; i < syntax->nr_operands; i++)
++    {
++      struct avr32_operand *op;
++      int optype = syntax->operand[i];
++      char *p;
++      char c;
++
++      assert(optype < AVR32_NR_OPERANDS);
++      op = &avr32_operand_table[optype];
++
++      for (p = str; *p; p++)
++      if (*p == ',')
++        break;
++
++      if (p == str)
++      return 0;
++
++      c = *p;
++      *p = 0;
++
++      if (!op->match(str))
++      {
++        *p = c;
++        return 0;
++      }
++
++      str = p;
++      *p = c;
++      if (c)
++      str++;
++    }
++
++  if (*str == '\0')
++    return 1;
++
++  if ((*str == 'e' || *str == 'E') && !str[1])
++    return 1;
++
++  return 0;
++}
++
++static int parse_operands(char *str)
++{
++  int i;
++
++  if (current_insn.syntax->nr_operands < 0)
++    {
++      int optype;
++      struct avr32_operand *op;
++
++      for (i = 0; i < (-current_insn.syntax->nr_operands - 1); i++)
++      {
++        char *p;
++        char c;
++
++        optype = current_insn.syntax->operand[i];
++        op = &avr32_operand_table[optype];
++
++        for (p = str; *p; p++)
++          if (*p == ',')
++            break;
++
++        assert(p != str);
++
++        c = *p, *p = 0;
++        op->parse(op, str, i);
++        *p = c;
++
++        str = p;
++        if (c) str++;
++      }
++
++      /* give the rest of the line to the last operand */
++      optype = current_insn.syntax->operand[i];
++      op = &avr32_operand_table[optype];
++      op->parse(op, str, i);
++    }
++  else
++    {
++      for (i = 0; i < current_insn.syntax->nr_operands; i++)
++      {
++        int optype = current_insn.syntax->operand[i];
++        struct avr32_operand *op = &avr32_operand_table[optype];
++        char *p;
++        char c;
++
++        skip_whitespace(str);
++
++        for (p = str; *p; p++)
++          if (*p == ',')
++            break;
++
++        assert(p != str);
++
++        c = *p, *p = 0;
++        op->parse(op, str, i);
++        *p = c;
++
++        str = p;
++        if (c) str++;
++      }
++
++      if (*str == 'E' || *str == 'e')
++      current_insn.force_extended = 1;
++    }
++
++  return 0;
++}
++
++static const char *
++finish_insn(const struct avr32_opcode *opc)
++{
++  expressionS *exp = &current_insn.immediate;
++  unsigned int i;
++  int will_relax = 0;
++  char *buf;
++
++  assert(current_insn.next_slot == opc->nr_fields);
++
++  pr_debug("%s:%d: finish_insn: trying opcode %d\n",
++         frag_now->fr_file, frag_now->fr_line, opc->id);
++
++  /* Go through the relaxation stage for all instructions that can
++     possibly take a symbolic immediate.  The relax code will take
++     care of range checking and alignment.  */
++  if (opc->var_field != -1)
++    {
++      int substate, largest_substate;
++      symbolS *sym;
++      offsetT off;
++
++      will_relax = 1;
++      substate = largest_substate = opc_initial_substate(opc);
++
++      while (relax_more(largest_substate) != AVR32_RS_NONE)
++      largest_substate = relax_more(largest_substate);
++
++      pr_debug("will relax. initial substate: %d (size %d), largest substate: %d (size %d)\n",
++             substate, avr32_rs_size(substate),
++             largest_substate, avr32_rs_size(largest_substate));
++
++      /* make sure we have enough room for the largest possible opcode */
++      frag_grow(avr32_rs_size(largest_substate));
++      buf = frag_more(opc->size);
++
++      dwarf2_emit_insn(opc->size);
++
++      frag_now->tc_frag_data.reloc_info = AVR32_OPINFO_NONE;
++      frag_now->tc_frag_data.pcrel = current_insn.pcrel;
++      frag_now->tc_frag_data.force_extended = current_insn.force_extended;
++      frag_now->tc_frag_data.relaxer = &avr32_default_relaxer;
++
++      if (exp->X_op == O_hi)
++      {
++        frag_now->tc_frag_data.reloc_info = AVR32_OPINFO_HI;
++        exp->X_op = exp->X_md;
++      }
++      else if (exp->X_op == O_lo)
++      {
++        frag_now->tc_frag_data.reloc_info = AVR32_OPINFO_LO;
++        exp->X_op = exp->X_md;
++      }
++      else if (exp->X_op == O_got)
++      {
++        frag_now->tc_frag_data.reloc_info = AVR32_OPINFO_GOT;
++        exp->X_op = O_symbol;
++      }
++
++#if 0
++      if ((opc->reloc_type == BFD_RELOC_AVR32_SUB5)
++        && exp->X_op == O_subtract)
++      {
++        symbolS *tmp;
++        tmp = exp->X_add_symbol;
++        exp->X_add_symbol = exp->X_op_symbol;
++        exp->X_op_symbol = tmp;
++      }
++#endif
++
++      frag_now->tc_frag_data.exp = current_insn.immediate;
++
++      sym = exp->X_add_symbol;
++      off = exp->X_add_number;
++      if (exp->X_op != O_symbol)
++      {
++        sym = make_expr_symbol(exp);
++        off = 0;
++      }
++
++      frag_var(rs_machine_dependent,
++             avr32_rs_size(largest_substate) - opc->size,
++             opc->size,
++             substate, sym, off, buf);
++    }
++  else
++    {
++      assert(avr32_rs_size(opc_initial_substate(opc)) == 0);
++
++      /* Make sure we always have room for another whole word, as the ifield
++       inserters can only write words. */
++      frag_grow(4);
++      buf = frag_more(opc->size);
++      dwarf2_emit_insn(opc->size);
++    }
++
++  assert(!(opc->value & ~opc->mask));
++
++  pr_debug("inserting opcode: 0x%lx\n", opc->value);
++  bfd_putb32(opc->value, buf);
++
++  for (i = 0; i < opc->nr_fields; i++)
++    {
++      const struct avr32_ifield *f = opc->fields[i];
++      const struct avr32_ifield_data *fd = &current_insn.field_value[i];
++
++      pr_debug("inserting field: 0x%lx & 0x%lx\n",
++             fd->value >> fd->align_order, f->mask);
++
++      f->insert(f, buf, fd->value >> fd->align_order);
++    }
++
++  assert(will_relax || !current_insn.immediate.X_add_symbol);
++  return NULL;
++}
++
++static const char *
++finish_alias(const struct avr32_alias *alias)
++{
++  const struct avr32_opcode *opc;
++  struct {
++    unsigned long value;
++    unsigned long align;
++  } mapped_operand[AVR32_MAX_OPERANDS];
++  unsigned int i;
++
++  opc = alias->opc;
++
++  /* Remap the operands from the alias to the real opcode */
++  for (i = 0; i < opc->nr_fields; i++)
++    {
++      if (alias->operand_map[i].is_opindex)
++      {
++        struct avr32_ifield_data *fd;
++        fd = &current_insn.field_value[alias->operand_map[i].value];
++        mapped_operand[i].value = fd->value;
++        mapped_operand[i].align = fd->align_order;
++      }
++      else
++      {
++        mapped_operand[i].value = alias->operand_map[i].value;
++        mapped_operand[i].align = 0;
++      }
++    }
++
++  for (i = 0; i < opc->nr_fields; i++)
++    {
++      current_insn.field_value[i].value = mapped_operand[i].value;
++      if (opc->id == AVR32_OPC_COP)
++      current_insn.field_value[i].align_order = 0;
++      else
++      current_insn.field_value[i].align_order
++        = mapped_operand[i].align;
++    }
++
++  current_insn.next_slot = opc->nr_fields;
++
++  return finish_insn(opc);
++}
++
++static const char *
++finish_lda(const struct avr32_syntax *syntax ATTRIBUTE_UNUSED)
++{
++  expressionS *exp = &current_insn.immediate;
++  relax_substateT initial_subtype;
++  symbolS *sym;
++  offsetT off;
++  int initial_size, max_size;
++  char *buf;
++
++  initial_size = LDA_INITIAL_SIZE;
++
++  if (avr32_pic)
++    {
++      initial_subtype = LDA_SUBTYPE_SUB;
++      if (linkrelax)
++      max_size = 8;
++      else
++      max_size = 4;
++    }
++  else
++    {
++      initial_subtype = LDA_SUBTYPE_MOV1;
++      max_size = 4;
++    }
++
++  frag_grow(max_size);
++  buf = frag_more(initial_size);
++  dwarf2_emit_insn(initial_size);
++
++  if (exp->X_op == O_symbol)
++    {
++      sym = exp->X_add_symbol;
++      off = exp->X_add_number;
++    }
++  else
++    {
++      sym = make_expr_symbol(exp);
++      off = 0;
++    }
++
++  frag_now->tc_frag_data.reloc_info = current_insn.field_value[0].value;
++  frag_now->tc_frag_data.relaxer = &avr32_lda_relaxer;
++
++  if (!avr32_pic)
++    {
++      /* The relaxer will bump the refcount if necessary */
++      frag_now->tc_frag_data.pool
++      = add_to_cpool(exp, &frag_now->tc_frag_data.pool_entry, 0);
++    }
++
++  frag_var(rs_machine_dependent, max_size - initial_size,
++         initial_size, initial_subtype, sym, off, buf);
++
++  return NULL;
++}
++
++static const char *
++finish_call(const struct avr32_syntax *syntax ATTRIBUTE_UNUSED)
++{
++  expressionS *exp = &current_insn.immediate;
++  symbolS *sym;
++  offsetT off;
++  int initial_size, max_size;
++  char *buf;
++
++  initial_size = CALL_INITIAL_SIZE;
++
++  if (avr32_pic)
++    {
++      if (linkrelax)
++      max_size = 10;
++      else
++      max_size = 4;
++    }
++  else
++    max_size = 4;
++
++  frag_grow(max_size);
++  buf = frag_more(initial_size);
++  dwarf2_emit_insn(initial_size);
++
++  frag_now->tc_frag_data.relaxer = &avr32_call_relaxer;
++
++  if (exp->X_op == O_symbol)
++    {
++      sym = exp->X_add_symbol;
++      off = exp->X_add_number;
++    }
++  else
++    {
++      sym = make_expr_symbol(exp);
++      off = 0;
++    }
++
++  if (!avr32_pic)
++    {
++      /* The relaxer will bump the refcount if necessary */
++      frag_now->tc_frag_data.pool
++      = add_to_cpool(exp, &frag_now->tc_frag_data.pool_entry, 0);
++    }
++
++  frag_var(rs_machine_dependent, max_size - initial_size,
++         initial_size, CALL_SUBTYPE_RCALL1, sym, off, buf);
++
++  return NULL;
++}
++
++void
++md_begin (void)
++{
++  unsigned long flags = 0;
++  int i;
++
++  avr32_mnemonic_htab = hash_new();
++
++  if (!avr32_mnemonic_htab)
++    as_fatal(_("virtual memory exhausted"));
++
++  for (i = 0; i < AVR32_NR_MNEMONICS; i++)
++    {
++      hash_insert(avr32_mnemonic_htab, avr32_mnemonic_table[i].name,
++                (void *)&avr32_mnemonic_table[i]);
++    }
++
++  if (linkrelax)
++    flags |= EF_AVR32_LINKRELAX;
++  if (avr32_pic)
++    flags |= EF_AVR32_PIC;
++
++  bfd_set_private_flags(stdoutput, flags);
++
++#ifdef OPC_CONSISTENCY_CHECK
++  if (sizeof(avr32_operand_table)/sizeof(avr32_operand_table[0])
++      < AVR32_NR_OPERANDS)
++    as_fatal(_("operand table is incomplete"));
++
++  for (i = 0; i < AVR32_NR_OPERANDS; i++)
++    if (avr32_operand_table[i].id != i)
++      as_fatal(_("operand table inconsistency found at index %d\n"), i);
++  pr_debug("%d operands verified\n", AVR32_NR_OPERANDS);
++
++  for (i = 0; i < AVR32_NR_IFIELDS; i++)
++    if (avr32_ifield_table[i].id != i)
++      as_fatal(_("ifield table inconsistency found at index %d\n"), i);
++  pr_debug("%d instruction fields verified\n", AVR32_NR_IFIELDS);
++
++  for (i = 0; i < AVR32_NR_OPCODES; i++)
++    {
++      if (avr32_opc_table[i].id != i)
++      as_fatal(_("opcode table inconsistency found at index %d\n"), i);
++      if ((avr32_opc_table[i].var_field == -1
++         && avr32_relax_table[i].length != 0)
++        || (avr32_opc_table[i].var_field != -1
++            && avr32_relax_table[i].length == 0))
++      as_fatal(_("relax table inconsistency found at index %d\n"), i);
++    }
++  pr_debug("%d opcodes verified\n", AVR32_NR_OPCODES);
++
++  for (i = 0; i < AVR32_NR_SYNTAX; i++)
++    if (avr32_syntax_table[i].id != i)
++      as_fatal(_("syntax table inconsistency found at index %d\n"), i);
++  pr_debug("%d syntax variants verified\n", AVR32_NR_SYNTAX);
++
++  for (i = 0; i < AVR32_NR_ALIAS; i++)
++    if (avr32_alias_table[i].id != i)
++      as_fatal(_("alias table inconsistency found at index %d\n"), i);
++  pr_debug("%d aliases verified\n", AVR32_NR_ALIAS);
++
++  for (i = 0; i < AVR32_NR_MNEMONICS; i++)
++    if (avr32_mnemonic_table[i].id != i)
++      as_fatal(_("mnemonic table inconsistency found at index %d\n"), i);
++  pr_debug("%d mnemonics verified\n", AVR32_NR_MNEMONICS);
++#endif
++}
++
++void
++md_assemble (char *str)
++{
++  struct avr32_mnemonic *mnemonic;
++  char *p, c;
++
++  memset(&current_insn, 0, sizeof(current_insn));
++  current_insn.immediate.X_op = O_constant;
++
++  skip_whitespace(str);
++  for (p = str; *p; p++)
++    if (*p == ' ')
++      break;
++  c = *p;
++  *p = 0;
++
++  mnemonic = hash_find(avr32_mnemonic_htab, str);
++  *p = c;
++  if (c) p++;
++
++  if (mnemonic)
++    {
++      const struct avr32_syntax *syntax;
++
++      for (syntax = mnemonic->syntax; syntax; syntax = syntax->next)
++      {
++        const char *errmsg = NULL;
++
++        if (syntax_matches(syntax, p))
++          {
++            if (!(syntax->isa_flags & avr32_arch->isa_flags))
++              {
++                as_bad(_("Selected architecture `%s'  does not support `%s'"),
++                       avr32_arch->name, str);
++                return;
++              }
++
++            current_insn.syntax = syntax;
++            parse_operands(p);
++
++            switch (syntax->type)
++              {
++              case AVR32_PARSER_NORMAL:
++                errmsg = finish_insn(syntax->u.opc);
++                break;
++              case AVR32_PARSER_ALIAS:
++                errmsg = finish_alias(syntax->u.alias);
++                break;
++              case AVR32_PARSER_LDA:
++                errmsg = finish_lda(syntax);
++                break;
++              case AVR32_PARSER_CALL:
++                errmsg = finish_call(syntax);
++                break;
++              default:
++                BAD_CASE(syntax->type);
++                break;
++              }
++
++            if (errmsg)
++              as_bad("%s in `%s'", errmsg, str);
++
++            return;
++          }
++      }
++
++      as_bad(_("unrecognized form of instruction: `%s'"), str);
++    }
++  else
++    as_bad(_("unrecognized instruction `%s'"), str);
++}
++
++void avr32_cleanup(void)
++{
++  struct cpool *pool;
++
++  /* Emit any constant pools that haven't been explicitly flushed with
++     a .cpool directive. */
++  for (pool = cpool_list; pool; pool = pool->next)
++    {
++      subseg_set(pool->section, pool->sub_section);
++      s_cpool(0);
++    }
++}
++
++/* Handle any PIC-related operands in data allocation pseudo-ops */
++void
++avr32_cons_fix_new (fragS *frag, int off, int size, expressionS *exp)
++{
++  bfd_reloc_code_real_type r_type = BFD_RELOC_UNUSED;
++  int pcrel = 0;
++
++  pr_debug("%s:%u: cons_fix_new, add_sym: %s, op_sym: %s, op: %d, add_num: %d\n",
++         frag->fr_file, frag->fr_line,
++         exp->X_add_symbol?S_GET_NAME(exp->X_add_symbol):"(none)",
++         exp->X_op_symbol?S_GET_NAME(exp->X_op_symbol):"(none)",
++         exp->X_op, exp->X_add_number);
++
++  if (exp->X_op == O_subtract && exp->X_op_symbol)
++    {
++      if (exp->X_op_symbol == GOT_symbol)
++      {
++        if (size != 4)
++          goto bad_size;
++        r_type = BFD_RELOC_AVR32_GOTPC;
++        exp->X_op = O_symbol;
++        exp->X_op_symbol = NULL;
++      }
++    }
++  else if (exp->X_op == O_got)
++    {
++      switch (size)
++      {
++      case 1:
++        r_type = BFD_RELOC_AVR32_GOT8;
++        break;
++      case 2:
++        r_type = BFD_RELOC_AVR32_GOT16;
++        break;
++      case 4:
++        r_type = BFD_RELOC_AVR32_GOT32;
++        break;
++      default:
++        goto bad_size;
++      }
++
++      exp->X_op = O_symbol;
++    }
++
++  if (r_type == BFD_RELOC_UNUSED)
++    switch (size)
++      {
++      case 1:
++      r_type = BFD_RELOC_8;
++      break;
++      case 2:
++      r_type = BFD_RELOC_16;
++      break;
++      case 4:
++      r_type = BFD_RELOC_32;
++      break;
++      default:
++      goto bad_size;
++      }
++  else if (size != 4)
++    {
++    bad_size:
++      as_bad(_("unsupported BFD relocation size %u"), size);
++      r_type = BFD_RELOC_UNUSED;
++    }
++
++  fix_new_exp (frag, off, size, exp, pcrel, r_type);
++}
++
++static void
++avr32_frob_section(bfd *abfd ATTRIBUTE_UNUSED, segT sec,
++                 void *ignore ATTRIBUTE_UNUSED)
++{
++  segment_info_type *seginfo;
++  fixS *fix;
++
++  seginfo = seg_info(sec);
++  if (!seginfo)
++    return;
++
++  for (fix = seginfo->fix_root; fix; fix = fix->fx_next)
++    {
++      if (fix->fx_done)
++      continue;
++
++      if (fix->fx_r_type == BFD_RELOC_AVR32_SUB5
++        && fix->fx_addsy && fix->fx_subsy)
++      {
++        if (S_GET_SEGMENT(fix->fx_addsy) != S_GET_SEGMENT(fix->fx_subsy)
++            || linkrelax)
++          {
++            symbolS *tmp;
++#ifdef DEBUG
++            fprintf(stderr, "Swapping symbols in fixup:\n");
++            print_fixup(fix);
++#endif
++            tmp = fix->fx_addsy;
++            fix->fx_addsy = fix->fx_subsy;
++            fix->fx_subsy = tmp;
++            fix->fx_offset = -fix->fx_offset;
++          }
++      }
++    }
++}
++
++/* We need to look for SUB5 instructions with expressions that will be
++   made PC-relative and switch fx_addsy with fx_subsy.  This has to be
++   done before adjustment or the wrong symbol might be adjusted.
++
++   This applies to fixups that are a result of expressions like -(sym
++   - .) and that will make it all the way to md_apply_fix3().  LDA
++   does the right thing in convert_frag, so we must not convert
++   those. */
++void
++avr32_frob_file(void)
++{
++  /* if (1 || !linkrelax)
++     return; */
++
++  bfd_map_over_sections(stdoutput, avr32_frob_section, NULL);
++}
++
++static bfd_boolean
++convert_to_diff_reloc(fixS *fixP)
++{
++  switch (fixP->fx_r_type)
++    {
++    case BFD_RELOC_32:
++      fixP->fx_r_type = BFD_RELOC_AVR32_DIFF32;
++      break;
++    case BFD_RELOC_16:
++      fixP->fx_r_type = BFD_RELOC_AVR32_DIFF16;
++      break;
++    case BFD_RELOC_8:
++      fixP->fx_r_type = BFD_RELOC_AVR32_DIFF8;
++      break;
++    default:
++      return FALSE;
++    }
++
++  return TRUE;
++}
++
++/* Simplify a fixup.  If possible, the fixup is reduced to a single
++   constant which is written to the output file.  Otherwise, a
++   relocation is generated so that the linker can take care of the
++   rest.
++
++   ELF relocations have certain constraints: They can only take a
++   single symbol and a single addend.  This means that for difference
++   expressions, we _must_ get rid of the fx_subsy symbol somehow.
++
++   The difference between two labels in the same section can be
++   calculated directly unless 'linkrelax' is set, or a relocation is
++   forced.  If so, we must emit a R_AVR32_DIFFxx relocation.  If there
++   are addends involved at this point, we must be especially careful
++   as the relocation must point exactly to the symbol being
++   subtracted.
++
++   When subtracting a symbol defined in the same section as the fixup,
++   we might be able to convert it to a PC-relative expression, unless
++   linkrelax is set. If this is the case, there's no way we can make
++   sure that the difference between the fixup and fx_subsy stays
++   constant.  So for now, we're just going to disallow that.
++   */
++void
++avr32_process_fixup(fixS *fixP, segT this_segment)
++{
++  segT add_symbol_segment = absolute_section;
++  segT sub_symbol_segment = absolute_section;
++  symbolS *fx_addsy, *fx_subsy;
++  offsetT value = 0, fx_offset;
++  bfd_boolean apply = FALSE;
++
++  assert(this_segment != absolute_section);
++
++  if (fixP->fx_r_type >= BFD_RELOC_UNUSED)
++    {
++      as_bad_where(fixP->fx_file, fixP->fx_line,
++                 _("Bad relocation type %d\n"), fixP->fx_r_type);
++      return;
++    }
++
++  /* BFD_RELOC_AVR32_SUB5 fixups have been swapped by avr32_frob_section() */
++  fx_addsy = fixP->fx_addsy;
++  fx_subsy = fixP->fx_subsy;
++  fx_offset = fixP->fx_offset;
++
++  if (fx_addsy)
++    add_symbol_segment = S_GET_SEGMENT(fx_addsy);
++
++  if (fx_subsy)
++    {
++      resolve_symbol_value(fx_subsy);
++      sub_symbol_segment = S_GET_SEGMENT(fx_subsy);
++
++      if (sub_symbol_segment == this_segment
++        && (!linkrelax
++            || S_GET_VALUE(fx_subsy) == (fixP->fx_frag->fr_address
++                                         + fixP->fx_where)))
++      {
++        fixP->fx_pcrel = TRUE;
++        fx_offset += (fixP->fx_frag->fr_address + fixP->fx_where
++                      - S_GET_VALUE(fx_subsy));
++        fx_subsy = NULL;
++      }
++      else if (sub_symbol_segment == absolute_section)
++      {
++        /* The symbol is really a constant.  */
++        fx_offset -= S_GET_VALUE(fx_subsy);
++        fx_subsy = NULL;
++      }
++      else if (SEG_NORMAL(add_symbol_segment)
++             && sub_symbol_segment == add_symbol_segment
++             && (!linkrelax || convert_to_diff_reloc(fixP)))
++      {
++        /* Difference between two labels in the same section.  */
++        if (linkrelax)
++          {
++            /* convert_to_diff() has ensured that the reloc type is
++               either DIFF32, DIFF16 or DIFF8.  */
++            value = (S_GET_VALUE(fx_addsy) + fixP->fx_offset
++                     - S_GET_VALUE(fx_subsy));
++
++            /* Try to convert it to a section symbol if possible  */
++            if (!S_FORCE_RELOC(fx_addsy, 1)
++                && !(sub_symbol_segment->flags & SEC_THREAD_LOCAL))
++              {
++                fx_offset = S_GET_VALUE(fx_subsy);
++                fx_addsy = section_symbol(sub_symbol_segment);
++              }
++            else
++              {
++                fx_addsy = fx_subsy;
++                fx_offset = 0;
++              }
++
++            fx_subsy = NULL;
++            apply = TRUE;
++          }
++        else
++          {
++            fx_offset += S_GET_VALUE(fx_addsy);
++            fx_offset -= S_GET_VALUE(fx_subsy);
++            fx_addsy = NULL;
++            fx_subsy = NULL;
++          }
++      }
++      else
++      {
++        as_bad_where(fixP->fx_file, fixP->fx_line,
++                     _("can't resolve `%s' {%s section} - `%s' {%s section}"),
++                     fx_addsy ? S_GET_NAME (fx_addsy) : "0",
++                     segment_name (add_symbol_segment),
++                     S_GET_NAME (fx_subsy),
++                     segment_name (sub_symbol_segment));
++        return;
++      }
++    }
++
++  if (fx_addsy && !TC_FORCE_RELOCATION(fixP))
++    {
++      if (add_symbol_segment == this_segment
++        && fixP->fx_pcrel)
++      {
++        value += S_GET_VALUE(fx_addsy);
++        value -= md_pcrel_from_section(fixP, this_segment);
++        fx_addsy = NULL;
++        fixP->fx_pcrel = FALSE;
++      }
++      else if (add_symbol_segment == absolute_section)
++      {
++        fx_offset += S_GET_VALUE(fixP->fx_addsy);
++        fx_addsy = NULL;
++      }
++    }
++
++  if (!fx_addsy)
++    fixP->fx_done = TRUE;
++
++  if (fixP->fx_pcrel)
++    {
++      if (fx_addsy != NULL
++        && S_IS_DEFINED(fx_addsy)
++        && S_GET_SEGMENT(fx_addsy) != this_segment)
++      value += md_pcrel_from_section(fixP, this_segment);
++
++      switch (fixP->fx_r_type)
++      {
++      case BFD_RELOC_32:
++        fixP->fx_r_type = BFD_RELOC_32_PCREL;
++        break;
++      case BFD_RELOC_16:
++        fixP->fx_r_type = BFD_RELOC_16_PCREL;
++        break;
++      case BFD_RELOC_8:
++        fixP->fx_r_type = BFD_RELOC_8_PCREL;
++        break;
++      case BFD_RELOC_AVR32_SUB5:
++        fixP->fx_r_type = BFD_RELOC_AVR32_16N_PCREL;
++        break;
++      case BFD_RELOC_AVR32_16S:
++        fixP->fx_r_type = BFD_RELOC_AVR32_16B_PCREL;
++        break;
++      case BFD_RELOC_AVR32_14UW:
++        fixP->fx_r_type = BFD_RELOC_AVR32_14UW_PCREL;
++        break;
++      case BFD_RELOC_AVR32_10UW:
++        fixP->fx_r_type = BFD_RELOC_AVR32_10UW_PCREL;
++        break;
++      default:
++        /* Should have been taken care of already */
++        break;
++      }
++    }
++
++  if (fixP->fx_done || apply)
++    {
++      const struct avr32_ifield *ifield;
++      char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
++
++      if (fixP->fx_done)
++      value += fx_offset;
++
++      switch (fixP->fx_r_type)
++      {
++      case BFD_RELOC_32:
++      case BFD_RELOC_16:
++      case BFD_RELOC_8:
++      case BFD_RELOC_AVR32_DIFF32:
++      case BFD_RELOC_AVR32_DIFF16:
++      case BFD_RELOC_AVR32_DIFF8:
++        md_number_to_chars(buf, value, fixP->fx_size);
++        break;
++      case BFD_RELOC_HI16:
++        value >>= 16;
++      case BFD_RELOC_LO16:
++        value &= 0xffff;
++        md_number_to_chars(buf + 2, value, 2);
++        break;
++      case BFD_RELOC_AVR32_16N_PCREL:
++        value = -value;
++        /* fall through */
++      case BFD_RELOC_AVR32_22H_PCREL:
++      case BFD_RELOC_AVR32_18W_PCREL:
++      case BFD_RELOC_AVR32_16B_PCREL:
++      case BFD_RELOC_AVR32_11H_PCREL:
++      case BFD_RELOC_AVR32_9H_PCREL:
++      case BFD_RELOC_AVR32_9UW_PCREL:
++      case BFD_RELOC_AVR32_3U:
++      case BFD_RELOC_AVR32_4UH:
++      case BFD_RELOC_AVR32_6UW:
++      case BFD_RELOC_AVR32_6S:
++      case BFD_RELOC_AVR32_7UW:
++      case BFD_RELOC_AVR32_8S_EXT:
++      case BFD_RELOC_AVR32_8S:
++      case BFD_RELOC_AVR32_10UW:
++      case BFD_RELOC_AVR32_10SW:
++      case BFD_RELOC_AVR32_STHH_W:
++      case BFD_RELOC_AVR32_14UW:
++      case BFD_RELOC_AVR32_16S:
++      case BFD_RELOC_AVR32_16U:
++      case BFD_RELOC_AVR32_21S:
++      case BFD_RELOC_AVR32_SUB5:
++      case BFD_RELOC_AVR32_CPCALL:
++      case BFD_RELOC_AVR32_16_CP:
++      case BFD_RELOC_AVR32_9W_CP:
++        ifield = fixP->tc_fix_data.ifield;
++        pr_debug("insert field: %ld <= %ld <= %ld (align %u)\n",
++                 fixP->tc_fix_data.min, value, fixP->tc_fix_data.max,
++                 fixP->tc_fix_data.align);
++        if (value < fixP->tc_fix_data.min || value > fixP->tc_fix_data.max)
++          as_bad_where(fixP->fx_file, fixP->fx_line,
++                       _("operand out of range (%ld not between %ld and %ld)"),
++                       value, fixP->tc_fix_data.min, fixP->tc_fix_data.max);
++        if (value & ((1 << fixP->tc_fix_data.align) - 1))
++          as_bad_where(fixP->fx_file, fixP->fx_line,
++                       _("misaligned operand (required alignment: %d)"),
++                       1 << fixP->tc_fix_data.align);
++        ifield->insert(ifield, buf, value >> fixP->tc_fix_data.align);
++        break;
++      case BFD_RELOC_AVR32_ALIGN:
++        /* Nothing to do */
++        fixP->fx_done = FALSE;
++        break;
++      default:
++        as_fatal("reloc type %s not handled\n",
++                 bfd_get_reloc_code_name(fixP->fx_r_type));
++      }
++    }
++
++  fixP->fx_addsy = fx_addsy;
++  fixP->fx_subsy = fx_subsy;
++  fixP->fx_offset = fx_offset;
++
++  if (!fixP->fx_done)
++    {
++      if (!fixP->fx_addsy)
++      fixP->fx_addsy = abs_section_sym;
++
++      symbol_mark_used_in_reloc(fixP->fx_addsy);
++      if (fixP->fx_subsy)
++      abort();
++    }
++}
++
++#if 0
++void
++md_apply_fix3 (fixS *fixP, valueT *valP, segT seg)
++{
++  const struct avr32_ifield *ifield;
++  offsetT     value = *valP;
++  char                *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
++  bfd_boolean apply;
++
++  pr_debug("%s:%u: apply_fix3: r_type=%d value=%lx offset=%lx\n",
++         fixP->fx_file, fixP->fx_line, fixP->fx_r_type, *valP,
++         fixP->fx_offset);
++
++  if (fixP->fx_r_type >= BFD_RELOC_UNUSED)
++    {
++      as_bad_where(fixP->fx_file, fixP->fx_line,
++                 _("Bad relocation type %d\n"), fixP->fx_r_type);
++      return;
++    }
++
++  if (!fixP->fx_addsy && !fixP->fx_subsy)
++    fixP->fx_done = 1;
++
++  if (fixP->fx_pcrel)
++    {
++      if (fixP->fx_addsy != NULL
++        && S_IS_DEFINED(fixP->fx_addsy)
++        && S_GET_SEGMENT(fixP->fx_addsy) != seg)
++      value += md_pcrel_from_section(fixP, seg);
++
++      switch (fixP->fx_r_type)
++      {
++      case BFD_RELOC_32:
++        fixP->fx_r_type = BFD_RELOC_32_PCREL;
++        break;
++      case BFD_RELOC_16:
++      case BFD_RELOC_8:
++        as_bad_where (fixP->fx_file, fixP->fx_line,
++                      _("8- and 16-bit PC-relative relocations not supported"));
++        break;
++      case BFD_RELOC_AVR32_SUB5:
++        fixP->fx_r_type = BFD_RELOC_AVR32_PCREL_SUB5;
++        break;
++      case BFD_RELOC_AVR32_16S:
++        fixP->fx_r_type = BFD_RELOC_AVR32_16_PCREL;
++        break;
++      default:
++        /* Should have been taken care of already */
++        break;
++      }
++    }
++
++  if (fixP->fx_r_type == BFD_RELOC_32
++      && fixP->fx_subsy)
++    {
++      fixP->fx_r_type = BFD_RELOC_AVR32_DIFF32;
++
++      /* Offsets are only allowed if it's a result of adjusting a
++       local symbol into a section-relative offset.
++       tc_fix_adjustable() should prevent any adjustment if there
++       was an offset involved before.  */
++      if (fixP->fx_offset && !symbol_section_p(fixP->fx_addsy))
++      as_bad_where(fixP->fx_file, fixP->fx_line,
++                   _("cannot represent symbol difference with an offset"));
++
++      value = (S_GET_VALUE(fixP->fx_addsy) + fixP->fx_offset
++             - S_GET_VALUE(fixP->fx_subsy));
++
++      /* The difference before any relaxing takes place is written
++       out, and the DIFF32 reloc identifies the address of the first
++       symbol (i.e. the on that's subtracted.)  */
++      *valP = value;
++      fixP->fx_offset -= value;
++      fixP->fx_subsy = NULL;
++
++      md_number_to_chars(buf, value, fixP->fx_size);
++    }
++
++  if (fixP->fx_done)
++    {
++      switch (fixP->fx_r_type)
++      {
++      case BFD_RELOC_8:
++      case BFD_RELOC_16:
++      case BFD_RELOC_32:
++        md_number_to_chars(buf, value, fixP->fx_size);
++        break;
++      case BFD_RELOC_HI16:
++        value >>= 16;
++      case BFD_RELOC_LO16:
++        value &= 0xffff;
++        *valP = value;
++        md_number_to_chars(buf + 2, value, 2);
++        break;
++      case BFD_RELOC_AVR32_PCREL_SUB5:
++        value = -value;
++        /* fall through */
++      case BFD_RELOC_AVR32_9_PCREL:
++      case BFD_RELOC_AVR32_11_PCREL:
++      case BFD_RELOC_AVR32_16_PCREL:
++      case BFD_RELOC_AVR32_18_PCREL:
++      case BFD_RELOC_AVR32_22_PCREL:
++      case BFD_RELOC_AVR32_3U:
++      case BFD_RELOC_AVR32_4UH:
++      case BFD_RELOC_AVR32_6UW:
++      case BFD_RELOC_AVR32_6S:
++      case BFD_RELOC_AVR32_7UW:
++      case BFD_RELOC_AVR32_8S:
++      case BFD_RELOC_AVR32_10UW:
++      case BFD_RELOC_AVR32_10SW:
++      case BFD_RELOC_AVR32_14UW:
++      case BFD_RELOC_AVR32_16S:
++      case BFD_RELOC_AVR32_16U:
++      case BFD_RELOC_AVR32_21S:
++      case BFD_RELOC_AVR32_BRC1:
++      case BFD_RELOC_AVR32_SUB5:
++      case BFD_RELOC_AVR32_CPCALL:
++      case BFD_RELOC_AVR32_16_CP:
++      case BFD_RELOC_AVR32_9_CP:
++        ifield = fixP->tc_fix_data.ifield;
++        pr_debug("insert field: %ld <= %ld <= %ld (align %u)\n",
++                 fixP->tc_fix_data.min, value, fixP->tc_fix_data.max,
++                 fixP->tc_fix_data.align);
++        if (value < fixP->tc_fix_data.min || value > fixP->tc_fix_data.max)
++          as_bad_where(fixP->fx_file, fixP->fx_line,
++                       _("operand out of range (%ld not between %ld and %ld)"),
++                       value, fixP->tc_fix_data.min, fixP->tc_fix_data.max);
++        if (value & ((1 << fixP->tc_fix_data.align) - 1))
++          as_bad_where(fixP->fx_file, fixP->fx_line,
++                       _("misaligned operand (required alignment: %d)"),
++                       1 << fixP->tc_fix_data.align);
++        ifield->insert(ifield, buf, value >> fixP->tc_fix_data.align);
++        break;
++      case BFD_RELOC_AVR32_ALIGN:
++        /* Nothing to do */
++        fixP->fx_done = FALSE;
++        break;
++      default:
++        as_fatal("reloc type %s not handled\n",
++                 bfd_get_reloc_code_name(fixP->fx_r_type));
++      }
++    }
++}
++#endif
++
++arelent *
++tc_gen_reloc (asection *section ATTRIBUTE_UNUSED,
++            fixS *fixp)
++{
++  arelent *reloc;
++  bfd_reloc_code_real_type code;
++
++  reloc = xmalloc (sizeof (arelent));
++
++  reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
++  *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
++  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
++  reloc->addend = fixp->fx_offset;
++  code = fixp->fx_r_type;
++
++  reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
++
++  if (reloc->howto == NULL)
++    {
++      as_bad_where (fixp->fx_file, fixp->fx_line,
++                  _("cannot represent relocation %s in this object file format"),
++                  bfd_get_reloc_code_name (code));
++      return NULL;
++    }
++
++  return reloc;
++}
++
++bfd_boolean
++avr32_force_reloc(fixS *fixP)
++{
++  if (linkrelax && fixP->fx_addsy
++      && !(S_GET_SEGMENT(fixP->fx_addsy)->flags & SEC_DEBUGGING)
++      && S_GET_SEGMENT(fixP->fx_addsy) != absolute_section)
++    {
++      pr_debug(stderr, "force reloc: addsy=%p, r_type=%d, sec=%s\n",
++             fixP->fx_addsy, fixP->fx_r_type, S_GET_SEGMENT(fixP->fx_addsy)->name);
++      return 1;
++    }
++
++  return generic_force_reloc(fixP);
++}
++
++bfd_boolean
++avr32_fix_adjustable(fixS *fixP)
++{
++  switch (fixP->fx_r_type)
++    {
++      /* GOT relocations can't have addends since BFD treats all
++       references to a given symbol the same. This means that we
++       must avoid section-relative references to local symbols when
++       dealing with these kinds of relocs */
++    case BFD_RELOC_AVR32_GOT32:
++    case BFD_RELOC_AVR32_GOT16:
++    case BFD_RELOC_AVR32_GOT8:
++    case BFD_RELOC_AVR32_GOT21S:
++    case BFD_RELOC_AVR32_GOT18SW:
++    case BFD_RELOC_AVR32_GOT16S:
++    case BFD_RELOC_AVR32_LDA_GOT:
++    case BFD_RELOC_AVR32_GOTCALL:
++      pr_debug("fix not adjustable\n");
++      return 0;
++
++    default:
++      break;
++    }
++
++  return 1;
++}
++
++/* When we want the linker to be able to relax the code, we need to
++   output a reloc for every .align directive requesting an alignment
++   to a four byte boundary or larger.  If we don't do this, the linker
++   can't guarantee that the alignment is actually maintained in the
++   linker output.
++
++   TODO: Might as well insert proper NOPs while we're at it... */
++void
++avr32_handle_align(fragS *frag)
++{
++  if (linkrelax
++      && frag->fr_type == rs_align_code
++      && frag->fr_address + frag->fr_fix > 0
++      && frag->fr_offset > 0)
++    {
++      /* The alignment order (fr_offset) is stored in the addend. */
++      fix_new(frag, frag->fr_fix, 2, &abs_symbol, frag->fr_offset,
++            FALSE, BFD_RELOC_AVR32_ALIGN);
++    }
++}
++
++/* Relax_align. Advance location counter to next address that has 'alignment'
++   lowest order bits all 0s, return size of adjustment made.  */
++relax_addressT
++avr32_relax_align(segT segment ATTRIBUTE_UNUSED,
++                fragS *fragP,
++                relax_addressT address)
++{
++  relax_addressT mask;
++  relax_addressT new_address;
++  int alignment;
++
++  alignment = fragP->fr_offset;
++  mask = ~((~0) << alignment);
++  new_address = (address + mask) & (~mask);
++
++  return new_address - address;
++}
++
++/* 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 .  An error message is
++   returned, or NULL on OK. */
++
++/* Equal to MAX_PRECISION in atof-ieee.c */
++#define MAX_LITTLENUMS 6
++
++char *
++md_atof (type, litP, sizeP)
++char   type;
++char * litP;
++int *  sizeP;
++{
++  int              i;
++  int              prec;
++  LITTLENUM_TYPE   words [MAX_LITTLENUMS];
++  char *           t;
++
++  switch (type)
++  {
++    case 'f':
++    case 'F':
++    case 's':
++    case 'S':
++      prec = 2;
++      break;
++
++    case 'd':
++    case 'D':
++    case 'r':
++    case 'R':
++      prec = 4;
++      break;
++
++      /* FIXME: Some targets allow other format chars for bigger sizes here.  */
++
++    default:
++      * sizeP = 0;
++      return _("Bad call to md_atof()");
++  }
++
++  t = atof_ieee (input_line_pointer, type, words);
++  if (t)
++    input_line_pointer = t;
++  * sizeP = prec * sizeof (LITTLENUM_TYPE);
++
++  for (i = 0; i < prec; i++)
++  {
++    md_number_to_chars (litP, (valueT) words[i],
++                        sizeof (LITTLENUM_TYPE));
++    litP += sizeof (LITTLENUM_TYPE);
++  }
++
++  return 0;
++}
++
++static char *avr32_end_of_match(char *cont, char *what)
++{
++  int len = strlen (what);
++
++  if (! is_part_of_name (cont[len])
++      && strncasecmp (cont, what, len) == 0)
++    return cont + len;
++
++  return NULL;
++}
++
++int
++avr32_parse_name (char const *name, expressionS *exp, char *nextchar)
++{
++  char *next = input_line_pointer;
++  char *next_end;
++
++  pr_debug("parse_name: %s, nextchar=%c (%02x)\n", name, *nextchar, *nextchar);
++
++  if (*nextchar == '(')
++    {
++      if (strcasecmp(name, "hi") == 0)
++      {
++        *next = *nextchar;
++
++        expression(exp);
++
++        if (exp->X_op == O_constant)
++          {
++            pr_debug("  -> constant hi(0x%08lx) -> 0x%04lx\n",
++                     exp->X_add_number, exp->X_add_number >> 16);
++            exp->X_add_number = (exp->X_add_number >> 16) & 0xffff;
++          }
++        else
++          {
++            exp->X_md = exp->X_op;
++            exp->X_op = O_hi;
++          }
++
++        return 1;
++      }
++      else if (strcasecmp(name, "lo") == 0)
++      {
++        *next = *nextchar;
++
++        expression(exp);
++
++        if (exp->X_op == O_constant)
++          exp->X_add_number &= 0xffff;
++        else
++          {
++            exp->X_md = exp->X_op;
++            exp->X_op = O_lo;
++          }
++
++        return 1;
++      }
++    }
++  else if (*nextchar == '@')
++    {
++      exp->X_md = exp->X_op;
++
++      if ((next_end = avr32_end_of_match (next + 1, "got")))
++      exp->X_op = O_got;
++      else if ((next_end = avr32_end_of_match (next + 1, "tlsgd")))
++      exp->X_op = O_tlsgd;
++      /* Add more as needed */
++      else
++      {
++        char c;
++        input_line_pointer++;
++        c = get_symbol_end();
++        as_bad (_("unknown relocation override `%s'"), next + 1);
++        *input_line_pointer = c;
++        input_line_pointer = next;
++        return 0;
++      }
++
++      exp->X_op_symbol = NULL;
++      exp->X_add_symbol = symbol_find_or_make (name);
++      exp->X_add_number = 0;
++
++      *input_line_pointer = *nextchar;
++      input_line_pointer = next_end;
++      *nextchar = *input_line_pointer;
++      *input_line_pointer = '\0';
++      return 1;
++    }
++  else if (strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
++    {
++      if (!GOT_symbol)
++      GOT_symbol = symbol_find_or_make(name);
++
++      exp->X_add_symbol = GOT_symbol;
++      exp->X_op = O_symbol;
++      exp->X_add_number = 0;
++      return 1;
++    }
++
++  return 0;
++}
++
++static void
++s_rseg (int value ATTRIBUTE_UNUSED)
++{
++  /* Syntax: RSEG segment_name [:type] [NOROOT|ROOT] [(align)]
++   * Defaults:
++   *  - type: undocumented ("typically CODE or DATA")
++   *  - ROOT
++   *  - align: 1 for code, 0 for others
++   *
++   * TODO: NOROOT is ignored. If gas supports discardable segments, it should
++   * be implemented.
++   */
++  char *name, *end;
++  int length, type, attr;
++  int align = 0;
++
++  SKIP_WHITESPACE();
++
++  end = input_line_pointer;
++  while (0 == strchr ("\n\t;:( ", *end))
++    end++;
++  if (end == input_line_pointer)
++    {
++      as_warn (_("missing name"));
++      ignore_rest_of_line();
++      return;
++    }
++
++  name = xmalloc (end - input_line_pointer + 1);
++  memcpy (name, input_line_pointer, end - input_line_pointer);
++  name[end - input_line_pointer] = '\0';
++  input_line_pointer = end;
++
++  SKIP_WHITESPACE();
++
++  type = SHT_NULL;
++  attr = 0;
++
++  if (*input_line_pointer == ':')
++    {
++      /* Skip the colon */
++      ++input_line_pointer;
++      SKIP_WHITESPACE();
++
++      /* Possible options at this point:
++       *   - flag (ROOT or NOROOT)
++       *   - a segment type
++       */
++      end = input_line_pointer;
++      while (0 == strchr ("\n\t;:( ", *end))
++      end++;
++      length = end - input_line_pointer;
++      if (((length == 4) && (0 == strncasecmp( input_line_pointer, "ROOT", 4))) ||
++        ((length == 6) && (0 == strncasecmp( input_line_pointer, "NOROOT", 6))))
++      {
++        /* Ignore ROOT/NOROOT */
++        input_line_pointer = end;
++      }
++      else
++      {
++        /* Must be a segment type */
++        switch (*input_line_pointer)
++          {
++          case 'C':
++          case 'c':
++            if ((length == 4) &&
++                (0 == strncasecmp (input_line_pointer, "CODE", 4)))
++              {
++                attr |= SHF_ALLOC | SHF_EXECINSTR;
++                type = SHT_PROGBITS;
++                align = 1;
++                break;
++              }
++            if ((length == 5) &&
++                (0 == strncasecmp (input_line_pointer, "CONST", 5)))
++              {
++                attr |= SHF_ALLOC;
++                type = SHT_PROGBITS;
++                break;
++              }
++            goto de_fault;
++
++          case 'D':
++          case 'd':
++            if ((length == 4) &&
++                (0 == strncasecmp (input_line_pointer, "DATA", 4)))
++              {
++                attr |= SHF_ALLOC | SHF_WRITE;
++                type = SHT_PROGBITS;
++                break;
++              }
++            goto de_fault;
++
++            /* TODO: Add FAR*, HUGE*, IDATA and NEAR* if necessary */
++
++          case 'U':
++          case 'u':
++            if ((length == 7) &&
++                (0 == strncasecmp (input_line_pointer, "UNTYPED", 7)))
++              break;
++            goto de_fault;
++
++            /* TODO: Add XDATA and ZPAGE if necessary */
++
++          de_fault:
++          default:
++            as_warn (_("unrecognized segment type"));
++          }
++
++        input_line_pointer = end;
++        SKIP_WHITESPACE();
++
++        if (*input_line_pointer == ':')
++          {
++            /*  ROOT/NOROOT */
++            ++input_line_pointer;
++            SKIP_WHITESPACE();
++
++            end = input_line_pointer;
++            while (0 == strchr ("\n\t;:( ", *end))
++              end++;
++            length = end - input_line_pointer;
++            if (! ((length == 4) &&
++                   (0 == strncasecmp( input_line_pointer, "ROOT", 4))) &&
++                ! ((length == 6) &&
++                   (0 == strncasecmp( input_line_pointer, "NOROOT", 6))))
++              {
++                as_warn (_("unrecognized segment flag"));
++              }
++
++            input_line_pointer = end;
++            SKIP_WHITESPACE();
++          }
++      }
++    }
++
++  if (*input_line_pointer == '(')
++    {
++      align = get_absolute_expression ();
++    }
++
++  demand_empty_rest_of_line();
++
++  obj_elf_change_section (name, type, attr, 0, NULL, 0, 0);
++#ifdef AVR32_DEBUG
++  fprintf( stderr, "RSEG: Changed section to %s, type: 0x%x, attr: 0x%x\n",
++      name, type, attr );
++  fprintf( stderr, "RSEG: Aligning to 2**%d\n", align );
++#endif
++
++  if (align > 15)
++    {
++      align = 15;
++      as_warn (_("alignment too large: %u assumed"), align);
++    }
++
++  /* Hope not, that is */
++  assert (now_seg != absolute_section);
++
++  /* Only make a frag if we HAVE to... */
++  if (align != 0 && !need_pass_2)
++    {
++      if (subseg_text_p (now_seg))
++      frag_align_code (align, 0);
++      else
++      frag_align (align, 0, 0);
++    }
++
++  record_alignment (now_seg, align - OCTETS_PER_BYTE_POWER);
++}
++
++/* vim: syntax=c sw=2
++ */
+diff -Nrup binutils-2.17/gas/config/tc-avr32.h binutils-2.17-atmel/gas/config/tc-avr32.h
+--- binutils-2.17/gas/config/tc-avr32.h        1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/config/tc-avr32.h  2007-02-12 15:37:09.000000000 +0100
+@@ -0,0 +1,313 @@
++/* Assembler definitions for AVR32.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   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.  */
++
++#if 0
++#define DEBUG
++#define DEBUG1
++#define DEBUG2
++#define DEBUG3
++#define DEBUG4
++#define DEBUG5
++#endif
++
++/* Are we trying to be compatible with the IAR assembler? (--iar) */
++extern int avr32_iarcompat;
++
++/* By convention, you should define this macro in the `.h' file.  For
++   example, `tc-m68k.h' defines `TC_M68K'.  You might have to use this
++   if it is necessary to add CPU specific code to the object format
++   file.  */
++#define TC_AVR32
++
++/* This macro is the BFD target name to use when creating the output
++   file.  This will normally depend upon the `OBJ_FMT' macro.  */
++#define TARGET_FORMAT "elf32-avr32"
++
++/* This macro is the BFD architecture to pass to `bfd_set_arch_mach'.  */
++#define TARGET_ARCH bfd_arch_avr32
++
++/* This macro is the BFD machine number to pass to
++   `bfd_set_arch_mach'.  If it is not defined, GAS will use 0.  */
++#define TARGET_MACH 0
++
++/* UNDOCUMENTED: Allow //-style comments */
++#define DOUBLESLASH_LINE_COMMENTS
++
++/* You should define this macro to be non-zero if the target is big
++   endian, and zero if the target is little endian.  */
++#define TARGET_BYTES_BIG_ENDIAN 1
++
++/* FIXME: It seems that GAS only expects a one-byte opcode...
++   #define NOP_OPCODE 0xd703 */
++
++/* If you define this macro, GAS will warn about the use of
++   nonstandard escape sequences in a string.  */
++#undef ONLY_STANDARD_ESCAPES
++
++#define DWARF2_FORMAT() dwarf2_format_32bit
++
++/* Instructions are either 2 or 4 bytes long */
++/* #define DWARF2_LINE_MIN_INSN_LENGTH 2 */
++
++/* GAS will call this function for any expression that can not be
++   recognized.  When the function is called, `input_line_pointer'
++   will point to the start of the expression.  */
++#define md_operand(x)
++
++#define md_parse_name(name, expr, mode, c) avr32_parse_name(name, expr, c)
++extern int avr32_parse_name(const char *, struct expressionS *, char *);
++
++/* You may define this macro to generate a fixup for a data
++   allocation pseudo-op.  */
++#define TC_CONS_FIX_NEW(FRAG, OFF, LEN, EXP)  \
++  avr32_cons_fix_new(FRAG, OFF, LEN, EXP)
++void avr32_cons_fix_new (fragS *, int, int, expressionS *);
++
++/* `extsym - .' expressions can be emitted using PC-relative relocs */
++#define DIFF_EXPR_OK
++
++/* This is used to construct expressions out of @gotoff, etc. The
++   relocation type is stored in X_md */
++#define O_got         O_md1
++#define O_hi          O_md2
++#define O_lo          O_md3
++#define O_tlsgd               O_md4
++
++/* You may define this macro to parse an expression used in a data
++   allocation pseudo-op such as `.word'.  You can use this to
++   recognize relocation directives that may appear in such directives.  */
++/* #define TC_PARSE_CONS_EXPRESSION(EXPR,N) avr_parse_cons_expression (EXPR,N)
++   void avr_parse_cons_expression (expressionS *exp, int nbytes); */
++
++/* This should just call either `number_to_chars_bigendian' or
++   `number_to_chars_littleendian', whichever is appropriate.  On
++   targets like the MIPS which support options to change the
++   endianness, which function to call is a runtime decision.  On
++   other targets, `md_number_to_chars' can be a simple macro.  */
++#define md_number_to_chars number_to_chars_bigendian
++
++/* `md_short_jump_size'
++   `md_long_jump_size'
++   `md_create_short_jump'
++   `md_create_long_jump'
++   If `WORKING_DOT_WORD' is defined, GAS will not do broken word
++   processing (*note Broken words::.).  Otherwise, you should set
++   `md_short_jump_size' to the size of a short jump (a jump that is
++   just long enough to jump around a long jmp) and
++   `md_long_jump_size' to the size of a long jump (a jump that can go
++   anywhere in the function), You should define
++   `md_create_short_jump' to create a short jump around a long jump,
++   and define `md_create_long_jump' to create a long jump.  */
++#define WORKING_DOT_WORD
++
++/* If you define this macro, it means that `tc_gen_reloc' may return
++   multiple relocation entries for a single fixup.  In this case, the
++   return value of `tc_gen_reloc' is a pointer to a null terminated
++   array.  */
++#undef RELOC_EXPANSION_POSSIBLE
++
++/* If you define this macro, GAS will not require pseudo-ops to start with a .
++   character. */
++#define NO_PSEUDO_DOT (avr32_iarcompat)
++
++/* The IAR assembler uses $ as the location counter. Unfortunately, we
++   can't make this dependent on avr32_iarcompat... */
++#define DOLLAR_DOT
++
++/* Values passed to md_apply_fix3 don't include the symbol value.  */
++#define MD_APPLY_SYM_VALUE(FIX) 0
++
++/* The number of bytes to put into a word in a listing.  This affects
++   the way the bytes are clumped together in the listing.  For
++   example, a value of 2 might print `1234 5678' where a value of 1
++   would print `12 34 56 78'.  The default value is 4.  */
++#define LISTING_WORD_SIZE 4
++
++/* extern const struct relax_type md_relax_table[];
++#define TC_GENERIC_RELAX_TABLE md_relax_table */
++
++/*
++  An `.lcomm' directive with no explicit alignment parameter will use
++  this macro to set P2VAR to the alignment that a request for SIZE
++  bytes will have.  The alignment is expressed as a power of two.  If
++  no alignment should take place, the macro definition should do
++  nothing.  Some targets define a `.bss' directive that is also
++  affected by this macro.  The default definition will set P2VAR to
++  the truncated power of two of sizes up to eight bytes.
++
++  We want doublewords to be word-aligned, so we're going to modify the
++  default definition a tiny bit.
++*/
++#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)      \
++  do                                                  \
++    {                                                 \
++      if ((SIZE) >= 4)                                        \
++      (P2VAR) = 2;                                    \
++      else if ((SIZE) >= 2)                           \
++      (P2VAR) = 1;                                    \
++      else                                            \
++      (P2VAR) = 0;                                    \
++    }                                                 \
++  while (0)
++
++/* When relaxing, we need to generate relocations for alignment
++   directives.  */
++#define HANDLE_ALIGN(frag) avr32_handle_align(frag)
++extern void avr32_handle_align(fragS *);
++
++/* See internals doc for explanation. Oh wait...
++   Now, can you guess where "alignment" comes from? ;-) */
++#define MAX_MEM_FOR_RS_ALIGN_CODE ((1 << alignment) - 1)
++
++/* We need to stop gas from reducing certain expressions (e.g. GOT
++   references) */
++#define tc_fix_adjustable(fix) avr32_fix_adjustable(fix)
++extern bfd_boolean avr32_fix_adjustable(struct fix *);
++
++/* The linker needs to be passed a little more information when relaxing. */
++#define TC_FORCE_RELOCATION(fix) avr32_force_reloc(fix)
++extern bfd_boolean avr32_force_reloc(struct fix *);
++
++/* I'm tired of working around all the madness in fixup_segment().
++   This hook will do basically the same things as the generic code,
++   and then it will "goto" right past it.  */
++#define TC_VALIDATE_FIX(FIX, SEG, SKIP)               \
++  do                                          \
++    {                                         \
++      avr32_process_fixup(FIX, SEG);          \
++      if (!(FIX)->fx_done)                    \
++      ++seg_reloc_count;                      \
++      goto SKIP;                              \
++    }                                         \
++  while (0)
++extern void avr32_process_fixup(struct fix *fixP, segT this_segment);
++
++/* We don't want the gas core to make any assumptions about our way of
++   doing linkrelaxing.  */
++#define TC_LINKRELAX_FIXUP(SEG)                       0
++
++/* ... but we do want it to insert lots of padding. */
++#define LINKER_RELAXING_SHRINKS_ONLY
++
++/* Better do it ourselves, really... */
++#define TC_RELAX_ALIGN(SEG, FRAG, ADDR)       avr32_relax_align(SEG, FRAG, ADDR)
++extern relax_addressT
++avr32_relax_align(segT segment, fragS *fragP, relax_addressT address);
++
++/* This is called by write_object_file() just before symbols are
++   attempted converted into section symbols.  */
++#define tc_frob_file_before_adjust()  avr32_frob_file()
++extern void avr32_frob_file(void);
++
++/* If you define this macro, GAS will call it at the end of each input
++   file.  */
++#define md_cleanup() avr32_cleanup()
++extern void avr32_cleanup(void);
++
++/* There's an AVR32-specific hack in operand() which creates O_md
++   expressions when encountering HWRD or LWRD. We need to generate
++   proper relocs for them */
++/* #define md_cgen_record_fixup_exp avr32_cgen_record_fixup_exp */
++
++/* I needed to add an extra hook in gas_cgen_finish_insn() for
++   conversion of O_md* operands because md_cgen_record_fixup_exp()
++   isn't called for relaxable insns */
++/* #define md_cgen_convert_expr(exp, opinfo) avr32_cgen_convert_expr(exp, opinfo)
++   int avr32_cgen_convert_expr(expressionS *, int); */
++
++/* #define tc_gen_reloc gas_cgen_tc_gen_reloc */
++
++/* If you define this macro, it should return the position from which
++   the PC relative adjustment for a PC relative fixup should be
++   made. On many processors, the base of a PC relative instruction is
++   the next instruction, so this macro would return the length of an
++   instruction, plus the address of the PC relative fixup. The latter
++   can be calculated as fixp->fx_where + fixp->fx_frag->fr_address. */
++extern long md_pcrel_from_section (struct fix *, segT);
++#define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from_section (FIX, SEC)
++
++#define LOCAL_LABEL(name) (name[0] == '.' && (name[1] == 'L'))
++#define LOCAL_LABELS_FB               1
++
++struct avr32_relaxer
++{
++  int (*estimate_size)(fragS *, segT);
++  long (*relax_frag)(segT, fragS *, long);
++  void (*convert_frag)(bfd *, segT, fragS *);
++};
++
++/* AVR32 has quite complex instruction coding, which means we need
++ * lots of information in order to do the right thing during relaxing
++ * (basically, we need to be able to reconstruct a whole new opcode if
++ * necessary) */
++#define TC_FRAG_TYPE struct avr32_frag_data
++
++struct cpool;
++
++struct avr32_frag_data
++{
++  /* TODO: Maybe add an expression object here so that we can use
++     fix_new_exp() in md_convert_frag?  We may have to decide
++     pcrel-ness in md_estimate_size_before_relax() as well...or we
++     might do it when parsing.  Doing it while parsing may fail
++     because the sub_symbol is undefined then... */
++  int pcrel;
++  int force_extended;
++  int reloc_info;
++  struct avr32_relaxer *relaxer;
++  expressionS exp;
++
++  /* Points to associated constant pool, for use by LDA and CALL in
++     non-pic mode, and when relaxing the .cpool directive */
++  struct cpool *pool;
++  unsigned int pool_entry;
++};
++
++/* We will have to initialize the fields explicitly when needed */
++#define TC_FRAG_INIT(fragP)
++
++#define md_estimate_size_before_relax(fragP, segT)                    \
++  ((fragP)->tc_frag_data.relaxer->estimate_size(fragP, segT))
++#define md_relax_frag(segment, fragP, stretch)                                \
++  ((fragP)->tc_frag_data.relaxer->relax_frag(segment, fragP, stretch))
++#define md_convert_frag(abfd, segment, fragP)                         \
++  ((fragP)->tc_frag_data.relaxer->convert_frag(abfd, segment, fragP))
++
++#define TC_FIX_TYPE struct avr32_fix_data
++
++struct avr32_fix_data
++{
++  const struct avr32_ifield *ifield;
++  unsigned int align;
++  long min;
++  long max;
++};
++
++#define TC_INIT_FIX_DATA(fixP)                        \
++  do                                          \
++    {                                         \
++      (fixP)->tc_fix_data.ifield = NULL;      \
++      (fixP)->tc_fix_data.align = 0;          \
++      (fixP)->tc_fix_data.min = 0;            \
++      (fixP)->tc_fix_data.max = 0;            \
++    }                                         \
++  while (0)
+diff -Nrup binutils-2.17/gas/config.in binutils-2.17-atmel/gas/config.in
+--- binutils-2.17/gas/config.in        2006-02-14 09:59:09.000000000 +0100
++++ binutils-2.17-atmel/gas/config.in  2007-02-20 16:07:31.000000000 +0100
+@@ -246,7 +246,7 @@
+ /* If using the C implementation of alloca, define if you know the
+    direction of stack growth for your system; otherwise it will be
+-   automatically deduced at run-time.
++   automatically deduced at runtime.
+       STACK_DIRECTION > 0 => grows toward higher addresses
+       STACK_DIRECTION < 0 => grows toward lower addresses
+       STACK_DIRECTION = 0 => direction of growth unknown */
+@@ -311,8 +311,8 @@
+ #undef inline
+ #endif
+-/* Define to `long' if <sys/types.h> does not define. */
++/* Define to `long int' if <sys/types.h> does not define. */
+ #undef off_t
+-/* Define to `unsigned' if <sys/types.h> does not define. */
++/* Define to `unsigned int' if <sys/types.h> does not define. */
+ #undef size_t
+diff -Nrup binutils-2.17/gas/configure binutils-2.17-atmel/gas/configure
+--- binutils-2.17/gas/configure        2006-04-06 23:49:31.000000000 +0200
++++ binutils-2.17-atmel/gas/configure  2007-02-20 16:07:29.000000000 +0100
+@@ -1,25 +1,54 @@
+ #! /bin/sh
+ # Guess values for system-dependent variables and create Makefiles.
+-# Generated by GNU Autoconf 2.59.
++# Generated by GNU Autoconf 2.61.
+ #
+-# Copyright (C) 2003 Free Software Foundation, Inc.
++# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ # This configure script is free software; the Free Software Foundation
+ # gives unlimited permission to copy, distribute and modify it.
+ ## --------------------- ##
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -29,8 +58,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -44,18 +108,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -63,157 +128,388 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++# CDPATH.
++$as_unset CDPATH
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
++if test "x$CONFIG_SHELL" = x; then
++  if (eval ":") 2>/dev/null; then
++  as_have_required=yes
++else
++  as_have_required=no
+ fi
++  if test $as_have_required = yes &&   (eval ":
++(as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0) || { (exit 1); exit 1; }
++
++(
++  as_lineno_1=\$LINENO
++  as_lineno_2=\$LINENO
++  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
++  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
++") 2> /dev/null; then
++  :
++else
++  as_candidate_shells=
+     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
++  case $as_dir in
+        /*)
+-         if ("$as_dir/$as_base" -c '
++         for as_base in sh bash ksh sh5; do
++           as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
++         done;;
++       esac
++done
++IFS=$as_save_IFS
++
++
++      for as_shell in $as_candidate_shells $SHELL; do
++       # Try only shells that exist, to save several forks.
++       if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
++              { ("$as_shell") 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++_ASEOF
++}; then
++  CONFIG_SHELL=$as_shell
++             as_have_required=yes
++             if { "$as_shell" 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++(as_func_return () {
++  (exit $1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = "$1" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test $exitcode = 0) || { (exit 1); exit 1; }
++
++(
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
++
++_ASEOF
++}; then
++  break
++fi
++
++fi
++
++      done
++
++      if test "x$CONFIG_SHELL" != x; then
++  for as_var in BASH_ENV ENV
++        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++        done
++        export CONFIG_SHELL
++        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
++fi
++
++
++    if test $as_have_required = no; then
++  echo This script requires a shell more modern than all the
++      echo shells that I found on your system.  Please install a
++      echo modern shell, or manually run the script under such a
++      echo shell if you do have one.
++      { (exit 1); exit 1; }
++fi
++
++
++fi
++
++fi
++
++
++
++(eval "as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0") || {
++  echo No shell found that supports shell functions.
++  echo Please tell autoconf@gnu.org about your system,
++  echo including any error possibly output before this
++  echo message
++}
++
++
++
++  as_lineno_1=$LINENO
++  as_lineno_2=$LINENO
++  test "x$as_lineno_1" != "x$as_lineno_2" &&
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
++  chmod +x "$as_me.lineno" ||
+     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -222,7 +518,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -231,39 +548,27 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
++exec 7<&0 </dev/null 6>&1
+ # Name of the host.
+ # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+ # so uname gets run too.
+ ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+-exec 6>&1
+-
+ #
+ # Initializations.
+ #
+ ac_default_prefix=/usr/local
++ac_clean_files=
+ ac_config_libobj_dir=.
++LIBOBJS=
+ cross_compiling=no
+ subdirs=
+ MFLAGS=
+ MAKEFLAGS=
+ SHELL=${CONFIG_SHELL-/bin/sh}
+-# Maximum number of lines to put in a shell here document.
+-# This variable seems obsolete.  It should probably be removed, and
+-# only ac_max_sed_lines should be used.
+-: ${ac_max_here_lines=38}
+-
+ # Identity of this package.
+ PACKAGE_NAME=
+ PACKAGE_TARNAME=
+@@ -275,42 +580,190 @@ ac_unique_file="as.h"
+ # Factoring default headers for most tests.
+ ac_includes_default="\
+ #include <stdio.h>
+-#if HAVE_SYS_TYPES_H
++#ifdef HAVE_SYS_TYPES_H
+ # include <sys/types.h>
+ #endif
+-#if HAVE_SYS_STAT_H
++#ifdef HAVE_SYS_STAT_H
+ # include <sys/stat.h>
+ #endif
+-#if STDC_HEADERS
++#ifdef STDC_HEADERS
+ # include <stdlib.h>
+ # include <stddef.h>
+ #else
+-# if HAVE_STDLIB_H
++# ifdef HAVE_STDLIB_H
+ #  include <stdlib.h>
+ # endif
+ #endif
+-#if HAVE_STRING_H
+-# if !STDC_HEADERS && HAVE_MEMORY_H
++#ifdef HAVE_STRING_H
++# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+ #  include <memory.h>
+ # endif
+ # include <string.h>
+ #endif
+-#if HAVE_STRINGS_H
++#ifdef HAVE_STRINGS_H
+ # include <strings.h>
+ #endif
+-#if HAVE_INTTYPES_H
++#ifdef HAVE_INTTYPES_H
+ # include <inttypes.h>
+-#else
+-# if HAVE_STDINT_H
+-#  include <stdint.h>
+-# endif
+ #endif
+-#if HAVE_UNISTD_H
++#ifdef HAVE_STDINT_H
++# include <stdint.h>
++#endif
++#ifdef HAVE_UNISTD_H
+ # include <unistd.h>
+ #endif"
+-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE LN_S RANLIB ac_ct_RANLIB LIBTOOL WARN_CFLAGS NO_WERROR GDBINIT cgen_cpu_prefix extra_objects target_cpu_type obj_format te_file install_tooldir atof BFDLIB OPCODES_LIB BFDVER_H ALL_OBJ_DEPS YACC LEX LEXLIB LEX_OUTPUT_ROOT CPP EGREP ALLOCA USE_NLS MSGFMT GMSGFMT XGETTEXT USE_INCLUDED_LIBINTL CATALOGS CATOBJEXT DATADIRNAME GMOFILES INSTOBJEXT INTLDEPS INTLLIBS INTLOBJS POFILES POSUB INCLUDE_LOCALE_H GT_NO GT_YES MKINSTALLDIRS l MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT LIBM datarootdir docdir htmldir LIBOBJS LTLIBOBJS'
++ac_subst_vars='SHELL
++PATH_SEPARATOR
++PACKAGE_NAME
++PACKAGE_TARNAME
++PACKAGE_VERSION
++PACKAGE_STRING
++PACKAGE_BUGREPORT
++exec_prefix
++prefix
++program_transform_name
++bindir
++sbindir
++libexecdir
++datarootdir
++datadir
++sysconfdir
++sharedstatedir
++localstatedir
++includedir
++oldincludedir
++docdir
++infodir
++htmldir
++dvidir
++pdfdir
++psdir
++libdir
++localedir
++mandir
++DEFS
++ECHO_C
++ECHO_N
++ECHO_T
++LIBS
++build_alias
++host_alias
++target_alias
++build
++build_cpu
++build_vendor
++build_os
++host
++host_cpu
++host_vendor
++host_os
++target
++target_cpu
++target_vendor
++target_os
++CC
++CFLAGS
++LDFLAGS
++CPPFLAGS
++ac_ct_CC
++EXEEXT
++OBJEXT
++INSTALL_PROGRAM
++INSTALL_SCRIPT
++INSTALL_DATA
++CYGPATH_W
++PACKAGE
++VERSION
++ACLOCAL
++AUTOCONF
++AUTOMAKE
++AUTOHEADER
++MAKEINFO
++install_sh
++STRIP
++INSTALL_STRIP_PROGRAM
++mkdir_p
++AWK
++SET_MAKE
++am__leading_dot
++AMTAR
++am__tar
++am__untar
++DEPDIR
++am__include
++am__quote
++AMDEP_TRUE
++AMDEP_FALSE
++AMDEPBACKSLASH
++CCDEPMODE
++am__fastdepCC_TRUE
++am__fastdepCC_FALSE
++LN_S
++RANLIB
++LIBTOOL
++WARN_CFLAGS
++NO_WERROR
++GDBINIT
++CPP
++GREP
++EGREP
++cgen_cpu_prefix
++extra_objects
++target_cpu_type
++obj_format
++te_file
++install_tooldir
++atof
++BFDLIB
++OPCODES_LIB
++BFDVER_H
++ALL_OBJ_DEPS
++YACC
++YFLAGS
++LEX
++LEX_OUTPUT_ROOT
++LEXLIB
++ALLOCA
++USE_NLS
++MSGFMT
++GMSGFMT
++XGETTEXT
++USE_INCLUDED_LIBINTL
++CATALOGS
++CATOBJEXT
++DATADIRNAME
++GMOFILES
++INSTOBJEXT
++INTLDEPS
++INTLLIBS
++INTLOBJS
++POFILES
++POSUB
++INCLUDE_LOCALE_H
++GT_NO
++GT_YES
++MKINSTALLDIRS
++l
++MAINTAINER_MODE_TRUE
++MAINTAINER_MODE_FALSE
++MAINT
++LIBM
++LIBOBJS
++LTLIBOBJS'
+ ac_subst_files=''
++      ac_precious_vars='build_alias
++host_alias
++target_alias
++CC
++CFLAGS
++LDFLAGS
++LIBS
++CPPFLAGS
++CPP
++YACC
++YFLAGS'
++
+ # Initialize some variables set by options.
+ ac_init_help=
+@@ -337,34 +790,48 @@ x_libraries=NONE
+ # and all the variables that are supposed to be based on exec_prefix
+ # by default will actually change.
+ # Use braces instead of parens because sh, perl, etc. also accept them.
++# (The list follows the same order as the GNU Coding Standards.)
+ bindir='${exec_prefix}/bin'
+ sbindir='${exec_prefix}/sbin'
+ libexecdir='${exec_prefix}/libexec'
+-datadir='${prefix}/share'
++datarootdir='${prefix}/share'
++datadir='${datarootdir}'
+ sysconfdir='${prefix}/etc'
+ sharedstatedir='${prefix}/com'
+ localstatedir='${prefix}/var'
+-libdir='${exec_prefix}/lib'
+ includedir='${prefix}/include'
+ oldincludedir='/usr/include'
+-infodir='${prefix}/info'
+-mandir='${prefix}/man'
++docdir='${datarootdir}/doc/${PACKAGE}'
++infodir='${datarootdir}/info'
++htmldir='${docdir}'
++dvidir='${docdir}'
++pdfdir='${docdir}'
++psdir='${docdir}'
++libdir='${exec_prefix}/lib'
++localedir='${datarootdir}/locale'
++mandir='${datarootdir}/man'
+ ac_prev=
++ac_dashdash=
+ for ac_option
+ do
+   # If the previous option needs an argument, assign it.
+   if test -n "$ac_prev"; then
+-    eval "$ac_prev=\$ac_option"
++    eval $ac_prev=\$ac_option
+     ac_prev=
+     continue
+   fi
+-  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
++  case $ac_option in
++  *=*)        ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
++  *)  ac_optarg=yes ;;
++  esac
+   # Accept the important Cygnus configure options, so we can diagnose typos.
+-  case $ac_option in
++  case $ac_dashdash$ac_option in
++  --)
++    ac_dashdash=yes ;;
+   -bindir | --bindir | --bindi | --bind | --bin | --bi)
+     ac_prev=bindir ;;
+@@ -386,33 +853,45 @@ do
+   --config-cache | -C)
+     cache_file=config.cache ;;
+-  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
++  -datadir | --datadir | --datadi | --datad)
+     ac_prev=datadir ;;
+-  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+-  | --da=*)
++  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+     datadir=$ac_optarg ;;
++  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
++  | --dataroo | --dataro | --datar)
++    ac_prev=datarootdir ;;
++  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
++  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
++    datarootdir=$ac_optarg ;;
++
+   -disable-* | --disable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    eval "enable_$ac_feature=no" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=no ;;
++
++  -docdir | --docdir | --docdi | --doc | --do)
++    ac_prev=docdir ;;
++  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
++    docdir=$ac_optarg ;;
++
++  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
++    ac_prev=dvidir ;;
++  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
++    dvidir=$ac_optarg ;;
+   -enable-* | --enable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "enable_$ac_feature='$ac_optarg'" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=\$ac_optarg ;;
+   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+@@ -439,6 +918,12 @@ do
+   -host=* | --host=* | --hos=* | --ho=*)
+     host_alias=$ac_optarg ;;
++  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
++    ac_prev=htmldir ;;
++  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
++  | --ht=*)
++    htmldir=$ac_optarg ;;
++
+   -includedir | --includedir | --includedi | --included | --include \
+   | --includ | --inclu | --incl | --inc)
+     ac_prev=includedir ;;
+@@ -463,13 +948,16 @@ do
+   | --libexe=* | --libex=* | --libe=*)
+     libexecdir=$ac_optarg ;;
++  -localedir | --localedir | --localedi | --localed | --locale)
++    ac_prev=localedir ;;
++  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
++    localedir=$ac_optarg ;;
++
+   -localstatedir | --localstatedir | --localstatedi | --localstated \
+-  | --localstate | --localstat | --localsta | --localst \
+-  | --locals | --local | --loca | --loc | --lo)
++  | --localstate | --localstat | --localsta | --localst | --locals)
+     ac_prev=localstatedir ;;
+   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+-  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+-  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
++  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+     localstatedir=$ac_optarg ;;
+   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+@@ -534,6 +1022,16 @@ do
+   | --progr-tra=* | --program-tr=* | --program-t=*)
+     program_transform_name=$ac_optarg ;;
++  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
++    ac_prev=pdfdir ;;
++  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
++    pdfdir=$ac_optarg ;;
++
++  -psdir | --psdir | --psdi | --psd | --ps)
++    ac_prev=psdir ;;
++  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
++    psdir=$ac_optarg ;;
++
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil)
+     silent=yes ;;
+@@ -586,24 +1084,20 @@ do
+   -with-* | --with-*)
+     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package| sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "with_$ac_package='$ac_optarg'" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=\$ac_optarg ;;
+   -without-* | --without-*)
+     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package | sed 's/-/_/g'`
+-    eval "with_$ac_package=no" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=no ;;
+   --x)
+     # Obsolete; use --with-x.
+@@ -634,8 +1128,7 @@ Try \`$0 --help' for more information." 
+     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
+    { (exit 1); exit 1; }; }
+-    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
+-    eval "$ac_envvar='$ac_optarg'"
++    eval $ac_envvar=\$ac_optarg
+     export $ac_envvar ;;
+   *)
+@@ -655,27 +1148,19 @@ if test -n "$ac_prev"; then
+    { (exit 1); exit 1; }; }
+ fi
+-# Be sure to have absolute paths.
+-for ac_var in exec_prefix prefix
+-do
+-  eval ac_val=$`echo $ac_var`
+-  case $ac_val in
+-    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
+-  esac
+-done
+-
+-# Be sure to have absolute paths.
+-for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
+-            localstatedir libdir includedir oldincludedir infodir mandir
++# Be sure to have absolute directory names.
++for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
++              datadir sysconfdir sharedstatedir localstatedir includedir \
++              oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
++              libdir localedir mandir
+ do
+-  eval ac_val=$`echo $ac_var`
++  eval ac_val=\$$ac_var
+   case $ac_val in
+-    [\\/$]* | ?:[\\/]* ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
++    [\\/$]* | ?:[\\/]* )  continue;;
++    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+   esac
++  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
++   { (exit 1); exit 1; }; }
+ done
+ # There might be people who depend on the old broken behavior: `$host'
+@@ -702,74 +1187,76 @@ test -n "$host_alias" && ac_tool_prefix=
+ test "$silent" = yes && exec 6>/dev/null
++ac_pwd=`pwd` && test -n "$ac_pwd" &&
++ac_ls_di=`ls -di .` &&
++ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
++  { echo "$as_me: error: Working directory cannot be determined" >&2
++   { (exit 1); exit 1; }; }
++test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
++  { echo "$as_me: error: pwd does not report name of working directory" >&2
++   { (exit 1); exit 1; }; }
++
++
+ # Find the source files, if location was not specified.
+ if test -z "$srcdir"; then
+   ac_srcdir_defaulted=yes
+-  # Try the directory containing this script, then its parent.
+-  ac_confdir=`(dirname "$0") 2>/dev/null ||
++  # Try the directory containing this script, then the parent directory.
++  ac_confdir=`$as_dirname -- "$0" ||
+ $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$0" : 'X\(//\)[^/]' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$0" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   srcdir=$ac_confdir
+-  if test ! -r $srcdir/$ac_unique_file; then
++  if test ! -r "$srcdir/$ac_unique_file"; then
+     srcdir=..
+   fi
+ else
+   ac_srcdir_defaulted=no
+ fi
+-if test ! -r $srcdir/$ac_unique_file; then
+-  if test "$ac_srcdir_defaulted" = yes; then
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
+-   { (exit 1); exit 1; }; }
+-  else
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-fi
+-(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
+-  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
+-   { (exit 1); exit 1; }; }
+-srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
+-ac_env_build_alias_set=${build_alias+set}
+-ac_env_build_alias_value=$build_alias
+-ac_cv_env_build_alias_set=${build_alias+set}
+-ac_cv_env_build_alias_value=$build_alias
+-ac_env_host_alias_set=${host_alias+set}
+-ac_env_host_alias_value=$host_alias
+-ac_cv_env_host_alias_set=${host_alias+set}
+-ac_cv_env_host_alias_value=$host_alias
+-ac_env_target_alias_set=${target_alias+set}
+-ac_env_target_alias_value=$target_alias
+-ac_cv_env_target_alias_set=${target_alias+set}
+-ac_cv_env_target_alias_value=$target_alias
+-ac_env_CC_set=${CC+set}
+-ac_env_CC_value=$CC
+-ac_cv_env_CC_set=${CC+set}
+-ac_cv_env_CC_value=$CC
+-ac_env_CFLAGS_set=${CFLAGS+set}
+-ac_env_CFLAGS_value=$CFLAGS
+-ac_cv_env_CFLAGS_set=${CFLAGS+set}
+-ac_cv_env_CFLAGS_value=$CFLAGS
+-ac_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_env_LDFLAGS_value=$LDFLAGS
+-ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_cv_env_LDFLAGS_value=$LDFLAGS
+-ac_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_env_CPPFLAGS_value=$CPPFLAGS
+-ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_cv_env_CPPFLAGS_value=$CPPFLAGS
+-ac_env_CPP_set=${CPP+set}
+-ac_env_CPP_value=$CPP
+-ac_cv_env_CPP_set=${CPP+set}
+-ac_cv_env_CPP_value=$CPP
++if test ! -r "$srcdir/$ac_unique_file"; then
++  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
++  { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
++   { (exit 1); exit 1; }; }
++fi
++ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
++ac_abs_confdir=`(
++      cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2
++   { (exit 1); exit 1; }; }
++      pwd)`
++# When building in place, set srcdir=.
++if test "$ac_abs_confdir" = "$ac_pwd"; then
++  srcdir=.
++fi
++# Remove unnecessary trailing slashes from srcdir.
++# Double slashes in file names in object file debugging info
++# mess up M-x gdb in Emacs.
++case $srcdir in
++*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
++esac
++for ac_var in $ac_precious_vars; do
++  eval ac_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_env_${ac_var}_value=\$${ac_var}
++  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_cv_env_${ac_var}_value=\$${ac_var}
++done
+ #
+ # Report the --help message.
+@@ -798,9 +1285,6 @@ Configuration:
+   -n, --no-create         do not create output files
+       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+-_ACEOF
+-
+-  cat <<_ACEOF
+ Installation directories:
+   --prefix=PREFIX         install architecture-independent files in PREFIX
+                         [$ac_default_prefix]
+@@ -818,15 +1302,22 @@ Fine tuning of the installation director
+   --bindir=DIR           user executables [EPREFIX/bin]
+   --sbindir=DIR          system admin executables [EPREFIX/sbin]
+   --libexecdir=DIR       program executables [EPREFIX/libexec]
+-  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
+   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
+   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
+   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
+   --libdir=DIR           object code libraries [EPREFIX/lib]
+   --includedir=DIR       C header files [PREFIX/include]
+   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
+-  --infodir=DIR          info documentation [PREFIX/info]
+-  --mandir=DIR           man documentation [PREFIX/man]
++  --datarootdir=DIR      read-only arch.-independent data root [PREFIX/share]
++  --datadir=DIR          read-only architecture-independent data [DATAROOTDIR]
++  --infodir=DIR          info documentation [DATAROOTDIR/info]
++  --localedir=DIR        locale-dependent data [DATAROOTDIR/locale]
++  --mandir=DIR           man documentation [DATAROOTDIR/man]
++  --docdir=DIR           documentation root [DATAROOTDIR/doc/PACKAGE]
++  --htmldir=DIR          html documentation [DOCDIR]
++  --dvidir=DIR           dvi documentation [DOCDIR]
++  --pdfdir=DIR           pdf documentation [DOCDIR]
++  --psdir=DIR            ps documentation [DOCDIR]
+ _ACEOF
+   cat <<\_ACEOF
+@@ -876,126 +1367,100 @@ Some influential environment variables:
+   CFLAGS      C compiler flags
+   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+               nonstandard directory <lib dir>
+-  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
+-              headers in a nonstandard directory <include dir>
++  LIBS        libraries to pass to the linker, e.g. -l<library>
++  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
++              you have headers in a nonstandard directory <include dir>
+   CPP         C preprocessor
++  YACC        The `Yet Another C Compiler' implementation to use. Defaults to
++              the first program found out of: `bison -y', `byacc', `yacc'.
++  YFLAGS      The list of arguments that will be passed by default to $YACC.
++              This script will default YFLAGS to the empty string to avoid a
++              default value of `-d' given by some make applications.
+ Use these variables to override the choices made by `configure' or to help
+ it to find libraries and programs with nonstandard names/locations.
+ _ACEOF
++ac_status=$?
+ fi
+ if test "$ac_init_help" = "recursive"; then
+   # If there are subdirs, report their specific --help.
+-  ac_popdir=`pwd`
+   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+-    test -d $ac_dir || continue
++    test -d "$ac_dir" || continue
+     ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
+-
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
+-
+-    cd $ac_dir
+-    # Check for guested configure; otherwise get Cygnus style configure.
+-    if test -f $ac_srcdir/configure.gnu; then
+-      echo
+-      $SHELL $ac_srcdir/configure.gnu  --help=recursive
+-    elif test -f $ac_srcdir/configure; then
+-      echo
+-      $SHELL $ac_srcdir/configure  --help=recursive
+-    elif test -f $ac_srcdir/configure.ac ||
+-         test -f $ac_srcdir/configure.in; then
+-      echo
+-      $ac_configure --help
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
++
++    cd "$ac_dir" || { ac_status=$?; continue; }
++    # Check for guested configure.
++    if test -f "$ac_srcdir/configure.gnu"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
++    elif test -f "$ac_srcdir/configure"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure" --help=recursive
+     else
+       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+-    fi
+-    cd $ac_popdir
++    fi || ac_status=$?
++    cd "$ac_pwd" || { ac_status=$?; break; }
+   done
+ fi
+-test -n "$ac_init_help" && exit 0
++test -n "$ac_init_help" && exit $ac_status
+ if $ac_init_version; then
+   cat <<\_ACEOF
++configure
++generated by GNU Autoconf 2.61
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ This configure script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it.
+ _ACEOF
+-  exit 0
++  exit
+ fi
+-exec 5>config.log
+-cat >&5 <<_ACEOF
++cat >config.log <<_ACEOF
+ This file contains any messages produced by compilers while
+ running configure, to aid debugging if configure makes a mistake.
+ It was created by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   $ $0 $@
+ _ACEOF
++exec 5>>config.log
+ {
+ cat <<_ASUNAME
+ ## --------- ##
+@@ -1014,7 +1479,7 @@ uname -v = `(uname -v) 2>/dev/null || ec
+ /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+ /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+ /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+-hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
++/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+ /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+ /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+ /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+@@ -1028,6 +1493,7 @@ do
+   test -z "$as_dir" && as_dir=.
+   echo "PATH: $as_dir"
+ done
++IFS=$as_save_IFS
+ } >&5
+@@ -1049,7 +1515,6 @@ _ACEOF
+ ac_configure_args=
+ ac_configure_args0=
+ ac_configure_args1=
+-ac_sep=
+ ac_must_keep_next=false
+ for ac_pass in 1 2
+ do
+@@ -1060,7 +1525,7 @@ do
+     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+     | -silent | --silent | --silen | --sile | --sil)
+       continue ;;
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
++    *\'*)
+       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+     esac
+     case $ac_pass in
+@@ -1082,9 +1547,7 @@ do
+         -* ) ac_must_keep_next=true ;;
+       esac
+       fi
+-      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
+-      # Get rid of the leading space.
+-      ac_sep=" "
++      ac_configure_args="$ac_configure_args '$ac_arg'"
+       ;;
+     esac
+   done
+@@ -1095,8 +1558,8 @@ $as_unset ac_configure_args1 || test "${
+ # When interrupted or exit'd, cleanup temporary files, and complete
+ # config.log.  We remove comments because anyway the quotes in there
+ # would cause problems or look ugly.
+-# WARNING: Be sure not to use single quotes in there, as some shells,
+-# such as our DU 5.0 friend, will then `close' the trap.
++# WARNING: Use '\'' to represent an apostrophe within the trap.
++# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+ trap 'exit_status=$?
+   # Save into config.log some information that might help in debugging.
+   {
+@@ -1109,20 +1572,34 @@ trap 'exit_status=$?
+ _ASBOX
+     echo
+     # The following way of writing the cache mishandles newlines in values,
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
+   (set) 2>&1 |
+-    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       sed -n \
+-      "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
+-        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
+-      ;;
++      "s/'\''/'\''\\\\'\'''\''/g;
++        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
++      ;; #(
+     *)
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-}
++    esac |
++    sort
++)
+     echo
+     cat <<\_ASBOX
+@@ -1133,22 +1610,28 @@ _ASBOX
+     echo
+     for ac_var in $ac_subst_vars
+     do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+     done | sort
+     echo
+     if test -n "$ac_subst_files"; then
+       cat <<\_ASBOX
+-## ------------- ##
+-## Output files. ##
+-## ------------- ##
++## ------------------- ##
++## File substitutions. ##
++## ------------------- ##
+ _ASBOX
+       echo
+       for ac_var in $ac_subst_files
+       do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+       done | sort
+       echo
+     fi
+@@ -1160,26 +1643,24 @@ _ASBOX
+ ## ----------- ##
+ _ASBOX
+       echo
+-      sed "/^$/d" confdefs.h | sort
++      cat confdefs.h
+       echo
+     fi
+     test "$ac_signal" != 0 &&
+       echo "$as_me: caught signal $ac_signal"
+     echo "$as_me: exit $exit_status"
+   } >&5
+-  rm -f core *.core &&
+-  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
++  rm -f core *.core core.conftest.* &&
++    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+     exit $exit_status
+-     ' 0
++' 0
+ for ac_signal in 1 2 13 15; do
+   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+ done
+ ac_signal=0
+ # confdefs.h avoids OS command line length limits that DEFS can exceed.
+-rm -rf conftest* confdefs.h
+-# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+-echo >confdefs.h
++rm -f -r conftest* confdefs.h
+ # Predefined preprocessor variables.
+@@ -1210,14 +1691,17 @@ _ACEOF
+ # Let the site file select an alternate cache file if it wants to.
+ # Prefer explicitly selected file to automatically selected ones.
+-if test -z "$CONFIG_SITE"; then
+-  if test "x$prefix" != xNONE; then
+-    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+-  else
+-    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+-  fi
++if test -n "$CONFIG_SITE"; then
++  set x "$CONFIG_SITE"
++elif test "x$prefix" != xNONE; then
++  set x "$prefix/share/config.site" "$prefix/etc/config.site"
++else
++  set x "$ac_default_prefix/share/config.site" \
++      "$ac_default_prefix/etc/config.site"
+ fi
+-for ac_site_file in $CONFIG_SITE; do
++shift
++for ac_site_file
++do
+   if test -r "$ac_site_file"; then
+     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
+ echo "$as_me: loading site script $ac_site_file" >&6;}
+@@ -1233,8 +1717,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -1246,12 +1730,11 @@ fi
+ # Check that the precious variables saved in the cache have kept the same
+ # value.
+ ac_cache_corrupted=false
+-for ac_var in `(set) 2>&1 |
+-             sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
++for ac_var in $ac_precious_vars; do
+   eval ac_old_set=\$ac_cv_env_${ac_var}_set
+   eval ac_new_set=\$ac_env_${ac_var}_set
+-  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
+-  eval ac_new_val="\$ac_env_${ac_var}_value"
++  eval ac_old_val=\$ac_cv_env_${ac_var}_value
++  eval ac_new_val=\$ac_env_${ac_var}_value
+   case $ac_old_set,$ac_new_set in
+     set,)
+       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+@@ -1276,8 +1759,7 @@ echo "$as_me:   current value: $ac_new_v
+   # Pass precious variables to config.status.
+   if test "$ac_new_set" = set; then
+     case $ac_new_val in
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+-      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
++    *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+     *) ac_arg=$ac_var=$ac_new_val ;;
+     esac
+     case " $ac_configure_args " in
+@@ -1294,12 +1776,6 @@ echo "$as_me: error: run \`make distclea
+    { (exit 1); exit 1; }; }
+ fi
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+@@ -1316,108 +1792,163 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ ac_aux_dir=
+-for ac_dir in .. $srcdir/..; do
+-  if test -f $ac_dir/install-sh; then
++for ac_dir in .. "$srcdir"/..; do
++  if test -f "$ac_dir/install-sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install-sh -c"
+     break
+-  elif test -f $ac_dir/install.sh; then
++  elif test -f "$ac_dir/install.sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install.sh -c"
+     break
+-  elif test -f $ac_dir/shtool; then
++  elif test -f "$ac_dir/shtool"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/shtool install -c"
+     break
+   fi
+ done
+ if test -z "$ac_aux_dir"; then
+-  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in .. $srcdir/.." >&5
+-echo "$as_me: error: cannot find install-sh or install.sh in .. $srcdir/.." >&2;}
++  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in .. \"$srcdir\"/.." >&5
++echo "$as_me: error: cannot find install-sh or install.sh in .. \"$srcdir\"/.." >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-ac_config_guess="$SHELL $ac_aux_dir/config.guess"
+-ac_config_sub="$SHELL $ac_aux_dir/config.sub"
+-ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
++
++# These three variables are undocumented and unsupported,
++# and are intended to be withdrawn in a future Autoconf release.
++# They can cause serious problems if a builder's source tree is in a directory
++# whose full name contains unusual characters.
++ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
++ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
++ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
++
+ # Make sure we can run config.sub.
+-$ac_config_sub sun4 >/dev/null 2>&1 ||
+-  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
+-echo "$as_me: error: cannot run $ac_config_sub" >&2;}
++$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
++  { { echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
++echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking build system type" >&5
+-echo $ECHO_N "checking build system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking build system type" >&5
++echo $ECHO_N "checking build system type... $ECHO_C" >&6; }
+ if test "${ac_cv_build+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_build_alias=$build_alias
+-test -z "$ac_cv_build_alias" &&
+-  ac_cv_build_alias=`$ac_config_guess`
+-test -z "$ac_cv_build_alias" &&
++  ac_build_alias=$build_alias
++test "x$ac_build_alias" = x &&
++  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
++test "x$ac_build_alias" = x &&
+   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
+ echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
+    { (exit 1); exit 1; }; }
+-ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
++ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
++  { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_build" >&5
+-echo "${ECHO_T}$ac_cv_build" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_build" >&5
++echo "${ECHO_T}$ac_cv_build" >&6; }
++case $ac_cv_build in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
++echo "$as_me: error: invalid value of canonical build" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ build=$ac_cv_build
+-build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_build
++shift
++build_cpu=$1
++build_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++build_os=$*
++IFS=$ac_save_IFS
++case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking host system type" >&5
+-echo $ECHO_N "checking host system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking host system type" >&5
++echo $ECHO_N "checking host system type... $ECHO_C" >&6; }
+ if test "${ac_cv_host+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_host_alias=$host_alias
+-test -z "$ac_cv_host_alias" &&
+-  ac_cv_host_alias=$ac_cv_build_alias
+-ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
++  if test "x$host_alias" = x; then
++  ac_cv_host=$ac_cv_build
++else
++  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_host" >&5
+-echo "${ECHO_T}$ac_cv_host" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_host" >&5
++echo "${ECHO_T}$ac_cv_host" >&6; }
++case $ac_cv_host in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
++echo "$as_me: error: invalid value of canonical host" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ host=$ac_cv_host
+-host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_host
++shift
++host_cpu=$1
++host_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++host_os=$*
++IFS=$ac_save_IFS
++case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking target system type" >&5
+-echo $ECHO_N "checking target system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking target system type" >&5
++echo $ECHO_N "checking target system type... $ECHO_C" >&6; }
+ if test "${ac_cv_target+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_target_alias=$target_alias
+-test "x$ac_cv_target_alias" = "x" &&
+-  ac_cv_target_alias=$ac_cv_host_alias
+-ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
++  if test "x$target_alias" = x; then
++  ac_cv_target=$ac_cv_host
++else
++  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_target" >&5
+-echo "${ECHO_T}$ac_cv_target" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_target" >&5
++echo "${ECHO_T}$ac_cv_target" >&6; }
++case $ac_cv_target in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical target" >&5
++echo "$as_me: error: invalid value of canonical target" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ target=$ac_cv_target
+-target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_target
++shift
++target_cpu=$1
++target_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++target_os=$*
++IFS=$ac_save_IFS
++case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
+ # The aliases save the names the user supplied, while $host etc.
+@@ -1434,8 +1965,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1448,32 +1979,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_CC"; then
+   ac_ct_CC=$CC
+   # Extract the first word of "gcc", so it can be a program name with args.
+ set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1486,36 +2019,51 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ else
+   CC="$ac_cv_prog_CC"
+ fi
+ if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1528,74 +2076,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}cc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
+-
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++  fi
+ fi
+ if test -z "$CC"; then
+   # Extract the first word of "cc", so it can be a program name with args.
+ set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1609,7 +2117,7 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+        continue
+@@ -1620,6 +2128,7 @@ do
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ if test $ac_prog_rejected = yes; then
+   # We found a bogon in the path, so make sure we never use it.
+@@ -1637,22 +2146,23 @@ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$CC"; then
+   if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1665,36 +2175,38 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+     test -n "$CC" && break
+   done
+ fi
+ if test -z "$CC"; then
+   ac_ct_CC=$CC
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1707,29 +2219,45 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$ac_ct_CC" && break
+ done
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ fi
+ fi
+@@ -1742,21 +2270,35 @@ See \`config.log' for more details." >&2
+    { (exit 1); exit 1; }; }
+ # Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
++echo "$as_me:$LINENO: checking for C compiler version" >&5
+ ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+@@ -1781,47 +2323,77 @@ ac_clean_files="$ac_clean_files a.out a.
+ # Try to create an executable without -o first, disregard a.out.
+ # It will help us diagnose broken compilers, and finding out an intuition
+ # of exeext.
+-echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
+-echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
++echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6; }
+ ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+-if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
+-  (eval $ac_link_default) 2>&5
++#
++# List of possible output files, starting from the most likely.
++# The algorithm is not robust to junk in `.', hence go to wildcards (a.*)
++# only as a last resort.  b.out is created by i960 compilers.
++ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'
++#
++# The IRIX 6 linker writes into existing files which may not be
++# executable, retaining their permissions.  Remove them first so a
++# subsequent execution test works.
++ac_rmfiles=
++for ac_file in $ac_files
++do
++  case $ac_file in
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
++    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
++  esac
++done
++rm -f $ac_rmfiles
++
++if { (ac_try="$ac_link_default"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link_default") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  # Find the output, starting from the most likely.  This scheme is
+-# not robust to junk in `.', hence go to wildcards (a.*) only as a last
+-# resort.
+-
+-# Be careful to initialize this variable, since it used to be cached.
+-# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
+-ac_cv_exeext=
+-# b.out is created by i960 compilers.
+-for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
++  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
++# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
++# in a Makefile.  We should not override ac_cv_exeext if it was cached,
++# so that the user can short-circuit this test for compilers unknown to
++# Autoconf.
++for ac_file in $ac_files ''
+ do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
+-      ;;
+-    conftest.$ac_ext )
+-      # This is the source file.
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )
+       ;;
+     [ab].out )
+       # We found the default executable, but exeext='' is most
+       # certainly right.
+       break;;
+     *.* )
+-      ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-      # FIXME: I believe we export ac_cv_exeext for Libtool,
+-      # but it would be cool to find out if it's true.  Does anybody
+-      # maintain Libtool? --akim.
+-      export ac_cv_exeext
++        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
++      then :; else
++         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
++      fi
++      # We set ac_cv_exeext here because the later test for it is not
++      # safe: cross compilers may not add the suffix if given an `-o'
++      # argument, so we may need to know it at that point already.
++      # Even if this section looks crufty: it has the advantage of
++      # actually working.
+       break;;
+     * )
+       break;;
+   esac
+ done
++test "$ac_cv_exeext" = no && ac_cv_exeext=
++
+ else
++  ac_file=''
++fi
++
++{ echo "$as_me:$LINENO: result: $ac_file" >&5
++echo "${ECHO_T}$ac_file" >&6; }
++if test -z "$ac_file"; then
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+@@ -1833,19 +2405,21 @@ See \`config.log' for more details." >&2
+ fi
+ ac_exeext=$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_file" >&5
+-echo "${ECHO_T}$ac_file" >&6
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether the C compiler works" >&5
+-echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether the C compiler works" >&5
++echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6; }
+ # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
+ # If not cross compiling, check that we can run a simple program.
+ if test "$cross_compiling" != yes; then
+   if { ac_try='./$ac_file'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -1864,22 +2438,27 @@ See \`config.log' for more details." >&2
+     fi
+   fi
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ rm -f a.out a.exe conftest$ac_cv_exeext b.out
+ ac_clean_files=$ac_clean_files_save
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
+-echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
+-echo "$as_me:$LINENO: result: $cross_compiling" >&5
+-echo "${ECHO_T}$cross_compiling" >&6
+-
+-echo "$as_me:$LINENO: checking for suffix of executables" >&5
+-echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
++echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }
++{ echo "$as_me:$LINENO: result: $cross_compiling" >&5
++echo "${ECHO_T}$cross_compiling" >&6; }
++
++{ echo "$as_me:$LINENO: checking for suffix of executables" >&5
++echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+@@ -1890,9 +2469,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_l
+ for ac_file in conftest.exe conftest conftest.*; do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
+     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-        export ac_cv_exeext
+         break;;
+     * ) break;;
+   esac
+@@ -1906,14 +2484,14 @@ See \`config.log' for more details." >&2
+ fi
+ rm -f conftest$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
+-echo "${ECHO_T}$ac_cv_exeext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
++echo "${ECHO_T}$ac_cv_exeext" >&6; }
+ rm -f conftest.$ac_ext
+ EXEEXT=$ac_cv_exeext
+ ac_exeext=$EXEEXT
+-echo "$as_me:$LINENO: checking for suffix of object files" >&5
+-echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for suffix of object files" >&5
++echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }
+ if test "${ac_cv_objext+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1933,14 +2511,20 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.o conftest.obj
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>&5
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
++  for ac_file in conftest.o conftest.obj conftest.*; do
++  test -f "$ac_file" || continue;
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;
+     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+        break;;
+   esac
+@@ -1958,12 +2542,12 @@ fi
+ rm -f conftest.$ac_cv_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
+-echo "${ECHO_T}$ac_cv_objext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
++echo "${ECHO_T}$ac_cv_objext" >&6; }
+ OBJEXT=$ac_cv_objext
+ ac_objext=$OBJEXT
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+ if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1986,50 +2570,49 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+ GCC=`test $ac_compiler_gnu = yes && echo yes`
+ ac_test_CFLAGS=${CFLAGS+set}
+ ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -2045,38 +2628,118 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
++
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
+ if test "$ac_test_CFLAGS" = set; then
+   CFLAGS=$ac_save_CFLAGS
+ elif test $ac_cv_prog_cc_g = yes; then
+@@ -2092,12 +2755,12 @@ else
+     CFLAGS=
+   fi
+ fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_prog_cc_stdc=no
++  ac_cv_prog_cc_c89=no
+ ac_save_CC=$CC
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -2131,12 +2794,17 @@ static char *f (char * (*g) (char **, in
+ /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+    function prototypes and stuff, but not '\xHH' hex character constants.
+    These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
++   as 'x'.  The following induces an error, until -std is added to get
+    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+    array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
++   that's true only with -std.  */
+ int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
+ int test (int i, double x);
+ struct s1 {int (*f) (int a);};
+ struct s2 {int (*f) (double a);};
+@@ -2151,335 +2819,144 @@ return f (e, argv, 0) != argv[0]  ||  f 
+   return 0;
+ }
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+ do
+   CC="$ac_save_CC $ac_arg"
+   rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext
++
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+-rm -f conftest.$ac_ext conftest.$ac_objext
++rm -f conftest.$ac_ext
+ CC=$ac_save_CC
+ fi
+-
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
+   *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
+ esac
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
++
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
++
++
++{ echo "$as_me:$LINENO: checking for library containing strerror" >&5
++echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6; }
++if test "${ac_cv_search_strerror+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_func_search_save_LIBS=$LIBS
+ cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
++
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
++#ifdef __cplusplus
++extern "C"
++#endif
++char strerror ();
+ int
+ main ()
+ {
+-exit (42);
++return strerror ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++for ac_lib in '' cposix; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_strerror=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
+-fi
+-
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_strerror+set}" = set; then
++  break
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+-
+-echo "$as_me:$LINENO: checking for library containing strerror" >&5
+-echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6
++done
+ if test "${ac_cv_search_strerror+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_strerror=no
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="none required"
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_strerror" = no; then
+-  for ac_lib in cposix; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="-l$ac_lib"
+-break
++  :
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++  ac_cv_search_strerror=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
+-echo "${ECHO_T}$ac_cv_search_strerror" >&6
+-if test "$ac_cv_search_strerror" != no; then
+-  test "$ac_cv_search_strerror" = "none required" || LIBS="$ac_cv_search_strerror $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
++echo "${ECHO_T}$ac_cv_search_strerror" >&6; }
++ac_res=$ac_cv_search_strerror
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+@@ -2499,8 +2976,8 @@ am__api_version="1.9"
+ # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+ # OS/2's system install, which has a completely different semantic
+ # ./install, which can be erroneously created by make from ./install.sh.
+-echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+-echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+ if test -z "$INSTALL"; then
+ if test "${ac_cv_path_install+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -2522,7 +2999,7 @@ case $as_dir/ in
+     # by default.
+     for ac_prog in ginstall scoinst install; do
+       for ac_exec_ext in '' $ac_executable_extensions; do
+-      if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
++      if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+         if test $ac_prog = install &&
+           grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+           # AIX install.  It has an incompatible calling convention.
+@@ -2541,21 +3018,22 @@ case $as_dir/ in
+     ;;
+ esac
+ done
++IFS=$as_save_IFS
+ fi
+   if test "${ac_cv_path_install+set}" = set; then
+     INSTALL=$ac_cv_path_install
+   else
+-    # As a last resort, use the slow shell script.  We don't cache a
+-    # path for INSTALL within a source directory, because that will
++    # As a last resort, use the slow shell script.  Don't cache a
++    # value for INSTALL within a source directory, because that will
+     # break other packages using the cache if that directory is
+-    # removed, or if the path is relative.
++    # removed, or if the value is a relative name.
+     INSTALL=$ac_install_sh
+   fi
+ fi
+-echo "$as_me:$LINENO: result: $INSTALL" >&5
+-echo "${ECHO_T}$INSTALL" >&6
++{ echo "$as_me:$LINENO: result: $INSTALL" >&5
++echo "${ECHO_T}$INSTALL" >&6; }
+ # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+ # It thinks the first close brace ends the variable substitution.
+@@ -2565,8 +3043,8 @@ test -z "$INSTALL_SCRIPT" && INSTALL_SCR
+ test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+-echo "$as_me:$LINENO: checking whether build environment is sane" >&5
+-echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether build environment is sane" >&5
++echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6; }
+ # Just in case
+ sleep 1
+ echo timestamp > conftest.file
+@@ -2608,20 +3086,20 @@ echo "$as_me: error: newly created file 
+ Check your system clock" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ test "$program_prefix" != NONE &&
+-  program_transform_name="s,^,$program_prefix,;$program_transform_name"
++  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+ # Use a double $ so make ignores it.
+ test "$program_suffix" != NONE &&
+-  program_transform_name="s,\$,$program_suffix,;$program_transform_name"
++  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+ # Double any \ or $.  echo might interpret backslashes.
+ # By default was `s,x,x', remove it if useless.
+ cat <<\_ACEOF >conftest.sed
+ s/[\\$]/&&/g;s/;s,x,x,$//
+ _ACEOF
+ program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
+-rm conftest.sed
++rm -f conftest.sed
+ # expand $ac_aux_dir to an absolute path
+ am_aux_dir=`cd $ac_aux_dir && pwd`
+@@ -2673,8 +3151,8 @@ for ac_prog in gawk mawk nawk awk
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_AWK+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2687,54 +3165,57 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_AWK="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ AWK=$ac_cv_prog_AWK
+ if test -n "$AWK"; then
+-  echo "$as_me:$LINENO: result: $AWK" >&5
+-echo "${ECHO_T}$AWK" >&6
++  { echo "$as_me:$LINENO: result: $AWK" >&5
++echo "${ECHO_T}$AWK" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$AWK" && break
+ done
+-echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+-echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
+-set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
+-if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
++echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6; }
++set x ${MAKE-make}; ac_make=`echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
++if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.make <<\_ACEOF
++SHELL = /bin/sh
+ all:
+-      @echo 'ac_maketemp="$(MAKE)"'
++      @echo '@@@%%%=$(MAKE)=@@@%%%'
+ _ACEOF
+ # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
+-eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
+-if test -n "$ac_maketemp"; then
+-  eval ac_cv_prog_make_${ac_make}_set=yes
+-else
+-  eval ac_cv_prog_make_${ac_make}_set=no
+-fi
++case `${MAKE-make} -f conftest.make 2>/dev/null` in
++  *@@@%%%=?*=@@@%%%*)
++    eval ac_cv_prog_make_${ac_make}_set=yes;;
++  *)
++    eval ac_cv_prog_make_${ac_make}_set=no;;
++esac
+ rm -f conftest.make
+ fi
+-if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+   SET_MAKE=
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+   SET_MAKE="MAKE=${MAKE-make}"
+ fi
+@@ -2749,7 +3230,7 @@ rmdir .tst 2>/dev/null
+ DEPDIR="${am__leading_dot}deps"
+-          ac_config_commands="$ac_config_commands depfiles"
++ac_config_commands="$ac_config_commands depfiles"
+ am_make=${MAKE-make}
+@@ -2759,8 +3240,8 @@ am__doit:
+ .PHONY: am__doit
+ END
+ # If we don't find an include directive, just comment out the code.
+-echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
+-echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
++echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6; }
+ am__include="#"
+ am__quote=
+ _am_result=none
+@@ -2787,15 +3268,15 @@ if test "$am__include" = "#"; then
+ fi
+-echo "$as_me:$LINENO: result: $_am_result" >&5
+-echo "${ECHO_T}$_am_result" >&6
++{ echo "$as_me:$LINENO: result: $_am_result" >&5
++echo "${ECHO_T}$_am_result" >&6; }
+ rm -f confinc confmf
+-# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
++# Check whether --enable-dependency-tracking was given.
+ if test "${enable_dependency_tracking+set}" = set; then
+-  enableval="$enable_dependency_tracking"
++  enableval=$enable_dependency_tracking;
++fi
+-fi;
+ if test "x$enable_dependency_tracking" != xno; then
+   am_depcomp="$ac_aux_dir/depcomp"
+   AMDEPBACKSLASH='\'
+@@ -2870,8 +3351,8 @@ if test "$cross_compiling" != no; then
+   if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2884,32 +3365,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2922,27 +3405,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -2963,8 +3460,8 @@ am__tar='${AMTAR} chof - "$$tardir"'; am
+ depcc="$CC"   am_compiler_list=
+-echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
+-echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
++echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; }
+ if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3053,8 +3550,8 @@ else
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
+-echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
++echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; }
+ CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+@@ -3072,10 +3569,9 @@ fi
+-# Check whether --enable-shared or --disable-shared was given.
++# Check whether --enable-shared was given.
+ if test "${enable_shared+set}" = set; then
+-  enableval="$enable_shared"
+-  p=${PACKAGE-default}
++  enableval=$enable_shared; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_shared=yes ;;
+ no) enable_shared=no ;;
+@@ -3093,11 +3589,11 @@ no) enable_shared=no ;;
+ esac
+ else
+   enable_shared=yes
+-fi;
+-# Check whether --enable-static or --disable-static was given.
++fi
++
++# Check whether --enable-static was given.
+ if test "${enable_static+set}" = set; then
+-  enableval="$enable_static"
+-  p=${PACKAGE-default}
++  enableval=$enable_static; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_static=yes ;;
+ no) enable_static=no ;;
+@@ -3115,11 +3611,11 @@ no) enable_static=no ;;
+ esac
+ else
+   enable_static=yes
+-fi;
+-# Check whether --enable-fast-install or --disable-fast-install was given.
++fi
++
++# Check whether --enable-fast-install was given.
+ if test "${enable_fast_install+set}" = set; then
+-  enableval="$enable_fast_install"
+-  p=${PACKAGE-default}
++  enableval=$enable_fast_install; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_fast_install=yes ;;
+ no) enable_fast_install=no ;;
+@@ -3137,20 +3633,21 @@ no) enable_fast_install=no ;;
+ esac
+ else
+   enable_fast_install=yes
+-fi;
++fi
++
+-# Check whether --with-gnu-ld or --without-gnu-ld was given.
++# Check whether --with-gnu-ld was given.
+ if test "${with_gnu_ld+set}" = set; then
+-  withval="$with_gnu_ld"
+-  test "$withval" = no || with_gnu_ld=yes
++  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+ else
+   with_gnu_ld=no
+-fi;
++fi
++
+ ac_prog=ld
+ if test "$GCC" = yes; then
+   # Check if gcc -print-prog-name=ld gives a path.
+-  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
+-echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for ld used by GCC" >&5
++echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6; }
+   case $host in
+   *-*-mingw*)
+     # gcc leaves a trailing carriage return which upsets mingw
+@@ -3179,11 +3676,11 @@ echo $ECHO_N "checking for ld used by GC
+     ;;
+   esac
+ elif test "$with_gnu_ld" = yes; then
+-  echo "$as_me:$LINENO: checking for GNU ld" >&5
+-echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for GNU ld" >&5
++echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6; }
+ else
+-  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
+-echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for non-GNU ld" >&5
++echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6; }
+ fi
+ if test "${lt_cv_path_LD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -3212,17 +3709,17 @@ fi
+ LD="$lt_cv_path_LD"
+ if test -n "$LD"; then
+-  echo "$as_me:$LINENO: result: $LD" >&5
+-echo "${ECHO_T}$LD" >&6
++  { echo "$as_me:$LINENO: result: $LD" >&5
++echo "${ECHO_T}$LD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
+ echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
+-echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
++echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6; }
+ if test "${lt_cv_prog_gnu_ld+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3233,25 +3730,25 @@ else
+   lt_cv_prog_gnu_ld=no
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
+-echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
++echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6; }
+ with_gnu_ld=$lt_cv_prog_gnu_ld
+-echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
+-echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
++echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6; }
+ if test "${lt_cv_ld_reload_flag+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   lt_cv_ld_reload_flag='-r'
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
+-echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
++echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6; }
+ reload_flag=$lt_cv_ld_reload_flag
+ test -n "$reload_flag" && reload_flag=" $reload_flag"
+-echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
+-echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
++echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6; }
+ if test "${lt_cv_path_NM+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3286,22 +3783,22 @@ fi
+ fi
+ NM="$lt_cv_path_NM"
+-echo "$as_me:$LINENO: result: $NM" >&5
+-echo "${ECHO_T}$NM" >&6
++{ echo "$as_me:$LINENO: result: $NM" >&5
++echo "${ECHO_T}$NM" >&6; }
+-echo "$as_me:$LINENO: checking whether ln -s works" >&5
+-echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether ln -s works" >&5
++echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6; }
+ LN_S=$as_ln_s
+ if test "$LN_S" = "ln -s"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
+-echo "${ECHO_T}no, using $LN_S" >&6
++  { echo "$as_me:$LINENO: result: no, using $LN_S" >&5
++echo "${ECHO_T}no, using $LN_S" >&6; }
+ fi
+-echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
+-echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
++echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6; }
+ if test "${lt_cv_deplibs_check_method+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3463,8 +3960,8 @@ sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+ esac
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
+-echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
++echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6; }
+ file_magic_cmd=$lt_cv_file_magic_cmd
+ deplibs_check_method=$lt_cv_deplibs_check_method
+@@ -3474,8 +3971,8 @@ deplibs_check_method=$lt_cv_deplibs_chec
+ # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
+ # find the maximum length of command line arguments
+-echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
+-echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
++echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6; }
+ if test "${lt_cv_sys_max_cmd_len+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3526,11 +4023,11 @@ else
+ fi
+ if test -n "$lt_cv_sys_max_cmd_len" ; then
+-  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
+-echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
++  { echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
++echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: none" >&5
+-echo "${ECHO_T}none" >&6
++  { echo "$as_me:$LINENO: result: none" >&5
++echo "${ECHO_T}none" >&6; }
+ fi
+@@ -3538,8 +4035,8 @@ fi
+ case $deplibs_check_method in
+ file_magic*)
+   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+-    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
+-echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
++echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3593,17 +4090,17 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ if test -z "$lt_cv_path_MAGIC_CMD"; then
+   if test -n "$ac_tool_prefix"; then
+-    echo "$as_me:$LINENO: checking for file" >&5
+-echo $ECHO_N "checking for file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for file" >&5
++echo $ECHO_N "checking for file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3657,11 +4154,11 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+   else
+@@ -3676,8 +4173,8 @@ esac
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3690,32 +4187,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3728,27 +4227,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -3756,8 +4269,8 @@ fi
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3770,32 +4283,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3808,27 +4323,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -3843,22 +4372,22 @@ test "$GCC" = yes && libtool_flags="$lib
+ test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
+-# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
++# Check whether --enable-libtool-lock was given.
+ if test "${enable_libtool_lock+set}" = set; then
+-  enableval="$enable_libtool_lock"
++  enableval=$enable_libtool_lock;
++fi
+-fi;
+ test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
+ test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
+-# Check whether --with-pic or --without-pic was given.
++# Check whether --with-pic was given.
+ if test "${with_pic+set}" = set; then
+-  withval="$with_pic"
+-  pic_mode="$withval"
++  withval=$with_pic; pic_mode="$withval"
+ else
+   pic_mode=default
+-fi;
++fi
++
+ test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
+ test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
+@@ -3867,7 +4396,7 @@ test x"$pic_mode" = xno && libtool_flags
+ case $host in
+ *-*-irix6*)
+   # Find out which ABI we are using.
+-  echo '#line 3870 "configure"' > conftest.$ac_ext
++  echo '#line 4399 "configure"' > conftest.$ac_ext
+   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+   (eval $ac_compile) 2>&5
+   ac_status=$?
+@@ -3972,13 +4501,12 @@ x86_64-*linux*|ppc*-*linux*|powerpc*-*li
+   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+   SAVE_CFLAGS="$CFLAGS"
+   CFLAGS="$CFLAGS -belf"
+-  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
+-echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
++echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6; }
+ if test "${lt_cv_cc_needs_belf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -4001,35 +4529,32 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   lt_cv_cc_needs_belf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-lt_cv_cc_needs_belf=no
++      lt_cv_cc_needs_belf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+@@ -4038,8 +4563,8 @@ ac_link='$CC -o conftest$ac_exeext $CFLA
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
+-echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
++echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6; }
+   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+     CFLAGS="$SAVE_CFLAGS"
+@@ -4069,39 +4594,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -4127,8 +4671,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -4154,10 +4698,9 @@ exec 5>>./config.log
+-# Check whether --enable-targets or --disable-targets was given.
++# Check whether --enable-targets was given.
+ if test "${enable_targets+set}" = set; then
+-  enableval="$enable_targets"
+-  case "${enableval}" in
++  enableval=$enable_targets; case "${enableval}" in
+   yes | "") { { echo "$as_me:$LINENO: error: enable-targets option must specify target names or 'all'" >&5
+ echo "$as_me: error: enable-targets option must specify target names or 'all'" >&2;}
+    { (exit 1); exit 1; }; }
+@@ -4165,33 +4708,34 @@ echo "$as_me: error: enable-targets opti
+   no)     enable_targets= ;;
+   *)      enable_targets=$enableval ;;
+ esac
+-fi; # Check whether --enable-commonbfdlib or --disable-commonbfdlib was given.
++fi
++# Check whether --enable-commonbfdlib was given.
+ if test "${enable_commonbfdlib+set}" = set; then
+-  enableval="$enable_commonbfdlib"
+-  case "${enableval}" in
++  enableval=$enable_commonbfdlib; case "${enableval}" in
+   yes) commonbfdlib=true ;;
+   no)  commonbfdlib=false ;;
+   *)   { { echo "$as_me:$LINENO: error: bad value ${enableval} for BFD commonbfdlib option" >&5
+ echo "$as_me: error: bad value ${enableval} for BFD commonbfdlib option" >&2;}
+    { (exit 1); exit 1; }; } ;;
+ esac
+-fi;
++fi
++
+ using_cgen=no
+ GCC_WARN_CFLAGS="-W -Wall -Wstrict-prototypes -Wmissing-prototypes"
+-# Check whether --enable-werror or --disable-werror was given.
++# Check whether --enable-werror was given.
+ if test "${enable_werror+set}" = set; then
+-  enableval="$enable_werror"
+-  case "${enableval}" in
++  enableval=$enable_werror; case "${enableval}" in
+      yes | y) ERROR_ON_WARNING="yes" ;;
+      no | n)  ERROR_ON_WARNING="no" ;;
+      *) { { echo "$as_me:$LINENO: error: bad value ${enableval} for --enable-werror" >&5
+ echo "$as_me: error: bad value ${enableval} for --enable-werror" >&2;}
+    { (exit 1); exit 1; }; } ;;
+    esac
+-fi;
++fi
++
+ # Enable -Werror by default when using gcc
+ if test "${GCC}" = yes -a -z "${ERROR_ON_WARNING}" ; then
+@@ -4208,10 +4752,9 @@ if test "${GCC}" = yes ; then
+   WARN_CFLAGS="${GCC_WARN_CFLAGS}"
+ fi
+-# Check whether --enable-build-warnings or --disable-build-warnings was given.
++# Check whether --enable-build-warnings was given.
+ if test "${enable_build_warnings+set}" = set; then
+-  enableval="$enable_build_warnings"
+-  case "${enableval}" in
++  enableval=$enable_build_warnings; case "${enableval}" in
+   yes)        WARN_CFLAGS="${GCC_WARN_CFLAGS}";;
+   no) if test "${GCC}" = yes ; then
+         WARN_CFLAGS="-w"
+@@ -4222,7 +4765,8 @@ if test "${enable_build_warnings+set}" =
+         WARN_CFLAGS="${t} ${GCC_WARN_CFLAGS}";;
+   *)    WARN_CFLAGS=`echo "${enableval}" | sed -e "s/,/ /g"`;;
+ esac
+-fi;
++fi
++
+ if test x"$silent" != x"yes" && test x"$WARN_CFLAGS" != x""; then
+   echo "Setting warning flags = $WARN_CFLAGS" 6>&1
+@@ -4233,7 +4777,7 @@ fi
+ # Generate a header file
+-          ac_config_headers="$ac_config_headers config.h:config.in"
++ac_config_headers="$ac_config_headers config.h:config.in"
+ # If we are on a DOS filesystem, we must use gdb.ini rather than
+@@ -4241,789 +4785,913 @@ fi
+ case "${host}" in
+   *-*-msdos* | *-*-go32* | *-*-mingw32* | *-*-windows*)
+     GDBINIT="gdb.ini"
+-              ac_config_files="$ac_config_files gdb.ini:gdbinit.in"
++    ac_config_files="$ac_config_files gdb.ini:gdbinit.in"
+     ;;
+   *)
+     GDBINIT=".gdbinit"
+-              ac_config_files="$ac_config_files .gdbinit:gdbinit.in"
++    ac_config_files="$ac_config_files .gdbinit:gdbinit.in"
+     ;;
+ esac
+ #We need this for the host.  BOUT header is in host order.
+-echo "$as_me:$LINENO: checking whether byte ordering is bigendian" >&5
+-echo $ECHO_N "checking whether byte ordering is bigendian... $ECHO_C" >&6
+-if test "${ac_cv_c_bigendian+set}" = set; then
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
++{ echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
++echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }
++# On Suns, sometimes $CPP names a directory.
++if test -n "$CPP" && test -d "$CPP"; then
++  CPP=
++fi
++if test -z "$CPP"; then
++  if test "${ac_cv_prog_CPP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  # See if sys/param.h defines the BYTE_ORDER macro.
+-cat >conftest.$ac_ext <<_ACEOF
++      # Double quotes because CPP needs to be expanded
++    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
++    do
++      ac_preproc_ok=false
++for ac_c_preproc_warn_flag in '' yes
++do
++  # Use a header file that comes with gcc, so configuring glibc
++  # with a fresh cross-compiler works.
++  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
++  # <limits.h> exists even on freestanding compilers.
++  # On the NeXT, cc -E runs the code through the compiler's parser,
++  # not just through cpp. "Syntax error" is here to catch this case.
++  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#include <sys/types.h>
+-#include <sys/param.h>
+-
+-int
+-main ()
+-{
+-#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
+- bogus endian macros
++#ifdef __STDC__
++# include <limits.h>
++#else
++# include <assert.h>
+ #endif
+-
+-  ;
+-  return 0;
+-}
++                   Syntax error
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  # It does; now see whether it defined to BIG_ENDIAN or not.
+-cat >conftest.$ac_ext <<_ACEOF
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++  # Broken: fails on valid input.
++continue
++fi
++
++rm -f conftest.err conftest.$ac_ext
++
++  # OK, works on sane cases.  Now check whether nonexistent headers
++  # can be detected and how.
++  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#include <sys/types.h>
+-#include <sys/param.h>
+-
+-int
+-main ()
+-{
+-#if BYTE_ORDER != BIG_ENDIAN
+- not big endian
+-#endif
+-
+-  ;
+-  return 0;
+-}
++#include <ac_nonexistent.h>
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_c_bigendian=yes
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
++  # Broken: success on invalid input.
++continue
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_c_bigendian=no
++  # Passes both tests.
++ac_preproc_ok=:
++break
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-# It does not; compile a test program.
+-if test "$cross_compiling" = yes; then
+-  # try to guess the endianness by grepping values into an object file
+-  ac_cv_c_bigendian=unknown
++rm -f conftest.err conftest.$ac_ext
++
++done
++# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
++rm -f conftest.err conftest.$ac_ext
++if $ac_preproc_ok; then
++  break
++fi
++
++    done
++    ac_cv_prog_CPP=$CPP
++
++fi
++  CPP=$ac_cv_prog_CPP
++else
++  ac_cv_prog_CPP=$CPP
++fi
++{ echo "$as_me:$LINENO: result: $CPP" >&5
++echo "${ECHO_T}$CPP" >&6; }
++ac_preproc_ok=false
++for ac_c_preproc_warn_flag in '' yes
++do
++  # Use a header file that comes with gcc, so configuring glibc
++  # with a fresh cross-compiler works.
++  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
++  # <limits.h> exists even on freestanding compilers.
++  # On the NeXT, cc -E runs the code through the compiler's parser,
++  # not just through cpp. "Syntax error" is here to catch this case.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-short ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
+-short ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
+-void _ascii () { char *s = (char *) ascii_mm; s = (char *) ascii_ii; }
+-short ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
+-short ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
+-void _ebcdic () { char *s = (char *) ebcdic_mm; s = (char *) ebcdic_ii; }
+-int
+-main ()
+-{
+- _ascii (); _ebcdic ();
+-  ;
+-  return 0;
+-}
++#ifdef __STDC__
++# include <limits.h>
++#else
++# include <assert.h>
++#endif
++                   Syntax error
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
+-  ac_cv_c_bigendian=yes
+-fi
+-if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
+-  if test "$ac_cv_c_bigendian" = unknown; then
+-    ac_cv_c_bigendian=no
+-  else
+-    # finding both strings is unlikely to happen, but who knows?
+-    ac_cv_c_bigendian=unknown
+-  fi
+-fi
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
++  :
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++  # Broken: fails on valid input.
++continue
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-else
++
++rm -f conftest.err conftest.$ac_ext
++
++  # OK, works on sane cases.  Now check whether nonexistent headers
++  # can be detected and how.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-int
+-main ()
+-{
+-  /* Are we little or big endian?  From Harbison&Steele.  */
+-  union
+-  {
+-    long l;
+-    char c[sizeof (long)];
+-  } u;
+-  u.l = 1;
+-  exit (u.c[sizeof (long) - 1] == 1);
+-}
++#include <ac_nonexistent.h>
+ _ACEOF
+-rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_c_bigendian=no
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
++  # Broken: success on invalid input.
++continue
+ else
+-  echo "$as_me: program exited with status $ac_status" >&5
+-echo "$as_me: failed program was:" >&5
++  echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-( exit $ac_status )
+-ac_cv_c_bigendian=yes
+-fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+-fi
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++  # Passes both tests.
++ac_preproc_ok=:
++break
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_bigendian" >&5
+-echo "${ECHO_T}$ac_cv_c_bigendian" >&6
+-case $ac_cv_c_bigendian in
+-  yes)
+-cat >>confdefs.h <<\_ACEOF
+-#define WORDS_BIGENDIAN 1
+-_ACEOF
+- ;;
+-  no)
+-     ;;
+-  *)
+-    { { echo "$as_me:$LINENO: error: unknown endianness
+-presetting ac_cv_c_bigendian=no (or yes) will help" >&5
+-echo "$as_me: error: unknown endianness
+-presetting ac_cv_c_bigendian=no (or yes) will help" >&2;}
+-   { (exit 1); exit 1; }; } ;;
+-esac
++rm -f conftest.err conftest.$ac_ext
++done
++# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
++rm -f conftest.err conftest.$ac_ext
++if $ac_preproc_ok; then
++  :
++else
++  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
++See \`config.log' for more details." >&5
++echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
++See \`config.log' for more details." >&2;}
++   { (exit 1); exit 1; }; }
++fi
+-te_file=generic
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-# Makefile target for installing gas in $(tooldir)/bin.
+-install_tooldir=install-exec-tooldir
+-canon_targets=""
+-all_targets=no
+-if test -n "$enable_targets" ; then
+-  for t in `echo $enable_targets | sed 's/,/ /g'`; do
+-    if test $t = "all"; then
+-      all_targets=yes
+-      continue
+-    fi
+-    result=`$ac_config_sub $t 2>/dev/null`
+-    if test -n "$result" ; then
+-      canon_targets="$canon_targets $result"
+-#    else
+-#      # Permit "all", etc.  We don't support it yet though.
+-#      canon_targets="$canon_targets $t"
++{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
++echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }
++if test "${ac_cv_path_GREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  # Extract the first word of "grep ggrep" to use in msg output
++if test -z "$GREP"; then
++set dummy grep ggrep; ac_prog_name=$2
++if test "${ac_cv_path_GREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_path_GREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in grep ggrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
++    # Check for GNU ac_path_GREP and select it if it is found.
++  # Check for GNU $ac_path_GREP
++case `"$ac_path_GREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'GREP' >> "conftest.nl"
++    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_GREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_GREP="$ac_path_GREP"
++      ac_path_GREP_max=$ac_count
+     fi
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
++
++
++    $ac_path_GREP_found && break 3
+   done
+-  _gas_uniq_list="$canon_targets"
+-_gas_uniq_newlist=""
+-for _gas_uniq_i in _gas_uniq_dummy $_gas_uniq_list ; do
+-  case $_gas_uniq_i in
+-  _gas_uniq_dummy) ;;
+-  *) case " $_gas_uniq_newlist " in
+-       *" $_gas_uniq_i "*) ;;
+-       *) _gas_uniq_newlist="$_gas_uniq_newlist $_gas_uniq_i" ;;
+-     esac ;;
+-  esac
+ done
+-canon_targets=$_gas_uniq_newlist
+-fi
++done
++IFS=$as_save_IFS
+-emulations=""
+-for this_target in $target $canon_targets ; do
++fi
+-    targ=${this_target}
+-    . ${srcdir}/configure.tgt
++GREP="$ac_cv_path_GREP"
++if test -z "$GREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
+-    case ${target_cpu} in
+-      crisv32)
++else
++  ac_cv_path_GREP=$GREP
++fi
+-cat >>confdefs.h <<_ACEOF
+-#define DEFAULT_CRIS_ARCH $arch
+-_ACEOF
+-      ;;
+-    esac
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
++echo "${ECHO_T}$ac_cv_path_GREP" >&6; }
++ GREP="$ac_cv_path_GREP"
+-    if test ${this_target} = $target ; then
+-      target_cpu_type=${cpu_type}
+-    elif test ${target_cpu_type} != ${cpu_type} ; then
+-      continue
++
++{ echo "$as_me:$LINENO: checking for egrep" >&5
++echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }
++if test "${ac_cv_path_EGREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
++   then ac_cv_path_EGREP="$GREP -E"
++   else
++     # Extract the first word of "egrep" to use in msg output
++if test -z "$EGREP"; then
++set dummy egrep; ac_prog_name=$2
++if test "${ac_cv_path_EGREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_path_EGREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in egrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
++    # Check for GNU ac_path_EGREP and select it if it is found.
++  # Check for GNU $ac_path_EGREP
++case `"$ac_path_EGREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'EGREP' >> "conftest.nl"
++    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_EGREP="$ac_path_EGREP"
++      ac_path_EGREP_max=$ac_count
+     fi
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
+-    generic_target=${cpu_type}-${target_vendor}-${target_os}
+-    case ${generic_target} in
+-      i386-*-sco3.2v5*)
+-      if test ${this_target} = $target; then
+-cat >>confdefs.h <<\_ACEOF
+-#define SCO_ELF 1
+-_ACEOF
++    $ac_path_EGREP_found && break 3
++  done
++done
+-      fi
+-      ;;
++done
++IFS=$as_save_IFS
+-      i386-*-msdosdjgpp* \
+-      | i386-*-go32* \
+-      | i386-go32-rtems*)
+-cat >>confdefs.h <<\_ACEOF
+-#define STRICTCOFF 1
+-_ACEOF
++fi
+-      ;;
++EGREP="$ac_cv_path_EGREP"
++if test -z "$EGREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
+-      i860-*-*)
+-      { echo "$as_me:$LINENO: WARNING: GAS support for ${generic_target} is preliminary and a work in progress" >&5
+-echo "$as_me: WARNING: GAS support for ${generic_target} is preliminary and a work in progress" >&2;}
+-      ;;
++else
++  ac_cv_path_EGREP=$EGREP
++fi
+-      mips-sony-bsd*)
+-      ;;
+-      mips-*-bsd*)
+-      { { echo "$as_me:$LINENO: error: Unknown vendor for mips-bsd configuration." >&5
+-echo "$as_me: error: Unknown vendor for mips-bsd configuration." >&2;}
+-   { (exit 1); exit 1; }; }
+-      ;;
+-      ppc-*-aix5.*)
++   fi
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
++echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }
++ EGREP="$ac_cv_path_EGREP"
+-cat >>confdefs.h <<\_ACEOF
+-#define AIX_WEAK_SUPPORT 1
++
++{ echo "$as_me:$LINENO: checking for ANSI C header files" >&5
++echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
++if test "${ac_cv_header_stdc+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
+ _ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <stdlib.h>
++#include <stdarg.h>
++#include <string.h>
++#include <float.h>
+-      ;;
+-      ppc-*-linux-*)
+-      case "$endian" in
+-        big)  ;;
+-        *)    { { echo "$as_me:$LINENO: error: GNU/Linux must be configured big endian" >&5
+-echo "$as_me: error: GNU/Linux must be configured big endian" >&2;}
+-   { (exit 1); exit 1; }; } ;;
+-      esac
+-      ;;
+-      ppc-*-solaris*)
+-      if test ${this_target} = $target; then
++int
++main ()
++{
+-cat >>confdefs.h <<\_ACEOF
+-#define TARGET_SOLARIS_COMMENT 1
++  ;
++  return 0;
++}
+ _ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_header_stdc=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
+-      fi
+-      if test x${endian} = xbig; then
+-        { { echo "$as_me:$LINENO: error: Solaris must be configured little endian" >&5
+-echo "$as_me: error: Solaris must be configured little endian" >&2;}
+-   { (exit 1); exit 1; }; }
+-      fi
+-      ;;
++      ac_cv_header_stdc=no
++fi
+-      sh*-*-symbianelf*)
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+-cat >>confdefs.h <<\_ACEOF
+-#define TARGET_SYMBIAN 1
++if test $ac_cv_header_stdc = yes; then
++  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
+ _ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <string.h>
+-      ;;
+-    esac
++_ACEOF
++if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
++  $EGREP "memchr" >/dev/null 2>&1; then
++  :
++else
++  ac_cv_header_stdc=no
++fi
++rm -f conftest*
+-    if test ${this_target} = $target ; then
+-      endian_def=
+-      if test x${endian} = xbig; then
+-      endian_def=1
+-      elif test x${endian} = xlittle; then
+-      endian_def=0
+-      fi
+-      if test x${endian_def} != x; then
++fi
+-cat >>confdefs.h <<_ACEOF
+-#define TARGET_BYTES_BIG_ENDIAN $endian_def
++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 <<_ACEOF
++/* confdefs.h.  */
+ _ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <stdlib.h>
+-      fi
+-    fi
++_ACEOF
++if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
++  $EGREP "free" >/dev/null 2>&1; then
++  :
++else
++  ac_cv_header_stdc=no
++fi
++rm -f conftest*
+-# Other random stuff.
++fi
+-    case ${cpu_type} in
+-      mips)
+-      # Set mips_cpu to the name of the default CPU.
+-      case ${target_cpu} in
+-        mips | mipsbe | mipseb | mipsle | mipsel | mips64 | mips64el)
+-          mips_cpu=from-abi
+-          ;;
+-        mipsisa32 | mipsisa32el)
+-          mips_cpu=mips32
+-          ;;
+-        mipsisa32r2 | mipsisa32r2el)
+-          mips_cpu=mips32r2
+-          ;;
+-        mipsisa64 | mipsisa64el)
+-          mips_cpu=mips64
+-          ;;
+-        mipsisa64r2 | mipsisa64r2el)
+-          mips_cpu=mips64r2
+-          ;;
+-        mipstx39 | mipstx39el)
+-          mips_cpu=r3900
+-          ;;
+-        mips64vr | mips64vrel)
+-          mips_cpu=vr4100
+-          ;;
+-        mipsisa32r2* | mipsisa64r2*)
+-          mips_cpu=`echo $target_cpu | sed -e 's/[a-z]*..r2//' -e 's/el$//'`
+-          ;;
+-        mips64* | mipsisa64* | mipsisa32*)
+-          mips_cpu=`echo $target_cpu | sed -e 's/[a-z]*..//' -e 's/el$//'`
+-          ;;
+-        *)
+-          { { echo "$as_me:$LINENO: error: $target_cpu isn't a supported MIPS CPU name" >&5
+-echo "$as_me: error: $target_cpu isn't a supported MIPS CPU name" >&2;}
+-   { (exit 1); exit 1; }; }
+-          ;;
+-      esac
+-      # See whether it's appropriate to set E_MIPS_ABI_O32 for o32
+-      # binaries.  It's a GNU extension that some OSes don't understand.
+-      # The value only matters on ELF targets.
+-      case ${target} in
+-        *-*-irix*)
+-          use_e_mips_abi_o32=0
+-          ;;
+-        *)
+-          use_e_mips_abi_o32=1
+-          ;;
+-      esac
+-      # Decide whether to generate 32-bit or 64-bit code by default.
+-      # Used to resolve -march=from-abi when an embedded ABI is selected.
+-      case ${target} in
+-        mips64*-*-* | mipsisa64*-*-*)
+-          mips_default_64bit=1
+-          ;;
+-        *)
+-          mips_default_64bit=0
+-          ;;
+-      esac
+-      # Decide which ABI to target by default.
+-      case ${target} in
+-        mips64*-linux* | mips-sgi-irix6*)
+-          mips_default_abi=N32_ABI
+-          ;;
+-        mips*-linux*)
+-          mips_default_abi=O32_ABI
+-          ;;
+-        mips64*-openbsd*)
+-          mips_default_abi=N64_ABI
+-          ;;
+-        *)
+-          mips_default_abi=NO_ABI
+-          ;;
+-      esac
++if test $ac_cv_header_stdc = yes; then
++  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
++  if test "$cross_compiling" = yes; then
++  :
++else
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <ctype.h>
++#include <stdlib.h>
++#if ((' ' & 0x0FF) == 0x020)
++# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
++# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
++#else
++# define ISLOWER(c) \
++                 (('a' <= (c) && (c) <= 'i') \
++                   || ('j' <= (c) && (c) <= 'r') \
++                   || ('s' <= (c) && (c) <= 'z'))
++# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
++#endif
+-cat >>confdefs.h <<_ACEOF
+-#define MIPS_CPU_STRING_DEFAULT "$mips_cpu"
++#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
++int
++main ()
++{
++  int i;
++  for (i = 0; i < 256; i++)
++    if (XOR (islower (i), ISLOWER (i))
++      || toupper (i) != TOUPPER (i))
++      return 2;
++  return 0;
++}
+ _ACEOF
++rm -f conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
++  ac_status=$?
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
++  ac_status=$?
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); }; }; then
++  :
++else
++  echo "$as_me: program exited with status $ac_status" >&5
++echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++( exit $ac_status )
++ac_cv_header_stdc=no
++fi
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++fi
+-cat >>confdefs.h <<_ACEOF
+-#define USE_E_MIPS_ABI_O32 $use_e_mips_abi_o32
+-_ACEOF
++fi
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
++echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
++if test $ac_cv_header_stdc = yes; then
+-cat >>confdefs.h <<_ACEOF
+-#define MIPS_DEFAULT_64BIT $mips_default_64bit
++cat >>confdefs.h <<\_ACEOF
++#define STDC_HEADERS 1
+ _ACEOF
++fi
+-cat >>confdefs.h <<_ACEOF
+-#define MIPS_DEFAULT_ABI $mips_default_abi
+-_ACEOF
++# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+-      ;;
+-    esac
+-    # Do we need the opcodes library?
+-    case ${cpu_type} in
+-      vax | i386 | tic30)
+-      ;;
+-      *)
+-      need_opcodes=yes
+-      case "${enable_shared}" in
+-      yes) shared_opcodes=true ;;
+-      *opcodes*) shared_opcodes=true ;;
+-      *) shared_opcodes=false ;;
+-      esac
+-      ;;
+-    esac
+-    # Any other special object files needed ?
+-    case ${cpu_type} in
+-      bfin)
+-        echo ${extra_objects} | grep -s "bfin-parse.o"
+-        if test $? -ne 0 ; then
+-          extra_objects="$extra_objects bfin-parse.o"
+-        fi
+-        echo ${extra_objects} | grep -s "bfin-lex.o"
+-        if test $? -ne 0 ; then
+-          extra_objects="$extra_objects bfin-lex.o"
+-        fi
+-        ;;
+-      fr30 | ip2k | iq2000 | m32r | openrisc)
+-      using_cgen=yes
+-      ;;
+-      m32c)
+-      using_cgen=yes
+-      ;;
+-      frv)
+-      using_cgen=yes
+-      ;;
+-      m68k)
+-      case ${extra_objects} in
+-      *m68k-parse.o*) ;;
+-      *) extra_objects="$extra_objects m68k-parse.o" ;;
+-      esac
+-      ;;
++for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
++                inttypes.h stdint.h unistd.h
++do
++as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++$ac_includes_default
+-      mips)
+-      echo ${extra_objects} | grep -s "itbl-parse.o"
+-      if test $? -ne 0 ; then
+-        extra_objects="$extra_objects itbl-parse.o"
+-      fi
++#include <$ac_header>
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  eval "$as_ac_Header=yes"
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
+-      echo ${extra_objects} | grep -s "itbl-lex.o"
+-      if test $? -ne 0 ; then
+-        extra_objects="$extra_objects itbl-lex.o"
+-      fi
++      eval "$as_ac_Header=no"
++fi
+-      echo ${extra_objects} | grep -s "itbl-ops.o"
+-      if test $? -ne 0 ; then
+-        extra_objects="$extra_objects itbl-ops.o"
+-      fi
+-      ;;
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
++if test `eval echo '${'$as_ac_Header'}'` = yes; then
++  cat >>confdefs.h <<_ACEOF
++#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
++_ACEOF
+-      mt)
+-        using_cgen=yes
+-      ;;
++fi
+-      i386 | s390 | sparc)
+-      if test $this_target = $target ; then
++done
+-cat >>confdefs.h <<_ACEOF
+-#define DEFAULT_ARCH "${arch}"
++
++{ echo "$as_me:$LINENO: checking whether byte ordering is bigendian" >&5
++echo $ECHO_N "checking whether byte ordering is bigendian... $ECHO_C" >&6; }
++if test "${ac_cv_c_bigendian+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  # See if sys/param.h defines the BYTE_ORDER macro.
++cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
+ _ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <sys/types.h>
++#include <sys/param.h>
+-      fi
+-      ;;
++int
++main ()
++{
++#if  ! (defined BYTE_ORDER && defined BIG_ENDIAN && defined LITTLE_ENDIAN \
++      && BYTE_ORDER && BIG_ENDIAN && LITTLE_ENDIAN)
++ bogus endian macros
++#endif
+-      xstormy16)
+-      using_cgen=yes
+-      ;;
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  # It does; now see whether it defined to BIG_ENDIAN or not.
++cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <sys/types.h>
++#include <sys/param.h>
+-      xc16x)
+-      using_cgen=yes
+-      ;;
++int
++main ()
++{
++#if BYTE_ORDER != BIG_ENDIAN
++ not big endian
++#endif
+-      xtensa)
+-      echo ${extra_objects} | grep -s "xtensa-relax.o"
+-      if test $? -ne 0 ; then
+-        extra_objects="$extra_objects xtensa-relax.o"
+-      fi
+-      ;;
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_c_bigendian=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
+-      *)
+-      ;;
+-    esac
++      ac_cv_c_bigendian=no
++fi
+-    if test $using_cgen = yes ; then
+-      case "x${extra_objects}" in
+-      *cgen.o*) ;;
+-      *) extra_objects="$extra_objects cgen.o" ;;
+-      esac
+-    fi
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
+-# See if we really can support this configuration with the emulation code.
++      # It does not; compile a test program.
++if test "$cross_compiling" = yes; then
++  # try to guess the endianness by grepping values into an object file
++  ac_cv_c_bigendian=unknown
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
++short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
++void _ascii () { char *s = (char *) ascii_mm; s = (char *) ascii_ii; }
++short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
++short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
++void _ebcdic () { char *s = (char *) ebcdic_mm; s = (char *) ebcdic_ii; }
++int
++main ()
++{
++ _ascii (); _ebcdic ();
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
++  ac_cv_c_bigendian=yes
++fi
++if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
++  if test "$ac_cv_c_bigendian" = unknown; then
++    ac_cv_c_bigendian=no
++  else
++    # finding both strings is unlikely to happen, but who knows?
++    ac_cv_c_bigendian=unknown
++  fi
++fi
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
+-    if test $this_target = $target ; then
+-      obj_format=$fmt
+-      te_file=$em
+-    fi
+-# From target name and format, produce a list of supported emulations.
++fi
+-    case ${generic_target}-${fmt} in
+-      mips-*-irix5*-*)        emulation="mipsbelf mipslelf mipself mipsbecoff mipslecoff mipsecoff" ;;
+-      mips*-*-linux*-*) case "$endian" in
+-                      big)    emulation="mipsbelf mipslelf mipself" ;;
+-                      *)      emulation="mipslelf mipsbelf mipself" ;;
+-                      esac ;;
+-      mips-*-lnews*-ecoff) ;;
+-      mips-*-*-ecoff) case "$endian" in
+-                      big)    emulation="mipsbecoff mipslecoff mipsecoff" ;;
+-                      *)      emulation="mipslecoff mipsbecoff mipsecoff" ;;
+-                      esac ;;
+-      mips-*-*-elf)   case "$endian" in
+-                      big)    emulation="mipsbelf mipslelf mipself" ;;
+-                      *)      emulation="mipslelf mipsbelf mipself" ;;
+-                      esac ;;
+-      mips-*-sysv4*MP*-*) emulation="mipsbelf mipslelf mipself mipsbecoff mipslecoff mipsecoff" ;;
+-      # i386-pc-pe-coff != i386-pc-coff.
+-      i386-*-pe-coff) ;;
+-      # Uncommenting the next line will turn on support for i386 AOUT
+-      # for the default linux configuration
+-      # i386-*-linux*-elf) emulation="i386elf i386aout" ;;
+-      #
+-      i386-*-aout)    emulation="i386aout" ;;
+-      i386-*-coff)    emulation="i386coff" ;;
+-      i386-*-elf)     emulation="i386elf" ;;
+-
+-      # Always all formats.  The first stated emulation becomes the default.
+-      cris-*-*aout*)  emulation="crisaout criself" ;;
+-      cris-*-*)               emulation="criself crisaout" ;;
+-    esac
+-
+-    emulations="$emulations $emulation"
+-
+-done
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++else
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++$ac_includes_default
++int
++main ()
++{
+-# Turn on all targets if possible
+-if test ${all_targets} = "yes"; then
+-  case ${target_cpu_type} in
+-  i386)
+-    case ${obj_format} in
+-    aout)
+-      emulations="$emulations i386coff i386elf"
+-      ;;
+-    coff)
+-      emulations="$emulations i386aout i386elf"
+-    ;;
+-    elf)
+-      emulations="$emulations i386aout i386coff"
+-      ;;
+-    esac
+-  ;;
+-  esac
+-fi
++  /* Are we little or big endian?  From Harbison&Steele.  */
++  union
++  {
++    long int l;
++    char c[sizeof (long int)];
++  } u;
++  u.l = 1;
++  return u.c[sizeof (long int) - 1] == 1;
+-# Assign floating point type.  Most processors with FP support
+-# IEEE FP.  On those that don't support FP at all, usually IEEE
+-# is emulated.
+-case ${target_cpu} in
+-  vax | tahoe )       atof=${target_cpu} ;;
+-  pdp11)      atof=vax ;;
+-  *)          atof=ieee ;;
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
+ esac
+-
+-case "${obj_format}" in
+-  "") { { echo "$as_me:$LINENO: error: GAS does not know what format to use for target ${target}" >&5
+-echo "$as_me: error: GAS does not know what format to use for target ${target}" >&2;}
+-   { (exit 1); exit 1; }; } ;;
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
++  ac_status=$?
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
+ esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
++  ac_status=$?
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); }; }; then
++  ac_cv_c_bigendian=no
++else
++  echo "$as_me: program exited with status $ac_status" >&5
++echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
+-# Unfortunately the cpu in cpu-opc.h file isn't always $(TARGET_CPU).
+-cgen_cpu_prefix=""
+-if test $using_cgen = yes ; then
+-  case ${target_cpu} in
+-    *) cgen_cpu_prefix=${target_cpu} ;;
+-  esac
+-
+-
+-cat >>confdefs.h <<\_ACEOF
+-#define USING_CGEN 1
+-_ACEOF
+-
++( exit $ac_status )
++ac_cv_c_bigendian=yes
++fi
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
+-if test ! -r ${srcdir}/config/tc-${target_cpu_type}.c; then
+-  { { echo "$as_me:$LINENO: error: GAS does not support target CPU ${target_cpu_type}" >&5
+-echo "$as_me: error: GAS does not support target CPU ${target_cpu_type}" >&2;}
+-   { (exit 1); exit 1; }; }
+ fi
+-if test ! -r ${srcdir}/config/obj-${obj_format}.c; then
+-  { { echo "$as_me:$LINENO: error: GAS does not have support for object file format ${obj_format}" >&5
+-echo "$as_me: error: GAS does not have support for object file format ${obj_format}" >&2;}
+-   { (exit 1); exit 1; }; }
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
++{ echo "$as_me:$LINENO: result: $ac_cv_c_bigendian" >&5
++echo "${ECHO_T}$ac_cv_c_bigendian" >&6; }
++case $ac_cv_c_bigendian in
++  yes)
+-# Some COFF configurations want these random other flags set.
+-case ${obj_format} in
+-  coff)
+-    case ${target_cpu_type} in
+-      i386)
+-cat >>confdefs.h <<\_ACEOF
+-#define I386COFF 1
+-_ACEOF
+- ;;
+-      m68k)
+-cat >>confdefs.h <<\_ACEOF
+-#define M68KCOFF 1
+-_ACEOF
+- ;;
+-      m88k)
+ cat >>confdefs.h <<\_ACEOF
+-#define M88KCOFF 1
++#define WORDS_BIGENDIAN 1
+ _ACEOF
+  ;;
+-    esac
+-    ;;
++  no)
++     ;;
++  *)
++    { { echo "$as_me:$LINENO: error: unknown endianness
++presetting ac_cv_c_bigendian=no (or yes) will help" >&5
++echo "$as_me: error: unknown endianness
++presetting ac_cv_c_bigendian=no (or yes) will help" >&2;}
++   { (exit 1); exit 1; }; } ;;
+ esac
+-# Getting this done right is going to be a bitch.  Each configuration specified
+-# with --enable-targets=... should be checked for environment, format, cpu
+-# setting.
+-#
+-# For each configuration, the necessary object file support code must be linked
+-# in.  This might be only one, it might be up to four.  The necessary emulation
+-# code needs to be provided, too.
+-#
+-# And then there's "--enable-targets=all"....
+-#
+-# For now, just always do it for MIPS ELF or ECOFF configurations.  Sigh.
+-formats="${obj_format}"
+-emfiles=""
+-EMULATIONS=""
+-_gas_uniq_list="$emulations"
+-_gas_uniq_newlist=""
+-for _gas_uniq_i in _gas_uniq_dummy $_gas_uniq_list ; do
+-  case $_gas_uniq_i in
+-  _gas_uniq_dummy) ;;
+-  *) case " $_gas_uniq_newlist " in
+-       *" $_gas_uniq_i "*) ;;
+-       *) _gas_uniq_newlist="$_gas_uniq_newlist $_gas_uniq_i" ;;
+-     esac ;;
+-  esac
+-done
+-emulations=$_gas_uniq_newlist
++te_file=generic
+-for em in . $emulations ; do
+-  case $em in
+-    .)        continue ;;
+-    mipsbelf | mipslelf | mipself)
+-      fmt=elf   file=mipself ;;
+-    mipsbecoff | mipslecoff | mipsecoff)
+-      fmt=ecoff file=mipsecoff ;;
+-    *coff)
+-      fmt=coff  file=$em ;;
+-    *aout)
+-      fmt=aout file=$em ;;
+-    *elf)
+-      fmt=elf file=$em ;;
+-  esac
+-  formats="$formats $fmt"
+-  emfiles="$emfiles e-$file.o"
+-  EMULATIONS="$EMULATIONS &$em,"
+-done
+-_gas_uniq_list="$formats"
+-_gas_uniq_newlist=""
+-for _gas_uniq_i in _gas_uniq_dummy $_gas_uniq_list ; do
+-  case $_gas_uniq_i in
+-  _gas_uniq_dummy) ;;
+-  *) case " $_gas_uniq_newlist " in
+-       *" $_gas_uniq_i "*) ;;
+-       *) _gas_uniq_newlist="$_gas_uniq_newlist $_gas_uniq_i" ;;
+-     esac ;;
+-  esac
+-done
+-formats=$_gas_uniq_newlist
++# Makefile target for installing gas in $(tooldir)/bin.
++install_tooldir=install-exec-tooldir
+-_gas_uniq_list="$emfiles"
++canon_targets=""
++all_targets=no
++if test -n "$enable_targets" ; then
++  for t in `echo $enable_targets | sed 's/,/ /g'`; do
++    if test $t = "all"; then
++      all_targets=yes
++      continue
++    fi
++    result=`$ac_config_sub $t 2>/dev/null`
++    if test -n "$result" ; then
++      canon_targets="$canon_targets $result"
++#    else
++#      # Permit "all", etc.  We don't support it yet though.
++#      canon_targets="$canon_targets $t"
++    fi
++  done
++  _gas_uniq_list="$canon_targets"
+ _gas_uniq_newlist=""
+ for _gas_uniq_i in _gas_uniq_dummy $_gas_uniq_list ; do
+   case $_gas_uniq_i in
+@@ -5034,883 +5702,871 @@ for _gas_uniq_i in _gas_uniq_dummy $_gas
+      esac ;;
+   esac
+ done
+-emfiles=$_gas_uniq_newlist
++canon_targets=$_gas_uniq_newlist
+-if test `set . $formats ; shift ; echo $#` -gt 1 ; then
+-  for fmt in $formats ; do
+-    case $fmt in
+-      aout)
+-cat >>confdefs.h <<\_ACEOF
+-#define OBJ_MAYBE_AOUT 1
++fi
++
++emulations=""
++
++for this_target in $target $canon_targets ; do
++
++    targ=${this_target}
++    . ${srcdir}/configure.tgt
++
++    case ${target_cpu} in
++      crisv32)
++
++cat >>confdefs.h <<_ACEOF
++#define DEFAULT_CRIS_ARCH $arch
+ _ACEOF
+-   ;;
+-      bout)
++
++      ;;
++    esac
++
++    if test ${this_target} = $target ; then
++      target_cpu_type=${cpu_type}
++    elif test ${target_cpu_type} != ${cpu_type} ; then
++      continue
++    fi
++
++    generic_target=${cpu_type}-${target_vendor}-${target_os}
++    case ${generic_target} in
++      i386-*-sco3.2v5*)
++      if test ${this_target} = $target; then
++
+ cat >>confdefs.h <<\_ACEOF
+-#define OBJ_MAYBE_BOUT 1
++#define SCO_ELF 1
+ _ACEOF
+-   ;;
+-      coff)
++
++      fi
++      ;;
++
++      i386-*-msdosdjgpp* \
++      | i386-*-go32* \
++      | i386-go32-rtems*)
++
+ cat >>confdefs.h <<\_ACEOF
+-#define OBJ_MAYBE_COFF 1
++#define STRICTCOFF 1
+ _ACEOF
+-    ;;
+-      ecoff)
+-cat >>confdefs.h <<\_ACEOF
+-#define OBJ_MAYBE_ECOFF 1
+-_ACEOF
+-   ;;
+-      elf)
+-cat >>confdefs.h <<\_ACEOF
+-#define OBJ_MAYBE_ELF 1
+-_ACEOF
+-     ;;
+-      generic)
+-cat >>confdefs.h <<\_ACEOF
+-#define OBJ_MAYBE_GENERIC 1
+-_ACEOF
+- ;;
+-      ieee)
+-cat >>confdefs.h <<\_ACEOF
+-#define OBJ_MAYBE_IEEE 1
+-_ACEOF
+-    ;;
+-      som)
+-cat >>confdefs.h <<\_ACEOF
+-#define OBJ_MAYBE_SOM 1
+-_ACEOF
+-     ;;
+-    esac
+-    extra_objects="$extra_objects obj-$fmt.o"
+-  done
+-  obj_format=multi
+-fi
+-if test `set . $emfiles ; shift ; echo $#` -gt 0 ; then
+-  DEFAULT_EMULATION=`set . $emulations ; echo $2`
+-  # e-mips* has more than one emulation per file, e-i386* has just one at the
+-  # moment.  If only one emulation is specified, then don't define
+-  # USE_EMULATIONS or include any of the e-files as they will only be bloat.
+-  case "${obj_format}${emfiles}" in
+-    multi* | *mips*)
+-      extra_objects="$extra_objects $emfiles"
+-cat >>confdefs.h <<\_ACEOF
+-#define USE_EMULATIONS 1
+-_ACEOF
+- ;;
+-  esac
+-fi
++      ;;
++      i860-*-*)
++      { echo "$as_me:$LINENO: WARNING: GAS support for ${generic_target} is preliminary and a work in progress" >&5
++echo "$as_me: WARNING: GAS support for ${generic_target} is preliminary and a work in progress" >&2;}
++      ;;
+-cat >>confdefs.h <<_ACEOF
+-#define EMULATIONS $EMULATIONS
+-_ACEOF
++      mips-sony-bsd*)
++      ;;
++      mips-*-bsd*)
++      { { echo "$as_me:$LINENO: error: Unknown vendor for mips-bsd configuration." >&5
++echo "$as_me: error: Unknown vendor for mips-bsd configuration." >&2;}
++   { (exit 1); exit 1; }; }
++      ;;
++      ppc-*-aix5.*)
+-cat >>confdefs.h <<_ACEOF
+-#define DEFAULT_EMULATION "$DEFAULT_EMULATION"
++cat >>confdefs.h <<\_ACEOF
++#define AIX_WEAK_SUPPORT 1
+ _ACEOF
++      ;;
++      ppc-*-linux-*)
++      case "$endian" in
++        big)  ;;
++        *)    { { echo "$as_me:$LINENO: error: GNU/Linux must be configured big endian" >&5
++echo "$as_me: error: GNU/Linux must be configured big endian" >&2;}
++   { (exit 1); exit 1; }; } ;;
++      esac
++      ;;
++      ppc-*-solaris*)
++      if test ${this_target} = $target; then
+-reject_dev_configs=yes
++cat >>confdefs.h <<\_ACEOF
++#define TARGET_SOLARIS_COMMENT 1
++_ACEOF
+-case ${reject_dev_configs}-${dev} in
+-  yes-yes) # Oops.
+-    { { echo "$as_me:$LINENO: error: GAS does not support the ${generic_target} configuration." >&5
+-echo "$as_me: error: GAS does not support the ${generic_target} configuration." >&2;}
++      fi
++      if test x${endian} = xbig; then
++        { { echo "$as_me:$LINENO: error: Solaris must be configured little endian" >&5
++echo "$as_me: error: Solaris must be configured little endian" >&2;}
+    { (exit 1); exit 1; }; }
+-    ;;
+-esac
+-
+-
+-
+-
+-
+-
+-
+-# do we need the opcodes library?
+-case "${need_opcodes}" in
+-yes)
+-  OPCODES_LIB=../opcodes/libopcodes.la
+-  ;;
+-esac
++      fi
++      ;;
+-BFDLIB=../bfd/libbfd.la
+-BFDVER_H=../bfd/bfdver.h
+-ALL_OBJ_DEPS="$ALL_OBJ_DEPS"' ../bfd/bfd.h $(INCDIR)/symcat.h'
++      sh*-*-symbianelf*)
++cat >>confdefs.h <<\_ACEOF
++#define TARGET_SYMBIAN 1
++_ACEOF
++      ;;
++    esac
++    if test ${this_target} = $target ; then
++      endian_def=
++      if test x${endian} = xbig; then
++      endian_def=1
++      elif test x${endian} = xlittle; then
++      endian_def=0
++      fi
++      if test x${endian_def} != x; then
++cat >>confdefs.h <<_ACEOF
++#define TARGET_BYTES_BIG_ENDIAN $endian_def
++_ACEOF
++      fi
++    fi
++# Other random stuff.
++    case ${cpu_type} in
++      mips)
++      # Set mips_cpu to the name of the default CPU.
++      case ${target_cpu} in
++        mips | mipsbe | mipseb | mipsle | mipsel | mips64 | mips64el)
++          mips_cpu=from-abi
++          ;;
++        mipsisa32 | mipsisa32el)
++          mips_cpu=mips32
++          ;;
++        mipsisa32r2 | mipsisa32r2el)
++          mips_cpu=mips32r2
++          ;;
++        mipsisa64 | mipsisa64el)
++          mips_cpu=mips64
++          ;;
++        mipsisa64r2 | mipsisa64r2el)
++          mips_cpu=mips64r2
++          ;;
++        mipstx39 | mipstx39el)
++          mips_cpu=r3900
++          ;;
++        mips64vr | mips64vrel)
++          mips_cpu=vr4100
++          ;;
++        mipsisa32r2* | mipsisa64r2*)
++          mips_cpu=`echo $target_cpu | sed -e 's/[a-z]*..r2//' -e 's/el$//'`
++          ;;
++        mips64* | mipsisa64* | mipsisa32*)
++          mips_cpu=`echo $target_cpu | sed -e 's/[a-z]*..//' -e 's/el$//'`
++          ;;
++        *)
++          { { echo "$as_me:$LINENO: error: $target_cpu isn't a supported MIPS CPU name" >&5
++echo "$as_me: error: $target_cpu isn't a supported MIPS CPU name" >&2;}
++   { (exit 1); exit 1; }; }
++          ;;
++      esac
++      # See whether it's appropriate to set E_MIPS_ABI_O32 for o32
++      # binaries.  It's a GNU extension that some OSes don't understand.
++      # The value only matters on ELF targets.
++      case ${target} in
++        *-*-irix*)
++          use_e_mips_abi_o32=0
++          ;;
++        *)
++          use_e_mips_abi_o32=1
++          ;;
++      esac
++      # Decide whether to generate 32-bit or 64-bit code by default.
++      # Used to resolve -march=from-abi when an embedded ABI is selected.
++      case ${target} in
++        mips64*-*-* | mipsisa64*-*-*)
++          mips_default_64bit=1
++          ;;
++        *)
++          mips_default_64bit=0
++          ;;
++      esac
++      # Decide which ABI to target by default.
++      case ${target} in
++        mips64*-linux* | mips-sgi-irix6*)
++          mips_default_abi=N32_ABI
++          ;;
++        mips*-linux*)
++          mips_default_abi=O32_ABI
++          ;;
++        mips64*-openbsd*)
++          mips_default_abi=N64_ABI
++          ;;
++        *)
++          mips_default_abi=NO_ABI
++          ;;
++      esac
+ cat >>confdefs.h <<_ACEOF
+-#define TARGET_ALIAS "${target_alias}"
++#define MIPS_CPU_STRING_DEFAULT "$mips_cpu"
+ _ACEOF
+ cat >>confdefs.h <<_ACEOF
+-#define TARGET_CANONICAL "${target}"
++#define USE_E_MIPS_ABI_O32 $use_e_mips_abi_o32
+ _ACEOF
+ cat >>confdefs.h <<_ACEOF
+-#define TARGET_CPU "${target_cpu}"
++#define MIPS_DEFAULT_64BIT $mips_default_64bit
+ _ACEOF
+ cat >>confdefs.h <<_ACEOF
+-#define TARGET_VENDOR "${target_vendor}"
++#define MIPS_DEFAULT_ABI $mips_default_abi
+ _ACEOF
++      ;;
++    esac
+-cat >>confdefs.h <<_ACEOF
+-#define TARGET_OS "${target_os}"
+-_ACEOF
++    # Do we need the opcodes library?
++    case ${cpu_type} in
++      vax | i386 | tic30)
++      ;;
++      *)
++      need_opcodes=yes
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+-set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$CC"; then
+-  ac_cv_prog_CC="$CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
++      case "${enable_shared}" in
++      yes) shared_opcodes=true ;;
++      *opcodes*) shared_opcodes=true ;;
++      *) shared_opcodes=false ;;
++      esac
++      ;;
++    esac
+-fi
+-fi
+-CC=$ac_cv_prog_CC
+-if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
++    # Any other special object files needed ?
++    case ${cpu_type} in
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "gcc", so it can be a program name with args.
+-set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="gcc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
++      bfin)
++        echo ${extra_objects} | grep -s "bfin-parse.o"
++        if test $? -ne 0 ; then
++          extra_objects="$extra_objects bfin-parse.o"
++        fi
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
++        echo ${extra_objects} | grep -s "bfin-lex.o"
++        if test $? -ne 0 ; then
++          extra_objects="$extra_objects bfin-lex.o"
++        fi
++        ;;
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++      fr30 | ip2k | iq2000 | m32r | openrisc)
++      using_cgen=yes
++      ;;
+-if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+-set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$CC"; then
+-  ac_cv_prog_CC="$CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_CC="${ac_tool_prefix}cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
++      m32c)
++      using_cgen=yes
++      ;;
++      frv)
++      using_cgen=yes
++      ;;
++      m68k)
++      case ${extra_objects} in
++      *m68k-parse.o*) ;;
++      *) extra_objects="$extra_objects m68k-parse.o" ;;
++      esac
++      ;;
+-fi
+-fi
+-CC=$ac_cv_prog_CC
+-if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
++      mips)
++      echo ${extra_objects} | grep -s "itbl-parse.o"
++      if test $? -ne 0 ; then
++        extra_objects="$extra_objects itbl-parse.o"
++      fi
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
++      echo ${extra_objects} | grep -s "itbl-lex.o"
++      if test $? -ne 0 ; then
++        extra_objects="$extra_objects itbl-lex.o"
++      fi
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
++      echo ${extra_objects} | grep -s "itbl-ops.o"
++      if test $? -ne 0 ; then
++        extra_objects="$extra_objects itbl-ops.o"
++      fi
++      ;;
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++      mt)
++        using_cgen=yes
++      ;;
++
++      i386 | s390 | sparc)
++      if test $this_target = $target ; then
++
++cat >>confdefs.h <<_ACEOF
++#define DEFAULT_ARCH "${arch}"
++_ACEOF
++
++      fi
++      ;;
++
++      xstormy16)
++      using_cgen=yes
++      ;;
++
++      xc16x)
++      using_cgen=yes
++      ;;
++
++      xtensa)
++      echo ${extra_objects} | grep -s "xtensa-relax.o"
++      if test $? -ne 0 ; then
++        extra_objects="$extra_objects xtensa-relax.o"
++      fi
++      ;;
++
++      *)
++      ;;
++    esac
++
++    if test $using_cgen = yes ; then
++      case "x${extra_objects}" in
++      *cgen.o*) ;;
++      *) extra_objects="$extra_objects cgen.o" ;;
++      esac
++    fi
++
++# See if we really can support this configuration with the emulation code.
++
++    if test $this_target = $target ; then
++      obj_format=$fmt
++      te_file=$em
++    fi
++
++# From target name and format, produce a list of supported emulations.
++
++    case ${generic_target}-${fmt} in
++      mips-*-irix5*-*)        emulation="mipsbelf mipslelf mipself mipsbecoff mipslecoff mipsecoff" ;;
++      mips*-*-linux*-*) case "$endian" in
++                      big)    emulation="mipsbelf mipslelf mipself" ;;
++                      *)      emulation="mipslelf mipsbelf mipself" ;;
++                      esac ;;
++      mips-*-lnews*-ecoff) ;;
++      mips-*-*-ecoff) case "$endian" in
++                      big)    emulation="mipsbecoff mipslecoff mipsecoff" ;;
++                      *)      emulation="mipslecoff mipsbecoff mipsecoff" ;;
++                      esac ;;
++      mips-*-*-elf)   case "$endian" in
++                      big)    emulation="mipsbelf mipslelf mipself" ;;
++                      *)      emulation="mipslelf mipsbelf mipself" ;;
++                      esac ;;
++      mips-*-sysv4*MP*-*) emulation="mipsbelf mipslelf mipself mipsbecoff mipslecoff mipsecoff" ;;
++      # i386-pc-pe-coff != i386-pc-coff.
++      i386-*-pe-coff) ;;
++      # Uncommenting the next line will turn on support for i386 AOUT
++      # for the default linux configuration
++      # i386-*-linux*-elf) emulation="i386elf i386aout" ;;
++      #
++      i386-*-aout)    emulation="i386aout" ;;
++      i386-*-coff)    emulation="i386coff" ;;
++      i386-*-elf)     emulation="i386elf" ;;
++
++      # Always all formats.  The first stated emulation becomes the default.
++      cris-*-*aout*)  emulation="crisaout criself" ;;
++      cris-*-*)               emulation="criself crisaout" ;;
++    esac
++
++    emulations="$emulations $emulation"
+-fi
+-if test -z "$CC"; then
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$CC"; then
+-  ac_cv_prog_CC="$CC" # Let the user override the test.
+-else
+-  ac_prog_rejected=no
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+-       ac_prog_rejected=yes
+-       continue
+-     fi
+-    ac_cv_prog_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+ done
+-if test $ac_prog_rejected = yes; then
+-  # We found a bogon in the path, so make sure we never use it.
+-  set dummy $ac_cv_prog_CC
+-  shift
+-  if test $# != 0; then
+-    # We chose a different compiler from the bogus one.
+-    # However, it has the same basename, so the bogon will be chosen
+-    # first if we set CC to just the basename; use the full file name.
+-    shift
+-    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+-  fi
+-fi
++# Turn on all targets if possible
++if test ${all_targets} = "yes"; then
++  case ${target_cpu_type} in
++  i386)
++    case ${obj_format} in
++    aout)
++      emulations="$emulations i386coff i386elf"
++      ;;
++    coff)
++      emulations="$emulations i386aout i386elf"
++    ;;
++    elf)
++      emulations="$emulations i386aout i386coff"
++      ;;
++    esac
++  ;;
++  esac
+ fi
++
++# Assign floating point type.  Most processors with FP support
++# IEEE FP.  On those that don't support FP at all, usually IEEE
++# is emulated.
++case ${target_cpu} in
++  vax | tahoe )       atof=${target_cpu} ;;
++  pdp11)      atof=vax ;;
++  *)          atof=ieee ;;
++esac
++
++case "${obj_format}" in
++  "") { { echo "$as_me:$LINENO: error: GAS does not know what format to use for target ${target}" >&5
++echo "$as_me: error: GAS does not know what format to use for target ${target}" >&2;}
++   { (exit 1); exit 1; }; } ;;
++esac
++
++# Unfortunately the cpu in cpu-opc.h file isn't always $(TARGET_CPU).
++cgen_cpu_prefix=""
++if test $using_cgen = yes ; then
++  case ${target_cpu} in
++    *) cgen_cpu_prefix=${target_cpu} ;;
++  esac
++
++
++cat >>confdefs.h <<\_ACEOF
++#define USING_CGEN 1
++_ACEOF
++
+ fi
+-CC=$ac_cv_prog_CC
+-if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++
++
++if test ! -r ${srcdir}/config/tc-${target_cpu_type}.c; then
++  { { echo "$as_me:$LINENO: error: GAS does not support target CPU ${target_cpu_type}" >&5
++echo "$as_me: error: GAS does not support target CPU ${target_cpu_type}" >&2;}
++   { (exit 1); exit 1; }; }
+ fi
++if test ! -r ${srcdir}/config/obj-${obj_format}.c; then
++  { { echo "$as_me:$LINENO: error: GAS does not have support for object file format ${obj_format}" >&5
++echo "$as_me: error: GAS does not have support for object file format ${obj_format}" >&2;}
++   { (exit 1); exit 1; }; }
+ fi
+-if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
+-  do
+-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$CC"; then
+-  ac_cv_prog_CC="$CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
++
++# Some COFF configurations want these random other flags set.
++case ${obj_format} in
++  coff)
++    case ${target_cpu_type} in
++      i386)
++cat >>confdefs.h <<\_ACEOF
++#define I386COFF 1
++_ACEOF
++ ;;
++      m68k)
++cat >>confdefs.h <<\_ACEOF
++#define M68KCOFF 1
++_ACEOF
++ ;;
++      m88k)
++cat >>confdefs.h <<\_ACEOF
++#define M88KCOFF 1
++_ACEOF
++ ;;
++    esac
++    ;;
++esac
++
++# Getting this done right is going to be a bitch.  Each configuration specified
++# with --enable-targets=... should be checked for environment, format, cpu
++# setting.
++#
++# For each configuration, the necessary object file support code must be linked
++# in.  This might be only one, it might be up to four.  The necessary emulation
++# code needs to be provided, too.
++#
++# And then there's "--enable-targets=all"....
++#
++# For now, just always do it for MIPS ELF or ECOFF configurations.  Sigh.
++
++formats="${obj_format}"
++emfiles=""
++EMULATIONS=""
++_gas_uniq_list="$emulations"
++_gas_uniq_newlist=""
++for _gas_uniq_i in _gas_uniq_dummy $_gas_uniq_list ; do
++  case $_gas_uniq_i in
++  _gas_uniq_dummy) ;;
++  *) case " $_gas_uniq_newlist " in
++       *" $_gas_uniq_i "*) ;;
++       *) _gas_uniq_newlist="$_gas_uniq_newlist $_gas_uniq_i" ;;
++     esac ;;
++  esac
+ done
++emulations=$_gas_uniq_newlist
++
++for em in . $emulations ; do
++  case $em in
++    .)        continue ;;
++    mipsbelf | mipslelf | mipself)
++      fmt=elf   file=mipself ;;
++    mipsbecoff | mipslecoff | mipsecoff)
++      fmt=ecoff file=mipsecoff ;;
++    *coff)
++      fmt=coff  file=$em ;;
++    *aout)
++      fmt=aout file=$em ;;
++    *elf)
++      fmt=elf file=$em ;;
++  esac
++  formats="$formats $fmt"
++  emfiles="$emfiles e-$file.o"
++  EMULATIONS="$EMULATIONS &$em,"
+ done
++_gas_uniq_list="$formats"
++_gas_uniq_newlist=""
++for _gas_uniq_i in _gas_uniq_dummy $_gas_uniq_list ; do
++  case $_gas_uniq_i in
++  _gas_uniq_dummy) ;;
++  *) case " $_gas_uniq_newlist " in
++       *" $_gas_uniq_i "*) ;;
++       *) _gas_uniq_newlist="$_gas_uniq_newlist $_gas_uniq_i" ;;
++     esac ;;
++  esac
++done
++formats=$_gas_uniq_newlist
++_gas_uniq_list="$emfiles"
++_gas_uniq_newlist=""
++for _gas_uniq_i in _gas_uniq_dummy $_gas_uniq_list ; do
++  case $_gas_uniq_i in
++  _gas_uniq_dummy) ;;
++  *) case " $_gas_uniq_newlist " in
++       *" $_gas_uniq_i "*) ;;
++       *) _gas_uniq_newlist="$_gas_uniq_newlist $_gas_uniq_i" ;;
++     esac ;;
++  esac
++done
++emfiles=$_gas_uniq_newlist
++
++if test `set . $formats ; shift ; echo $#` -gt 1 ; then
++  for fmt in $formats ; do
++    case $fmt in
++      aout)
++cat >>confdefs.h <<\_ACEOF
++#define OBJ_MAYBE_AOUT 1
++_ACEOF
++   ;;
++      bout)
++cat >>confdefs.h <<\_ACEOF
++#define OBJ_MAYBE_BOUT 1
++_ACEOF
++   ;;
++      coff)
++cat >>confdefs.h <<\_ACEOF
++#define OBJ_MAYBE_COFF 1
++_ACEOF
++    ;;
++      ecoff)
++cat >>confdefs.h <<\_ACEOF
++#define OBJ_MAYBE_ECOFF 1
++_ACEOF
++   ;;
++      elf)
++cat >>confdefs.h <<\_ACEOF
++#define OBJ_MAYBE_ELF 1
++_ACEOF
++     ;;
++      generic)
++cat >>confdefs.h <<\_ACEOF
++#define OBJ_MAYBE_GENERIC 1
++_ACEOF
++ ;;
++      ieee)
++cat >>confdefs.h <<\_ACEOF
++#define OBJ_MAYBE_IEEE 1
++_ACEOF
++    ;;
++      som)
++cat >>confdefs.h <<\_ACEOF
++#define OBJ_MAYBE_SOM 1
++_ACEOF
++     ;;
++    esac
++    extra_objects="$extra_objects obj-$fmt.o"
++  done
++  obj_format=multi
+ fi
+-fi
+-CC=$ac_cv_prog_CC
+-if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++if test `set . $emfiles ; shift ; echo $#` -gt 0 ; then
++  DEFAULT_EMULATION=`set . $emulations ; echo $2`
++  # e-mips* has more than one emulation per file, e-i386* has just one at the
++  # moment.  If only one emulation is specified, then don't define
++  # USE_EMULATIONS or include any of the e-files as they will only be bloat.
++  case "${obj_format}${emfiles}" in
++    multi* | *mips*)
++      extra_objects="$extra_objects $emfiles"
++
++cat >>confdefs.h <<\_ACEOF
++#define USE_EMULATIONS 1
++_ACEOF
++ ;;
++  esac
+ fi
+-    test -n "$CC" && break
+-  done
+-fi
+-if test -z "$CC"; then
+-  ac_ct_CC=$CC
+-  for ac_prog in cl
+-do
+-  # Extract the first word of "$ac_prog", so it can be a program name with args.
+-set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="$ac_prog"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
++cat >>confdefs.h <<_ACEOF
++#define EMULATIONS $EMULATIONS
++_ACEOF
+-  test -n "$ac_ct_CC" && break
+-done
+-  CC=$ac_ct_CC
+-fi
++cat >>confdefs.h <<_ACEOF
++#define DEFAULT_EMULATION "$DEFAULT_EMULATION"
++_ACEOF
+-fi
++reject_dev_configs=yes
+-test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
+-See \`config.log' for more details." >&5
+-echo "$as_me: error: no acceptable C compiler found in \$PATH
+-See \`config.log' for more details." >&2;}
++case ${reject_dev_configs}-${dev} in
++  yes-yes) # Oops.
++    { { echo "$as_me:$LINENO: error: GAS does not support the ${generic_target} configuration." >&5
++echo "$as_me: error: GAS does not support the ${generic_target} configuration." >&2;}
+    { (exit 1); exit 1; }; }
++    ;;
++esac
+-# Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
+-ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
+-if test "${ac_cv_c_compiler_gnu+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-int
+-main ()
+-{
+-#ifndef __GNUC__
+-       choke me
+-#endif
+-  ;
+-  return 0;
+-}
++
++
++
++# do we need the opcodes library?
++case "${need_opcodes}" in
++yes)
++  OPCODES_LIB=../opcodes/libopcodes.la
++  ;;
++esac
++
++BFDLIB=../bfd/libbfd.la
++BFDVER_H=../bfd/bfdver.h
++ALL_OBJ_DEPS="$ALL_OBJ_DEPS"' ../bfd/bfd.h $(INCDIR)/symcat.h'
++
++
++
++
++
++
++
++
++cat >>confdefs.h <<_ACEOF
++#define TARGET_ALIAS "${target_alias}"
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_compiler_gnu=yes
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-ac_cv_c_compiler_gnu=$ac_compiler_gnu
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
+-GCC=`test $ac_compiler_gnu = yes && echo yes`
+-ac_test_CFLAGS=${CFLAGS+set}
+-ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_g+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
++cat >>confdefs.h <<_ACEOF
++#define TARGET_CANONICAL "${target}"
+ _ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-int
+-main ()
+-{
+-  ;
+-  return 0;
+-}
++cat >>confdefs.h <<_ACEOF
++#define TARGET_CPU "${target_cpu}"
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_g=yes
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
+-if test "$ac_test_CFLAGS" = set; then
+-  CFLAGS=$ac_save_CFLAGS
+-elif test $ac_cv_prog_cc_g = yes; then
+-  if test "$GCC" = yes; then
+-    CFLAGS="-g -O2"
+-  else
+-    CFLAGS="-g"
+-  fi
+-else
+-  if test "$GCC" = yes; then
+-    CFLAGS="-O2"
+-  else
+-    CFLAGS=
+-  fi
+-fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_cv_prog_cc_stdc=no
+-ac_save_CC=$CC
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
++
++cat >>confdefs.h <<_ACEOF
++#define TARGET_VENDOR "${target_vendor}"
+ _ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <stdarg.h>
+-#include <stdio.h>
+-#include <sys/types.h>
+-#include <sys/stat.h>
+-/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+-struct buf { int x; };
+-FILE * (*rcsopen) (struct buf *, struct stat *, int);
+-static char *e (p, i)
+-     char **p;
+-     int i;
+-{
+-  return p[i];
+-}
+-static char *f (char * (*g) (char **, int), char **p, ...)
+-{
+-  char *s;
+-  va_list v;
+-  va_start (v,p);
+-  s = g (p, va_arg (v,int));
+-  va_end (v);
+-  return s;
+-}
+-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+-   function prototypes and stuff, but not '\xHH' hex character constants.
+-   These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
+-   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+-   array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
+-int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+-int test (int i, double x);
+-struct s1 {int (*f) (int a);};
+-struct s2 {int (*f) (double a);};
+-int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+-int argc;
+-char **argv;
+-int
+-main ()
+-{
+-return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+-  ;
+-  return 0;
+-}
++cat >>confdefs.h <<_ACEOF
++#define TARGET_OS "${target_os}"
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+-do
+-  CC="$ac_save_CC $ac_arg"
+-  rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++
++
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
++if test -n "$ac_tool_prefix"; then
++  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
++set dummy ${ac_tool_prefix}gcc; ac_word=$2
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_CC+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++  if test -n "$CC"; then
++  ac_cv_prog_CC="$CC" # Let the user override the test.
++else
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_exec_ext in '' $ac_executable_extensions; do
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    ac_cv_prog_CC="${ac_tool_prefix}gcc"
++    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
++    break 2
++  fi
++done
++done
++IFS=$as_save_IFS
++
++fi
++fi
++CC=$ac_cv_prog_CC
++if test -n "$CC"; then
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
++else
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
++fi
++
+ fi
+-rm -f conftest.err conftest.$ac_objext
++if test -z "$ac_cv_prog_CC"; then
++  ac_ct_CC=$CC
++  # Extract the first word of "gcc", so it can be a program name with args.
++set dummy gcc; ac_word=$2
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  if test -n "$ac_ct_CC"; then
++  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
++else
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_exec_ext in '' $ac_executable_extensions; do
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    ac_cv_prog_ac_ct_CC="gcc"
++    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
++    break 2
++  fi
+ done
+-rm -f conftest.$ac_ext conftest.$ac_objext
+-CC=$ac_save_CC
++done
++IFS=$as_save_IFS
+ fi
++fi
++ac_ct_CC=$ac_cv_prog_ac_ct_CC
++if test -n "$ac_ct_CC"; then
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
++else
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
++fi
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
+-  *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
+ esac
++    CC=$ac_ct_CC
++  fi
++else
++  CC="$ac_cv_prog_CC"
++fi
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
+-cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
++if test -z "$CC"; then
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++set dummy ${ac_tool_prefix}cc; ac_word=$2
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_CC+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++  if test -n "$CC"; then
++  ac_cv_prog_CC="$CC" # Let the user override the test.
++else
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_exec_ext in '' $ac_executable_extensions; do
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    ac_cv_prog_CC="${ac_tool_prefix}cc"
++    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
++    break 2
++  fi
++done
++done
++IFS=$as_save_IFS
+-continue
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
++fi
++CC=$ac_cv_prog_CC
++if test -n "$CC"; then
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
++fi
++
++  fi
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++if test -z "$CC"; then
++  # Extract the first word of "cc", so it can be a program name with args.
++set dummy cc; ac_word=$2
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_CC+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  if test -n "$CC"; then
++  ac_cv_prog_CC="$CC" # Let the user override the test.
++else
++  ac_prog_rejected=no
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_exec_ext in '' $ac_executable_extensions; do
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
++       ac_prog_rejected=yes
++       continue
++     fi
++    ac_cv_prog_CC="cc"
++    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
++    break 2
++  fi
+ done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
+-fi
++done
++IFS=$as_save_IFS
++if test $ac_prog_rejected = yes; then
++  # We found a bogon in the path, so make sure we never use it.
++  set dummy $ac_cv_prog_CC
++  shift
++  if test $# != 0; then
++    # We chose a different compiler from the bogus one.
++    # However, it has the same basename, so the bogon will be chosen
++    # first if we set CC to just the basename; use the full file name.
++    shift
++    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
++  fi
++fi
++fi
++fi
++CC=$ac_cv_prog_CC
++if test -n "$CC"; then
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-for ac_prog in 'bison -y' byacc
+-do
+-  # Extract the first word of "$ac_prog", so it can be a program name with args.
+-set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_YACC+set}" = set; then
++fi
++if test -z "$CC"; then
++  if test -n "$ac_tool_prefix"; then
++  for ac_prog in cl.exe
++  do
++    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
++set dummy $ac_tool_prefix$ac_prog; ac_word=$2
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if test -n "$YACC"; then
+-  ac_cv_prog_YACC="$YACC" # Let the user override the test.
++  if test -n "$CC"; then
++  ac_cv_prog_CC="$CC" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+@@ -5918,40 +6574,43 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_YACC="$ac_prog"
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+-YACC=$ac_cv_prog_YACC
+-if test -n "$YACC"; then
+-  echo "$as_me:$LINENO: result: $YACC" >&5
+-echo "${ECHO_T}$YACC" >&6
++CC=$ac_cv_prog_CC
++if test -n "$CC"; then
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  test -n "$YACC" && break
+-done
+-test -n "$YACC" || YACC="yacc"
+-for ac_prog in flex lex
++    test -n "$CC" && break
++  done
++fi
++if test -z "$CC"; then
++  ac_ct_CC=$CC
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_LEX+set}" = set; then
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if test -n "$LEX"; then
+-  ac_cv_prog_LEX="$LEX" # Let the user override the test.
++  if test -n "$ac_ct_CC"; then
++  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+@@ -5959,277 +6618,432 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_LEX="$ac_prog"
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+-LEX=$ac_cv_prog_LEX
+-if test -n "$LEX"; then
+-  echo "$as_me:$LINENO: result: $LEX" >&5
+-echo "${ECHO_T}$LEX" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++ac_ct_CC=$ac_cv_prog_ac_ct_CC
++if test -n "$ac_ct_CC"; then
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
++else
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
++fi
++
++
++  test -n "$ac_ct_CC" && break
++done
++
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
++fi
++
+ fi
+-  test -n "$LEX" && break
+-done
+-test -n "$LEX" || LEX=":"
+-if test -z "$LEXLIB"
+-then
+-  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
+-echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
+-if test "${ac_cv_lib_fl_yywrap+set}" = set; then
++test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
++See \`config.log' for more details." >&5
++echo "$as_me: error: no acceptable C compiler found in \$PATH
++See \`config.log' for more details." >&2;}
++   { (exit 1); exit 1; }; }
++
++# Provide some information about the compiler.
++echo "$as_me:$LINENO: checking for C compiler version" >&5
++ac_compiler=`set X $ac_compile; echo $2`
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
++  ac_status=$?
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); }
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
++  ac_status=$?
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); }
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
++  ac_status=$?
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); }
++
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
++if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_check_lib_save_LIBS=$LIBS
+-LIBS="-lfl  $LIBS"
+-cat >conftest.$ac_ext <<_ACEOF
++  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char yywrap ();
+ int
+ main ()
+ {
+-yywrap ();
++#ifndef __GNUC__
++       choke me
++#endif
++
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_lib_fl_yywrap=yes
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_fl_yywrap=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++ac_cv_c_compiler_gnu=$ac_compiler_gnu
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
+-echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
+-if test $ac_cv_lib_fl_yywrap = yes; then
+-  LEXLIB="-lfl"
+-else
+-  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
+-echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
+-if test "${ac_cv_lib_l_yywrap+set}" = set; then
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
++GCC=`test $ac_compiler_gnu = yes && echo yes`
++ac_test_CFLAGS=${CFLAGS+set}
++ac_save_CFLAGS=$CFLAGS
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_check_lib_save_LIBS=$LIBS
+-LIBS="-ll  $LIBS"
+-cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char yywrap ();
+ int
+ main ()
+ {
+-yywrap ();
++
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_lib_l_yywrap=yes
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_l_yywrap=no
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
+-echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
+-if test $ac_cv_lib_l_yywrap = yes; then
+-  LEXLIB="-ll"
++
+ fi
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-if test "x$LEX" != "x:"; then
+-  echo "$as_me:$LINENO: checking lex output file root" >&5
+-echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
+-if test "${ac_cv_prog_lex_root+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  # The minimal lex program is just a single line: %%.  But some broken lexes
+-# (Solaris, I think it was) want two %% lines, so accommodate them.
+-cat >conftest.l <<_ACEOF
+-%%
+-%%
+-_ACEOF
+-{ (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
+-  (eval $LEX conftest.l) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }
+-if test -f lex.yy.c; then
+-  ac_cv_prog_lex_root=lex.yy
+-elif test -f lexyy.c; then
+-  ac_cv_prog_lex_root=lexyy
+-else
+-  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
+-echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
+-   { (exit 1); exit 1; }; }
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
+ fi
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
++if test "$ac_test_CFLAGS" = set; then
++  CFLAGS=$ac_save_CFLAGS
++elif test $ac_cv_prog_cc_g = yes; then
++  if test "$GCC" = yes; then
++    CFLAGS="-g -O2"
++  else
++    CFLAGS="-g"
++  fi
++else
++  if test "$GCC" = yes; then
++    CFLAGS="-O2"
++  else
++    CFLAGS=
++  fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
+-echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
+-rm -f conftest.l
+-LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
+-
+-echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
+-echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
+-if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  # POSIX says lex can declare yytext either as a pointer or an array; the
+-# default is implementation-dependent. Figure out which it is, since
+-# not all implementations provide the %pointer and %array declarations.
+-ac_cv_prog_lex_yytext_pointer=no
+-echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
+-ac_save_LIBS=$LIBS
+-LIBS="$LIBS $LEXLIB"
++  ac_cv_prog_cc_c89=no
++ac_save_CC=$CC
+ cat >conftest.$ac_ext <<_ACEOF
+-`cat $LEX_OUTPUT_ROOT.c`
++/* confdefs.h.  */
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <stdarg.h>
++#include <stdio.h>
++#include <sys/types.h>
++#include <sys/stat.h>
++/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
++struct buf { int x; };
++FILE * (*rcsopen) (struct buf *, struct stat *, int);
++static char *e (p, i)
++     char **p;
++     int i;
++{
++  return p[i];
++}
++static char *f (char * (*g) (char **, int), char **p, ...)
++{
++  char *s;
++  va_list v;
++  va_start (v,p);
++  s = g (p, va_arg (v,int));
++  va_end (v);
++  return s;
++}
++
++/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
++   function prototypes and stuff, but not '\xHH' hex character constants.
++   These don't provoke an error unfortunately, instead are silently treated
++   as 'x'.  The following induces an error, until -std is added to get
++   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
++   array size at least.  It's necessary to write '\x00'==0 to get something
++   that's true only with -std.  */
++int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
++int test (int i, double x);
++struct s1 {int (*f) (int a);};
++struct s2 {int (*f) (double a);};
++int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
++int argc;
++char **argv;
++int
++main ()
++{
++return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
++  ;
++  return 0;
++}
++_ACEOF
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++do
++  CC="$ac_save_CC $ac_arg"
++  rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_lex_yytext_pointer=yes
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_save_LIBS
+-rm -f "${LEX_OUTPUT_ROOT}.c"
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
+-echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
+-if test $ac_cv_prog_lex_yytext_pointer = yes; then
+-cat >>confdefs.h <<\_ACEOF
+-#define YYTEXT_POINTER 1
+-_ACEOF
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
++done
++rm -f conftest.$ac_ext
++CC=$ac_save_CC
+ fi
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
++  *)
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
++esac
+-fi
+-if test "$LEX" = :; then
+-  LEX=${am_missing_run}flex
+-fi
+-ALL_LINGUAS="fr tr es rw"
+-if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+-set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_RANLIB+set}" = set; then
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
++
++
++for ac_prog in 'bison -y' byacc
++do
++  # Extract the first word of "$ac_prog", so it can be a program name with args.
++set dummy $ac_prog; ac_word=$2
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_YACC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if test -n "$RANLIB"; then
+-  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
++  if test -n "$YACC"; then
++  ac_cv_prog_YACC="$YACC" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+@@ -6237,37 +7051,42 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    ac_cv_prog_YACC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+-RANLIB=$ac_cv_prog_RANLIB
+-if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++YACC=$ac_cv_prog_YACC
++if test -n "$YACC"; then
++  { echo "$as_me:$LINENO: result: $YACC" >&5
++echo "${ECHO_T}$YACC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-fi
+-if test -z "$ac_cv_prog_RANLIB"; then
+-  ac_ct_RANLIB=$RANLIB
+-  # Extract the first word of "ranlib", so it can be a program name with args.
+-set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
++
++  test -n "$YACC" && break
++done
++test -n "$YACC" || YACC="yacc"
++
++for ac_prog in flex lex
++do
++  # Extract the first word of "$ac_prog", so it can be a program name with args.
++set dummy $ac_prog; ac_word=$2
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_LEX+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if test -n "$ac_ct_RANLIB"; then
+-  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
++  if test -n "$LEX"; then
++  ac_cv_prog_LEX="$LEX" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+@@ -6275,449 +7094,295 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_RANLIB="ranlib"
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    ac_cv_prog_LEX="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+-ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+-if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++LEX=$ac_cv_prog_LEX
++if test -n "$LEX"; then
++  { echo "$as_me:$LINENO: result: $LEX" >&5
++echo "${ECHO_T}$LEX" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
+-else
+-  RANLIB="$ac_cv_prog_RANLIB"
+-fi
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
+-echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
+-# On Suns, sometimes $CPP names a directory.
+-if test -n "$CPP" && test -d "$CPP"; then
+-  CPP=
+-fi
+-if test -z "$CPP"; then
+-  if test "${ac_cv_prog_CPP+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-      # Double quotes because CPP needs to be expanded
+-    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+-    do
+-      ac_preproc_ok=false
+-for ac_c_preproc_warn_flag in '' yes
+-do
+-  # Use a header file that comes with gcc, so configuring glibc
+-  # with a fresh cross-compiler works.
+-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+-  # <limits.h> exists even on freestanding compilers.
+-  # On the NeXT, cc -E runs the code through the compiler's parser,
+-  # not just through cpp. "Syntax error" is here to catch this case.
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#ifdef __STDC__
+-# include <limits.h>
+-#else
+-# include <assert.h>
++  test -n "$LEX" && break
++done
++test -n "$LEX" || LEX=":"
++
++if test "x$LEX" != "x:"; then
++  cat >conftest.l <<_ACEOF
++%%
++a { ECHO; }
++b { REJECT; }
++c { yymore (); }
++d { yyless (1); }
++e { yyless (input () != 0); }
++f { unput (yytext[0]); }
++. { BEGIN INITIAL; }
++%%
++#ifdef YYTEXT_POINTER
++extern char *yytext;
+ #endif
+-                   Syntax error
++int
++main (void)
++{
++  return ! yylex () + ! yywrap ();
++}
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++{ (ac_try="$LEX conftest.l"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$LEX conftest.l") 2>&5
+   ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
+-  :
++  (exit $ac_status); }
++{ echo "$as_me:$LINENO: checking lex output file root" >&5
++echo $ECHO_N "checking lex output file root... $ECHO_C" >&6; }
++if test "${ac_cv_prog_lex_root+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-  # Broken: fails on valid input.
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
+-  # can be detected and how.
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <ac_nonexistent.h>
+-_ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
+-  # Broken: success on invalid input.
+-continue
++if test -f lex.yy.c; then
++  ac_cv_prog_lex_root=lex.yy
++elif test -f lexyy.c; then
++  ac_cv_prog_lex_root=lexyy
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-  # Passes both tests.
+-ac_preproc_ok=:
+-break
++  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
++echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
++   { (exit 1); exit 1; }; }
+ fi
+-rm -f conftest.err conftest.$ac_ext
+-
+-done
+-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+-rm -f conftest.err conftest.$ac_ext
+-if $ac_preproc_ok; then
+-  break
+ fi
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
++echo "${ECHO_T}$ac_cv_prog_lex_root" >&6; }
++LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
+-    done
+-    ac_cv_prog_CPP=$CPP
+-
+-fi
+-  CPP=$ac_cv_prog_CPP
+-else
+-  ac_cv_prog_CPP=$CPP
+-fi
+-echo "$as_me:$LINENO: result: $CPP" >&5
+-echo "${ECHO_T}$CPP" >&6
+-ac_preproc_ok=false
+-for ac_c_preproc_warn_flag in '' yes
+-do
+-  # Use a header file that comes with gcc, so configuring glibc
+-  # with a fresh cross-compiler works.
+-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+-  # <limits.h> exists even on freestanding compilers.
+-  # On the NeXT, cc -E runs the code through the compiler's parser,
+-  # not just through cpp. "Syntax error" is here to catch this case.
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#ifdef __STDC__
+-# include <limits.h>
+-#else
+-# include <assert.h>
+-#endif
+-                   Syntax error
+-_ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
+-  :
++if test -z "${LEXLIB+set}"; then
++  { echo "$as_me:$LINENO: checking lex library" >&5
++echo $ECHO_N "checking lex library... $ECHO_C" >&6; }
++if test "${ac_cv_lib_lex+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-  # Broken: fails on valid input.
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
+-  # can be detected and how.
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <ac_nonexistent.h>
++    ac_save_LIBS=$LIBS
++    ac_cv_lib_lex='none needed'
++    for ac_lib in '' -lfl -ll; do
++      LIBS="$ac_lib $ac_save_LIBS"
++      cat >conftest.$ac_ext <<_ACEOF
++`cat $LEX_OUTPUT_ROOT.c`
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
+-  # Broken: success on invalid input.
+-continue
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_lib_lex=$ac_lib
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-  # Passes both tests.
+-ac_preproc_ok=:
+-break
+-fi
+-rm -f conftest.err conftest.$ac_ext
+-done
+-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+-rm -f conftest.err conftest.$ac_ext
+-if $ac_preproc_ok; then
+-  :
+-else
+-  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
+-See \`config.log' for more details." >&5
+-echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
+-See \`config.log' for more details." >&2;}
+-   { (exit 1); exit 1; }; }
+ fi
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext conftest.$ac_ext
++      test "$ac_cv_lib_lex" != 'none needed' && break
++    done
++    LIBS=$ac_save_LIBS
+-echo "$as_me:$LINENO: checking for egrep" >&5
+-echo $ECHO_N "checking for egrep... $ECHO_C" >&6
+-if test "${ac_cv_prog_egrep+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
+-    then ac_cv_prog_egrep='grep -E'
+-    else ac_cv_prog_egrep='egrep'
+-    fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
+-echo "${ECHO_T}$ac_cv_prog_egrep" >&6
+- EGREP=$ac_cv_prog_egrep
+-
+-
+-echo "$as_me:$LINENO: checking for ANSI C header files" >&5
+-echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
+-if test "${ac_cv_header_stdc+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <stdlib.h>
+-#include <stdarg.h>
+-#include <string.h>
+-#include <float.h>
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_lex" >&5
++echo "${ECHO_T}$ac_cv_lib_lex" >&6; }
++  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
++fi
+-int
+-main ()
+-{
+-  ;
+-  return 0;
+-}
++{ echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
++echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6; }
++if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  # POSIX says lex can declare yytext either as a pointer or an array; the
++# default is implementation-dependent.  Figure out which it is, since
++# not all implementations provide the %pointer and %array declarations.
++ac_cv_prog_lex_yytext_pointer=no
++ac_save_LIBS=$LIBS
++LIBS="$LEXLIB $ac_save_LIBS"
++cat >conftest.$ac_ext <<_ACEOF
++#define YYTEXT_POINTER 1
++`cat $LEX_OUTPUT_ROOT.c`
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_header_stdc=yes
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_prog_lex_yytext_pointer=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_header_stdc=no
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-
+-if test $ac_cv_header_stdc = yes; then
+-  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <string.h>
+-_ACEOF
+-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+-  $EGREP "memchr" >/dev/null 2>&1; then
+-  :
+-else
+-  ac_cv_header_stdc=no
+ fi
+-rm -f conftest*
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext conftest.$ac_ext
++LIBS=$ac_save_LIBS
+ fi
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
++echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6; }
++if test $ac_cv_prog_lex_yytext_pointer = yes; then
+-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 <<_ACEOF
+-/* confdefs.h.  */
++cat >>confdefs.h <<\_ACEOF
++#define YYTEXT_POINTER 1
+ _ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <stdlib.h>
+-_ACEOF
+-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+-  $EGREP "free" >/dev/null 2>&1; then
+-  :
+-else
+-  ac_cv_header_stdc=no
+ fi
+-rm -f conftest*
++rm -f conftest.l $LEX_OUTPUT_ROOT.c
+ fi
++if test "$LEX" = :; then
++  LEX=${am_missing_run}flex
++fi
+-if test $ac_cv_header_stdc = yes; then
+-  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+-  if test "$cross_compiling" = yes; then
+-  :
++ALL_LINGUAS="fr tr es rw"
++if test -n "$ac_tool_prefix"; then
++  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
++set dummy ${ac_tool_prefix}ranlib; ac_word=$2
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_RANLIB+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <ctype.h>
+-#if ((' ' & 0x0FF) == 0x020)
+-# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+-# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+-#else
+-# define ISLOWER(c) \
+-                 (('a' <= (c) && (c) <= 'i') \
+-                   || ('j' <= (c) && (c) <= 'r') \
+-                   || ('s' <= (c) && (c) <= 'z'))
+-# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+-#endif
+-
+-#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+-int
+-main ()
+-{
+-  int i;
+-  for (i = 0; i < 256; i++)
+-    if (XOR (islower (i), ISLOWER (i))
+-      || toupper (i) != TOUPPER (i))
+-      exit(2);
+-  exit (0);
+-}
+-_ACEOF
+-rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
++  if test -n "$RANLIB"; then
++  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+ else
+-  echo "$as_me: program exited with status $ac_status" >&5
+-echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_exec_ext in '' $ac_executable_extensions; do
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
++    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
++    break 2
++  fi
++done
++done
++IFS=$as_save_IFS
+-( exit $ac_status )
+-ac_cv_header_stdc=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++RANLIB=$ac_cv_prog_RANLIB
++if test -n "$RANLIB"; then
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
++else
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
+-echo "${ECHO_T}$ac_cv_header_stdc" >&6
+-if test $ac_cv_header_stdc = yes; then
++if test -z "$ac_cv_prog_RANLIB"; then
++  ac_ct_RANLIB=$RANLIB
++  # Extract the first word of "ranlib", so it can be a program name with args.
++set dummy ranlib; ac_word=$2
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
++if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  if test -n "$ac_ct_RANLIB"; then
++  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
++else
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_exec_ext in '' $ac_executable_extensions; do
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
++    ac_cv_prog_ac_ct_RANLIB="ranlib"
++    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
++    break 2
++  fi
++done
++done
++IFS=$as_save_IFS
+-cat >>confdefs.h <<\_ACEOF
+-#define STDC_HEADERS 1
+-_ACEOF
++fi
++fi
++ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
++if test -n "$ac_ct_RANLIB"; then
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
++else
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
++fi
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
++else
++  RANLIB="$ac_cv_prog_RANLIB"
+ fi
+-echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
+-echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
++echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; }
+ if test "${ac_cv_c_const+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6735,10 +7400,10 @@ main ()
+ #ifndef __cplusplus
+   /* Ultrix mips cc rejects this.  */
+   typedef int charset[2];
+-  const charset x;
++  const charset cs;
+   /* SunOS 4.1.1 cc rejects this.  */
+-  char const *const *ccp;
+-  char **p;
++  char const *const *pcpcc;
++  char **ppc;
+   /* NEC SVR4.0.2 mips cc rejects this.  */
+   struct point {int x, y;};
+   static struct point const zero = {0,0};
+@@ -6747,16 +7412,17 @@ main ()
+      an arm of an if-expression whose if-part is not a constant
+      expression */
+   const char *g = "string";
+-  ccp = &g + (g ? g-g : 0);
++  pcpcc = &g + (g ? g-g : 0);
+   /* HPUX 7.0 cc rejects these. */
+-  ++ccp;
+-  p = (char**) ccp;
+-  ccp = (char const *const *) p;
++  ++pcpcc;
++  ppc = (char**) pcpcc;
++  pcpcc = (char const *const *) ppc;
+   { /* SCO 3.2v4 cc rejects this.  */
+     char *t;
+     char const *s = 0 ? (char *) 0 : (char const *) 0;
+     *t++ = 0;
++    if (s) return 0;
+   }
+   { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+     int x[] = {25, 17};
+@@ -6775,7 +7441,9 @@ main ()
+   }
+   { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+     const int foo = 10;
++    if (!foo) return 0;
+   }
++  return !cs[0] && !zero.x;
+ #endif
+   ;
+@@ -6783,38 +7451,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_c_const=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_c_const=no
++      ac_cv_c_const=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
+-echo "${ECHO_T}$ac_cv_c_const" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
++echo "${ECHO_T}$ac_cv_c_const" >&6; }
+ if test $ac_cv_c_const = no; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -6823,8 +7487,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for inline" >&5
+-echo $ECHO_N "checking for inline... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for inline" >&5
++echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
+ if test "${ac_cv_c_inline+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6844,39 +7508,37 @@ $ac_kw foo_t foo () {return 0; }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_c_inline=$ac_kw; break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_c_inline=$ac_kw
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++  test "$ac_cv_c_inline" != no && break
+ done
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
+-echo "${ECHO_T}$ac_cv_c_inline" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
++echo "${ECHO_T}$ac_cv_c_inline" >&6; }
+ case $ac_cv_c_inline in
+@@ -6894,80 +7556,8 @@ _ACEOF
+     ;;
+ esac
+-# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+-                inttypes.h stdint.h unistd.h
+-do
+-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_includes_default
+-
+-#include <$ac_header>
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  eval "$as_ac_Header=yes"
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-eval "$as_ac_Header=no"
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+-if test `eval echo '${'$as_ac_Header'}'` = yes; then
+-  cat >>confdefs.h <<_ACEOF
+-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+-_ACEOF
+-
+-fi
+-
+-done
+-
+-
+-echo "$as_me:$LINENO: checking for off_t" >&5
+-echo $ECHO_N "checking for off_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for off_t" >&5
++echo $ECHO_N "checking for off_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_off_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6978,62 +7568,59 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef off_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((off_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (off_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_off_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_off_t=no
++      ac_cv_type_off_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
+-echo "${ECHO_T}$ac_cv_type_off_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
++echo "${ECHO_T}$ac_cv_type_off_t" >&6; }
+ if test $ac_cv_type_off_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define off_t long
++#define off_t long int
+ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for size_t" >&5
+-echo $ECHO_N "checking for size_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for size_t" >&5
++echo $ECHO_N "checking for size_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_size_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7044,64 +7631,61 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef size_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((size_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (size_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_size_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_size_t=no
++      ac_cv_type_size_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
+-echo "${ECHO_T}$ac_cv_type_size_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
++echo "${ECHO_T}$ac_cv_type_size_t" >&6; }
+ if test $ac_cv_type_size_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define size_t unsigned
++#define size_t unsigned int
+ _ACEOF
+ fi
+ # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+ # for constant arguments.  Useless!
+-echo "$as_me:$LINENO: checking for working alloca.h" >&5
+-echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working alloca.h" >&5
++echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6; }
+ if test "${ac_cv_working_alloca_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7116,44 +7700,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (2 * sizeof (int));
++                        if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_working_alloca_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_working_alloca_h=no
++      ac_cv_working_alloca_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
+-echo "${ECHO_T}$ac_cv_working_alloca_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
++echo "${ECHO_T}$ac_cv_working_alloca_h" >&6; }
+ if test $ac_cv_working_alloca_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -7162,8 +7744,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for alloca" >&5
+-echo $ECHO_N "checking for alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for alloca" >&5
++echo $ECHO_N "checking for alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_func_alloca_works+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7180,7 +7762,7 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #  include <malloc.h>
+ #  define alloca _alloca
+ # else
+-#  if HAVE_ALLOCA_H
++#  ifdef HAVE_ALLOCA_H
+ #   include <alloca.h>
+ #  else
+ #   ifdef _AIX
+@@ -7198,44 +7780,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (1);
++                                  if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_func_alloca_works=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_func_alloca_works=no
++      ac_cv_func_alloca_works=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
+-echo "${ECHO_T}$ac_cv_func_alloca_works" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
++echo "${ECHO_T}$ac_cv_func_alloca_works" >&6; }
+ if test $ac_cv_func_alloca_works = yes; then
+@@ -7249,15 +7829,15 @@ else
+ # contain a buggy version.  If you still want to use their alloca,
+ # use ar to extract alloca.o from them instead of compiling alloca.c.
+-ALLOCA=alloca.$ac_objext
++ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
+ cat >>confdefs.h <<\_ACEOF
+ #define C_ALLOCA 1
+ _ACEOF
+-echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
+-echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
++echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6; }
+ if test "${ac_cv_os_cray+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7267,7 +7847,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#if defined(CRAY) && ! defined(CRAY2)
++#if defined CRAY && ! defined CRAY2
+ webecray
+ #else
+ wenotbecray
+@@ -7283,14 +7863,14 @@ fi
+ rm -f conftest*
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
+-echo "${ECHO_T}$ac_cv_os_cray" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
++echo "${ECHO_T}$ac_cv_os_cray" >&6; }
+ if test $ac_cv_os_cray = yes; then
+   for ac_func in _getb67 GETB67 getb67; do
+     as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7316,68 +7896,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -7390,8 +7962,8 @@ fi
+   done
+ fi
+-echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
+-echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
++echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_c_stack_direction+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7404,6 +7976,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
++$ac_includes_default
+ int
+ find_stack_direction ()
+ {
+@@ -7421,17 +7994,26 @@ find_stack_direction ()
+ int
+ main ()
+ {
+-  exit (find_stack_direction () < 0);
++  return find_stack_direction () < 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -7444,11 +8026,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_c_stack_direction=-1
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
+-echo "${ECHO_T}$ac_cv_c_stack_direction" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
++echo "${ECHO_T}$ac_cv_c_stack_direction" >&6; }
+ cat >>confdefs.h <<_ACEOF
+ #define STACK_DIRECTION $ac_cv_c_stack_direction
+@@ -7462,18 +8046,19 @@ fi
+ for ac_header in stdlib.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7484,41 +8069,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7527,24 +8108,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -7552,9 +8131,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -7578,25 +8158,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -7612,9 +8186,9 @@ done
+ for ac_func in getpagesize
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7640,68 +8214,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7710,8 +8276,8 @@ _ACEOF
+ fi
+ done
+-echo "$as_me:$LINENO: checking for working mmap" >&5
+-echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working mmap" >&5
++echo $ECHO_N "checking for working mmap... $ECHO_C" >&6; }
+ if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7753,21 +8319,21 @@ $ac_includes_default
+ #include <fcntl.h>
+ #include <sys/mman.h>
+-#if !STDC_HEADERS && !HAVE_STDLIB_H
++#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H
+ char *malloc ();
+ #endif
+ /* This mess was copied from the GNU getpagesize.h.  */
+-#if !HAVE_GETPAGESIZE
++#ifndef HAVE_GETPAGESIZE
+ /* Assume that all systems that can run configure have sys/param.h.  */
+-# if !HAVE_SYS_PARAM_H
++# ifndef HAVE_SYS_PARAM_H
+ #  define HAVE_SYS_PARAM_H 1
+ # endif
+ # ifdef _SC_PAGESIZE
+ #  define getpagesize() sysconf(_SC_PAGESIZE)
+ # else /* no _SC_PAGESIZE */
+-#  if HAVE_SYS_PARAM_H
++#  ifdef HAVE_SYS_PARAM_H
+ #   include <sys/param.h>
+ #   ifdef EXEC_PAGESIZE
+ #    define getpagesize() EXEC_PAGESIZE
+@@ -7806,15 +8372,15 @@ main ()
+   /* First, make a file with some known garbage in it. */
+   data = (char *) malloc (pagesize);
+   if (!data)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     *(data + i) = rand ();
+   umask (0);
+   fd = creat ("conftest.mmap", 0600);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   if (write (fd, data, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   close (fd);
+   /* Next, try to mmap the file at a fixed address which already has
+@@ -7822,17 +8388,17 @@ main ()
+      we see the same garbage.  */
+   fd = open ("conftest.mmap", O_RDWR);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   data2 = (char *) malloc (2 * pagesize);
+   if (!data2)
+-    exit (1);
+-  data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
++    return 1;
++  data2 += (pagesize - ((long int) data2 & (pagesize - 1))) & (pagesize - 1);
+   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_FIXED, fd, 0L))
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data2 + i))
+-      exit (1);
++      return 1;
+   /* Finally, make sure that changes to the mapped area do not
+      percolate back to the file as seen by read().  (This is a bug on
+@@ -7841,24 +8407,33 @@ main ()
+     *(data2 + i) = *(data2 + i) + 1;
+   data3 = (char *) malloc (pagesize);
+   if (!data3)
+-    exit (1);
++    return 1;
+   if (read (fd, data3, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data3 + i))
+-      exit (1);
++      return 1;
+   close (fd);
+-  exit (0);
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -7871,11 +8446,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_func_mmap_fixed_mapped=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
+-echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
++echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6; }
+ if test $ac_cv_func_mmap_fixed_mapped = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -7899,18 +8476,19 @@ for ac_header in argz.h limits.h locale.
+ unistd.h values.h sys/param.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7921,41 +8499,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7964,24 +8538,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -7989,9 +8561,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -8015,25 +8588,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -8059,9 +8626,9 @@ for ac_func in getcwd munmap putenv sete
+ __argz_count __argz_stringify __argz_next
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -8087,68 +8654,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -8163,9 +8722,9 @@ done
+ for ac_func in stpcpy
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -8191,68 +8750,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -8271,8 +8822,8 @@ _ACEOF
+    fi
+    if test $ac_cv_header_locale_h = yes; then
+-    echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
+-echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
++echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6; }
+ if test "${am_cv_val_LC_MESSAGES+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8292,39 +8843,36 @@ return LC_MESSAGES
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   am_cv_val_LC_MESSAGES=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-am_cv_val_LC_MESSAGES=no
++      am_cv_val_LC_MESSAGES=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
+-echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
++echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6; }
+     if test $am_cv_val_LC_MESSAGES = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -8333,34 +8881,34 @@ _ACEOF
+     fi
+   fi
+-   echo "$as_me:$LINENO: checking whether NLS is requested" >&5
+-echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6
+-        # Check whether --enable-nls or --disable-nls was given.
++   { echo "$as_me:$LINENO: checking whether NLS is requested" >&5
++echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6; }
++        # Check whether --enable-nls was given.
+ if test "${enable_nls+set}" = set; then
+-  enableval="$enable_nls"
+-  USE_NLS=$enableval
++  enableval=$enable_nls; USE_NLS=$enableval
+ else
+   USE_NLS=yes
+-fi;
+-    echo "$as_me:$LINENO: result: $USE_NLS" >&5
+-echo "${ECHO_T}$USE_NLS" >&6
++fi
++
++    { echo "$as_me:$LINENO: result: $USE_NLS" >&5
++echo "${ECHO_T}$USE_NLS" >&6; }
+     USE_INCLUDED_LIBINTL=no
+         if test "$USE_NLS" = "yes"; then
+-      echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
+-echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6
++      { echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
++echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6; }
+-# Check whether --with-included-gettext or --without-included-gettext was given.
++# Check whether --with-included-gettext was given.
+ if test "${with_included_gettext+set}" = set; then
+-  withval="$with_included_gettext"
+-  nls_cv_force_use_gnu_gettext=$withval
++  withval=$with_included_gettext; nls_cv_force_use_gnu_gettext=$withval
+ else
+   nls_cv_force_use_gnu_gettext=no
+-fi;
+-      echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
+-echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6
++fi
++
++      { echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
++echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6; }
+       nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext"
+       if test "$nls_cv_force_use_gnu_gettext" != "yes"; then
+@@ -8369,17 +8917,17 @@ echo "${ECHO_T}$nls_cv_force_use_gnu_get
+       CATOBJEXT=
+       if test "${ac_cv_header_libintl_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking libintl.h usability" >&5
+-echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h usability" >&5
++echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8390,41 +8938,37 @@ $ac_includes_default
+ #include <libintl.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking libintl.h presence" >&5
+-echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h presence" >&5
++echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8433,24 +8977,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <libintl.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -8458,9 +9000,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -8484,30 +9027,23 @@ echo "$as_me: WARNING: libintl.h:     se
+ echo "$as_me: WARNING: libintl.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: libintl.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: libintl.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_libintl_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ fi
+ if test $ac_cv_header_libintl_h = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libc" >&5
+-echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libc" >&5
++echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libc+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8527,43 +9063,40 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libc=no
++      gt_cv_func_gettext_libc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6; }
+          if test "$gt_cv_func_gettext_libc" != "yes"; then
+-           echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
+-echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6
++           { echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
++echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6; }
+ if test "${ac_cv_lib_intl_bindtextdomain+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8576,59 +9109,56 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char bindtextdomain ();
+ int
+ main ()
+ {
+-bindtextdomain ();
++return bindtextdomain ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_lib_intl_bindtextdomain=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_intl_bindtextdomain=no
++      ac_cv_lib_intl_bindtextdomain=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
+-echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
++echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6; }
+ if test $ac_cv_lib_intl_bindtextdomain = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libintl" >&5
+-echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libintl" >&5
++echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libintl+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8648,39 +9178,36 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libintl=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libintl=no
++      gt_cv_func_gettext_libintl=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6; }
+ fi
+          fi
+@@ -8694,8 +9221,8 @@ _ACEOF
+             # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8721,20 +9248,20 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+             if test "$MSGFMT" != "no"; then
+ for ac_func in dcgettext
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -8760,68 +9287,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -8832,8 +9351,8 @@ done
+               # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8848,32 +9367,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+               # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8899,11 +9419,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+               cat >conftest.$ac_ext <<_ACEOF
+@@ -8923,37 +9443,34 @@ extern int _nl_msg_cat_cntr;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   CATOBJEXT=.gmo
+                  DATADIRNAME=share
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-CATOBJEXT=.mo
++      CATOBJEXT=.mo
+                  DATADIRNAME=lib
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+               INSTOBJEXT=.mo
+             fi
+@@ -8975,8 +9492,8 @@ fi
+                 INTLOBJS="\$(GETTOBJS)"
+         # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9002,17 +9519,17 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+         # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9027,32 +9544,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+         # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9078,11 +9596,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+@@ -9101,8 +9619,8 @@ fi
+                       if $XGETTEXT --omit-header /dev/null 2> /dev/null; then
+         : ;
+       else
+-        echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
+-echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6
++        { echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
++echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6; }
+         XGETTEXT=":"
+       fi
+       fi
+@@ -9151,8 +9669,8 @@ _ACEOF
+      if test "x$ALL_LINGUAS" = "x"; then
+        LINGUAS=
+      else
+-       echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
+-echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6
++       { echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
++echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6; }
+        NEW_LINGUAS=
+        for lang in ${LINGUAS=$ALL_LINGUAS}; do
+          case "$ALL_LINGUAS" in
+@@ -9160,8 +9678,8 @@ echo $ECHO_N "checking for catalogs to b
+          esac
+        done
+        LINGUAS=$NEW_LINGUAS
+-       echo "$as_me:$LINENO: result: $LINGUAS" >&5
+-echo "${ECHO_T}$LINGUAS" >&6
++       { echo "$as_me:$LINENO: result: $LINGUAS" >&5
++echo "${ECHO_T}$LINGUAS" >&6; }
+      fi
+           if test -n "$LINGUAS"; then
+@@ -9180,17 +9698,17 @@ echo "${ECHO_T}$LINGUAS" >&6
+             if test -f $srcdir/po2tbl.sed.in; then
+       if test "$CATOBJEXT" = ".cat"; then
+        if test "${ac_cv_header_linux_version_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking linux/version.h usability" >&5
+-echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h usability" >&5
++echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9201,41 +9719,37 @@ $ac_includes_default
+ #include <linux/version.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking linux/version.h presence" >&5
+-echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h presence" >&5
++echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9244,24 +9758,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <linux/version.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -9269,9 +9781,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -9295,25 +9808,18 @@ echo "$as_me: WARNING: linux/version.h: 
+ echo "$as_me: WARNING: linux/version.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: linux/version.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: linux/version.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_linux_version_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ fi
+ if test $ac_cv_header_linux_version_h = yes; then
+@@ -9363,17 +9869,17 @@ fi
+    fi
+-echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
+-echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
+-    # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
++{ echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
++echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6; }
++    # Check whether --enable-maintainer-mode was given.
+ if test "${enable_maintainer_mode+set}" = set; then
+-  enableval="$enable_maintainer_mode"
+-  USE_MAINTAINER_MODE=$enableval
++  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
+ else
+   USE_MAINTAINER_MODE=no
+-fi;
+-  echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
+-echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
++fi
++
++  { echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
++echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6; }
+ if test $USE_MAINTAINER_MODE = yes; then
+@@ -9401,18 +9907,19 @@ fi
+ for ac_header in string.h stdlib.h memory.h strings.h unistd.h stdarg.h varargs.h errno.h sys/types.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9423,41 +9930,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9466,24 +9969,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -9491,9 +9992,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -9517,25 +10019,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -9550,8 +10046,8 @@ done
+ # 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 "$as_me:$LINENO: checking whether compiling a cross-assembler" >&5
+-echo $ECHO_N "checking whether compiling a cross-assembler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether compiling a cross-assembler" >&5
++echo $ECHO_N "checking whether compiling a cross-assembler... $ECHO_C" >&6; }
+ if test "${host}" = "${target}"; then
+   cross_gas=no
+ else
+@@ -9562,13 +10058,13 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+ fi
+-echo "$as_me:$LINENO: result: $cross_gas" >&5
+-echo "${ECHO_T}$cross_gas" >&6
++{ echo "$as_me:$LINENO: result: $cross_gas" >&5
++echo "${ECHO_T}$cross_gas" >&6; }
+ # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+ # for constant arguments.  Useless!
+-echo "$as_me:$LINENO: checking for working alloca.h" >&5
+-echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working alloca.h" >&5
++echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6; }
+ if test "${ac_cv_working_alloca_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9583,44 +10079,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (2 * sizeof (int));
++                        if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_working_alloca_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_working_alloca_h=no
++      ac_cv_working_alloca_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
+-echo "${ECHO_T}$ac_cv_working_alloca_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
++echo "${ECHO_T}$ac_cv_working_alloca_h" >&6; }
+ if test $ac_cv_working_alloca_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -9629,8 +10123,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for alloca" >&5
+-echo $ECHO_N "checking for alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for alloca" >&5
++echo $ECHO_N "checking for alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_func_alloca_works+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9647,7 +10141,7 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #  include <malloc.h>
+ #  define alloca _alloca
+ # else
+-#  if HAVE_ALLOCA_H
++#  ifdef HAVE_ALLOCA_H
+ #   include <alloca.h>
+ #  else
+ #   ifdef _AIX
+@@ -9665,44 +10159,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (1);
++                                  if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_func_alloca_works=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_func_alloca_works=no
++      ac_cv_func_alloca_works=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
+-echo "${ECHO_T}$ac_cv_func_alloca_works" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
++echo "${ECHO_T}$ac_cv_func_alloca_works" >&6; }
+ if test $ac_cv_func_alloca_works = yes; then
+@@ -9716,15 +10208,15 @@ else
+ # contain a buggy version.  If you still want to use their alloca,
+ # use ar to extract alloca.o from them instead of compiling alloca.c.
+-ALLOCA=alloca.$ac_objext
++ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
+ cat >>confdefs.h <<\_ACEOF
+ #define C_ALLOCA 1
+ _ACEOF
+-echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
+-echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
++echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6; }
+ if test "${ac_cv_os_cray+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9734,7 +10226,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#if defined(CRAY) && ! defined(CRAY2)
++#if defined CRAY && ! defined CRAY2
+ webecray
+ #else
+ wenotbecray
+@@ -9750,14 +10242,14 @@ fi
+ rm -f conftest*
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
+-echo "${ECHO_T}$ac_cv_os_cray" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
++echo "${ECHO_T}$ac_cv_os_cray" >&6; }
+ if test $ac_cv_os_cray = yes; then
+   for ac_func in _getb67 GETB67 getb67; do
+     as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -9783,68 +10275,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -9857,8 +10341,8 @@ fi
+   done
+ fi
+-echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
+-echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
++echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_c_stack_direction+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9871,6 +10355,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
++$ac_includes_default
+ int
+ find_stack_direction ()
+ {
+@@ -9888,17 +10373,26 @@ find_stack_direction ()
+ int
+ main ()
+ {
+-  exit (find_stack_direction () < 0);
++  return find_stack_direction () < 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -9911,11 +10405,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_c_stack_direction=-1
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
+-echo "${ECHO_T}$ac_cv_c_stack_direction" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
++echo "${ECHO_T}$ac_cv_c_stack_direction" >&6; }
+ cat >>confdefs.h <<_ACEOF
+ #define STACK_DIRECTION $ac_cv_c_stack_direction
+@@ -9924,8 +10420,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for inline" >&5
+-echo $ECHO_N "checking for inline... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for inline" >&5
++echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
+ if test "${ac_cv_c_inline+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9945,39 +10441,37 @@ $ac_kw foo_t foo () {return 0; }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_c_inline=$ac_kw; break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_c_inline=$ac_kw
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++  test "$ac_cv_c_inline" != no && break
+ done
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
+-echo "${ECHO_T}$ac_cv_c_inline" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
++echo "${ECHO_T}$ac_cv_c_inline" >&6; }
+ case $ac_cv_c_inline in
+@@ -10002,9 +10496,9 @@ esac
+ for ac_func in unlink remove
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -10030,68 +10524,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -10106,9 +10592,9 @@ done
+ for ac_func in sbrk
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -10134,68 +10620,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -10215,8 +10693,8 @@ case $host in
+   # on darwin the libm is a symbolic link to libSystem.dylib
+   ;;
+ *-ncr-sysv4.3*)
+-  echo "$as_me:$LINENO: checking for _mwvalidcheckl in -lmw" >&5
+-echo $ECHO_N "checking for _mwvalidcheckl in -lmw... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for _mwvalidcheckl in -lmw" >&5
++echo $ECHO_N "checking for _mwvalidcheckl in -lmw... $ECHO_C" >&6; }
+ if test "${ac_cv_lib_mw__mwvalidcheckl+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10229,62 +10707,59 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char _mwvalidcheckl ();
+ int
+ main ()
+ {
+-_mwvalidcheckl ();
++return _mwvalidcheckl ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_lib_mw__mwvalidcheckl=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_mw__mwvalidcheckl=no
++      ac_cv_lib_mw__mwvalidcheckl=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_mw__mwvalidcheckl" >&5
+-echo "${ECHO_T}$ac_cv_lib_mw__mwvalidcheckl" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_mw__mwvalidcheckl" >&5
++echo "${ECHO_T}$ac_cv_lib_mw__mwvalidcheckl" >&6; }
+ if test $ac_cv_lib_mw__mwvalidcheckl = yes; then
+   LIBM="-lmw"
+ fi
+-  echo "$as_me:$LINENO: checking for main in -lm" >&5
+-echo $ECHO_N "checking for main in -lm... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for main in -lm" >&5
++echo $ECHO_N "checking for main in -lm... $ECHO_C" >&6; }
+ if test "${ac_cv_lib_m_main+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10301,54 +10776,51 @@ cat >>conftest.$ac_ext <<_ACEOF
+ int
+ main ()
+ {
+-main ();
++return main ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_lib_m_main=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_m_main=no
++      ac_cv_lib_m_main=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_m_main" >&5
+-echo "${ECHO_T}$ac_cv_lib_m_main" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_m_main" >&5
++echo "${ECHO_T}$ac_cv_lib_m_main" >&6; }
+ if test $ac_cv_lib_m_main = yes; then
+   LIBM="$LIBM -lm"
+ fi
+   ;;
+ *)
+-  echo "$as_me:$LINENO: checking for main in -lm" >&5
+-echo $ECHO_N "checking for main in -lm... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for main in -lm" >&5
++echo $ECHO_N "checking for main in -lm... $ECHO_C" >&6; }
+ if test "${ac_cv_lib_m_main+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10365,46 +10837,43 @@ cat >>conftest.$ac_ext <<_ACEOF
+ int
+ main ()
+ {
+-main ();
++return main ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_lib_m_main=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_m_main=no
++      ac_cv_lib_m_main=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_m_main" >&5
+-echo "${ECHO_T}$ac_cv_lib_m_main" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_m_main" >&5
++echo "${ECHO_T}$ac_cv_lib_m_main" >&6; }
+ if test $ac_cv_lib_m_main = yes; then
+   LIBM="-lm"
+ fi
+@@ -10419,8 +10888,8 @@ esac
+ # Some non-ANSI preprocessors botch requoting inside strings.  That's bad
+ # enough, but on some of those systems, the assert macro relies on requoting
+ # working properly!
+-echo "$as_me:$LINENO: checking for working assert macro" >&5
+-echo $ECHO_N "checking for working assert macro... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working assert macro" >&5
++echo $ECHO_N "checking for working assert macro... $ECHO_C" >&6; }
+ if test "${gas_cv_assert_ok+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10449,39 +10918,36 @@ assert (a == b
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gas_cv_assert_ok=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gas_cv_assert_ok=no
++      gas_cv_assert_ok=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gas_cv_assert_ok" >&5
+-echo "${ECHO_T}$gas_cv_assert_ok" >&6
++{ echo "$as_me:$LINENO: result: $gas_cv_assert_ok" >&5
++echo "${ECHO_T}$gas_cv_assert_ok" >&6; }
+ test $gas_cv_assert_ok = yes ||
+ cat >>confdefs.h <<\_ACEOF
+ #define BROKEN_ASSERT 1
+@@ -10514,8 +10980,8 @@ gas_test_headers="
+ # Does errno.h declare errno, or do we have to add a separate declaration
+ # for it?
+-echo "$as_me:$LINENO: checking whether declaration is required for errno" >&5
+-echo $ECHO_N "checking whether declaration is required for errno... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether declaration is required for errno" >&5
++echo $ECHO_N "checking whether declaration is required for errno... $ECHO_C" >&6; }
+ if test "${gas_cv_decl_needed_errno+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10543,39 +11009,36 @@ x = (f) errno;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gas_cv_decl_needed_errno=no
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gas_cv_decl_needed_errno=yes
++      gas_cv_decl_needed_errno=yes
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gas_cv_decl_needed_errno" >&5
+-echo "${ECHO_T}$gas_cv_decl_needed_errno" >&6
++{ echo "$as_me:$LINENO: result: $gas_cv_decl_needed_errno" >&5
++echo "${ECHO_T}$gas_cv_decl_needed_errno" >&6; }
+ if test $gas_cv_decl_needed_errno = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -10585,8 +11048,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for a known getopt prototype in unistd.h" >&5
+-echo $ECHO_N "checking for a known getopt prototype in unistd.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a known getopt prototype in unistd.h" >&5
++echo $ECHO_N "checking for a known getopt prototype in unistd.h... $ECHO_C" >&6; }
+ if test "${gas_cv_decl_getopt_unistd_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10606,39 +11069,35 @@ extern int getopt (int, char *const*, co
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   gas_cv_decl_getopt_unistd_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gas_cv_decl_getopt_unistd_h=no
++      gas_cv_decl_getopt_unistd_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gas_cv_decl_getopt_unistd_h" >&5
+-echo "${ECHO_T}$gas_cv_decl_getopt_unistd_h" >&6
++{ echo "$as_me:$LINENO: result: $gas_cv_decl_getopt_unistd_h" >&5
++echo "${ECHO_T}$gas_cv_decl_getopt_unistd_h" >&6; }
+ if test $gas_cv_decl_getopt_unistd_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -10648,8 +11107,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether declaration is required for environ" >&5
+-echo $ECHO_N "checking whether declaration is required for environ... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether declaration is required for environ" >&5
++echo $ECHO_N "checking whether declaration is required for environ... $ECHO_C" >&6; }
+ if test "${gas_cv_decl_needed_environ+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10673,39 +11132,36 @@ x = (f) environ;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gas_cv_decl_needed_environ=no
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gas_cv_decl_needed_environ=yes
++      gas_cv_decl_needed_environ=yes
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gas_cv_decl_needed_environ" >&5
+-echo "${ECHO_T}$gas_cv_decl_needed_environ" >&6
++{ echo "$as_me:$LINENO: result: $gas_cv_decl_needed_environ" >&5
++echo "${ECHO_T}$gas_cv_decl_needed_environ" >&6; }
+ if test $gas_cv_decl_needed_environ = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -10715,8 +11171,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether declaration is required for ffs" >&5
+-echo $ECHO_N "checking whether declaration is required for ffs... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether declaration is required for ffs" >&5
++echo $ECHO_N "checking whether declaration is required for ffs... $ECHO_C" >&6; }
+ if test "${gas_cv_decl_needed_ffs+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10740,39 +11196,36 @@ x = (f) ffs;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gas_cv_decl_needed_ffs=no
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gas_cv_decl_needed_ffs=yes
++      gas_cv_decl_needed_ffs=yes
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gas_cv_decl_needed_ffs" >&5
+-echo "${ECHO_T}$gas_cv_decl_needed_ffs" >&6
++{ echo "$as_me:$LINENO: result: $gas_cv_decl_needed_ffs" >&5
++echo "${ECHO_T}$gas_cv_decl_needed_ffs" >&6; }
+ if test $gas_cv_decl_needed_ffs = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -10782,8 +11235,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether declaration is required for free" >&5
+-echo $ECHO_N "checking whether declaration is required for free... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether declaration is required for free" >&5
++echo $ECHO_N "checking whether declaration is required for free... $ECHO_C" >&6; }
+ if test "${gas_cv_decl_needed_free+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10807,39 +11260,36 @@ x = (f) free;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gas_cv_decl_needed_free=no
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gas_cv_decl_needed_free=yes
++      gas_cv_decl_needed_free=yes
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gas_cv_decl_needed_free" >&5
+-echo "${ECHO_T}$gas_cv_decl_needed_free" >&6
++{ echo "$as_me:$LINENO: result: $gas_cv_decl_needed_free" >&5
++echo "${ECHO_T}$gas_cv_decl_needed_free" >&6; }
+ if test $gas_cv_decl_needed_free = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -10849,8 +11299,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether declaration is required for malloc" >&5
+-echo $ECHO_N "checking whether declaration is required for malloc... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether declaration is required for malloc" >&5
++echo $ECHO_N "checking whether declaration is required for malloc... $ECHO_C" >&6; }
+ if test "${gas_cv_decl_needed_malloc+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10874,39 +11324,36 @@ x = (f) malloc;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gas_cv_decl_needed_malloc=no
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gas_cv_decl_needed_malloc=yes
++      gas_cv_decl_needed_malloc=yes
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gas_cv_decl_needed_malloc" >&5
+-echo "${ECHO_T}$gas_cv_decl_needed_malloc" >&6
++{ echo "$as_me:$LINENO: result: $gas_cv_decl_needed_malloc" >&5
++echo "${ECHO_T}$gas_cv_decl_needed_malloc" >&6; }
+ if test $gas_cv_decl_needed_malloc = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -10916,8 +11363,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether declaration is required for sbrk" >&5
+-echo $ECHO_N "checking whether declaration is required for sbrk... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether declaration is required for sbrk" >&5
++echo $ECHO_N "checking whether declaration is required for sbrk... $ECHO_C" >&6; }
+ if test "${gas_cv_decl_needed_sbrk+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -10941,39 +11388,36 @@ x = (f) sbrk;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gas_cv_decl_needed_sbrk=no
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gas_cv_decl_needed_sbrk=yes
++      gas_cv_decl_needed_sbrk=yes
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gas_cv_decl_needed_sbrk" >&5
+-echo "${ECHO_T}$gas_cv_decl_needed_sbrk" >&6
++{ echo "$as_me:$LINENO: result: $gas_cv_decl_needed_sbrk" >&5
++echo "${ECHO_T}$gas_cv_decl_needed_sbrk" >&6; }
+ if test $gas_cv_decl_needed_sbrk = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -10983,8 +11427,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether declaration is required for strstr" >&5
+-echo $ECHO_N "checking whether declaration is required for strstr... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether declaration is required for strstr" >&5
++echo $ECHO_N "checking whether declaration is required for strstr... $ECHO_C" >&6; }
+ if test "${gas_cv_decl_needed_strstr+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11008,39 +11452,36 @@ x = (f) strstr;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gas_cv_decl_needed_strstr=no
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gas_cv_decl_needed_strstr=yes
++      gas_cv_decl_needed_strstr=yes
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gas_cv_decl_needed_strstr" >&5
+-echo "${ECHO_T}$gas_cv_decl_needed_strstr" >&6
++{ echo "$as_me:$LINENO: result: $gas_cv_decl_needed_strstr" >&5
++echo "${ECHO_T}$gas_cv_decl_needed_strstr" >&6; }
+ if test $gas_cv_decl_needed_strstr = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -11050,8 +11491,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether vsnprintf is declared" >&5
+-echo $ECHO_N "checking whether vsnprintf is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether vsnprintf is declared" >&5
++echo $ECHO_N "checking whether vsnprintf is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_vsnprintf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -11066,7 +11507,7 @@ int
+ main ()
+ {
+ #ifndef vsnprintf
+-  char *p = (char *) vsnprintf;
++  (void) vsnprintf;
+ #endif
+   ;
+@@ -11074,38 +11515,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_vsnprintf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_vsnprintf=no
++      ac_cv_have_decl_vsnprintf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_vsnprintf" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_vsnprintf" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_vsnprintf" >&5
++echo "${ECHO_T}$ac_cv_have_decl_vsnprintf" >&6; }
+ if test $ac_cv_have_decl_vsnprintf = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -11129,9 +11566,9 @@ fi
+-                              ac_config_files="$ac_config_files Makefile doc/Makefile po/Makefile.in:po/Make-in"
++ac_config_files="$ac_config_files Makefile doc/Makefile po/Makefile.in:po/Make-in"
+-          ac_config_commands="$ac_config_commands default"
++ac_config_commands="$ac_config_commands default"
+ cat >confcache <<\_ACEOF
+@@ -11152,39 +11589,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -11193,32 +11649,18 @@ test "x$prefix" = xNONE && prefix=$ac_de
+ # Let make expand exec_prefix.
+ test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+-# VPATH may cause trouble with some makes, so we remove $(srcdir),
+-# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+-# trailing colons and then remove the whole line if VPATH becomes empty
+-# (actually we leave an empty line to preserve line numbers).
+-if test "x$srcdir" = x.; then
+-  ac_vpsub='/^[        ]*VPATH[        ]*=/{
+-s/:*\$(srcdir):*/:/;
+-s/:*\${srcdir}:*/:/;
+-s/:*@srcdir@:*/:/;
+-s/^\([^=]*=[   ]*\):*/\1/;
+-s/:*$//;
+-s/^[^=]*=[     ]*$//;
+-}'
+-fi
+-
+ DEFS=-DHAVE_CONFIG_H
+ ac_libobjs=
+ ac_ltlibobjs=
+ for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+   # 1. Remove the extension, and $U if already installed.
+-  ac_i=`echo "$ac_i" |
+-       sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
+-  # 2. Add them.
+-  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
+-  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
++  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
++  ac_i=`echo "$ac_i" | sed "$ac_script"`
++  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
++  #    will be set to the directory where LIBOBJS objects are built.
++  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
++  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
+ done
+ LIBOBJS=$ac_libobjs
+@@ -11270,17 +11712,45 @@ cat >>$CONFIG_STATUS <<\_ACEOF
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -11290,8 +11760,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -11305,18 +11810,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -11324,159 +11830,120 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-
+-
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
+-fi
++# CDPATH.
++$as_unset CDPATH
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+-echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
+-    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
+-       /*)
+-         if ("$as_dir/$as_base" -c '
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
+-    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+-echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
++  chmod +x "$as_me.lineno" ||
++    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -11485,7 +11952,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -11493,32 +11981,15 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ # Sed expression to map a string onto a valid variable name.
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
+-
++
+ exec 6>&1
+-# Open the log real soon, to keep \$[0] and so on meaningful, and to
++# Save the log message, to keep $[0] and so on meaningful, and to
+ # report actual input values of CONFIG_FILES etc. instead of their
+-# values after options handling.  Logging --version etc. is OK.
+-exec 5>>config.log
+-{
+-  echo
+-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+-## Running $as_me. ##
+-_ASBOX
+-} >&5
+-cat >&5 <<_CSEOF
+-
++# values after options handling.
++ac_log="
+ This file was extended by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   CONFIG_FILES    = $CONFIG_FILES
+   CONFIG_HEADERS  = $CONFIG_HEADERS
+@@ -11526,30 +11997,20 @@ generated by GNU Autoconf 2.59.  Invocat
+   CONFIG_COMMANDS = $CONFIG_COMMANDS
+   $ $0 $@
+-_CSEOF
+-echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+-echo >&5
++on `(hostname || uname -n) 2>/dev/null | sed 1q`
++"
++
+ _ACEOF
++cat >>$CONFIG_STATUS <<_ACEOF
+ # Files that config.status was made for.
+-if test -n "$ac_config_files"; then
+-  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_headers"; then
+-  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_links"; then
+-  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
+-fi
++config_files="$ac_config_files"
++config_headers="$ac_config_headers"
++config_commands="$ac_config_commands"
+-if test -n "$ac_config_commands"; then
+-  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
+-fi
++_ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-
+ ac_cs_usage="\
+ \`$as_me' instantiates files from templates according to the
+ current configuration.
+@@ -11557,7 +12018,7 @@ current configuration.
+ Usage: $0 [OPTIONS] [FILE]...
+   -h, --help       print this help, then exit
+-  -V, --version    print version number, then exit
++  -V, --version    print version number and configuration settings, then exit
+   -q, --quiet      do not print progress messages
+   -d, --debug      don't remove temporary files
+       --recheck    update $as_me by reconfiguring in the same conditions
+@@ -11576,19 +12037,21 @@ Configuration commands:
+ $config_commands
+ Report bugs to <bug-autoconf@gnu.org>."
+-_ACEOF
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ ac_cs_version="\\
+ config.status
+-configured by $0, generated by GNU Autoconf 2.59,
+-  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
++configured by $0, generated by GNU Autoconf 2.61,
++  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 2006 Free Software Foundation, Inc.
+ This config.status script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it."
+-srcdir=$srcdir
+-INSTALL="$INSTALL"
++
++ac_pwd='$ac_pwd'
++srcdir='$srcdir'
++INSTALL='$INSTALL'
+ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+@@ -11599,39 +12062,24 @@ while test $# != 0
+ do
+   case $1 in
+   --*=*)
+-    ac_option=`expr "x$1" : 'x\([^=]*\)='`
+-    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
++    ac_option=`expr "X$1" : 'X\([^=]*\)='`
++    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+     ac_shift=:
+     ;;
+-  -*)
++  *)
+     ac_option=$1
+     ac_optarg=$2
+     ac_shift=shift
+     ;;
+-  *) # This is not an option, so the user has probably given explicit
+-     # arguments.
+-     ac_option=$1
+-     ac_need_defaults=false;;
+   esac
+   case $ac_option in
+   # Handling of the options.
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+     ac_cs_recheck=: ;;
+-  --version | --vers* | -V )
+-    echo "$ac_cs_version"; exit 0 ;;
+-  --he | --h)
+-    # Conflict between --help and --header
+-    { { echo "$as_me:$LINENO: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&2;}
+-   { (exit 1); exit 1; }; };;
+-  --help | --hel | -h )
+-    echo "$ac_cs_usage"; exit 0 ;;
+-  --debug | --d* | -d )
++  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
++    echo "$ac_cs_version"; exit ;;
++  --debug | --debu | --deb | --de | --d | -d )
+     debug=: ;;
+   --file | --fil | --fi | --f )
+     $ac_shift
+@@ -11641,18 +12089,24 @@ Try \`$0 --help' for more information." 
+     $ac_shift
+     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+     ac_need_defaults=false;;
++  --he | --h)
++    # Conflict between --help and --header
++    { echo "$as_me: error: ambiguous option: $1
++Try \`$0 --help' for more information." >&2
++   { (exit 1); exit 1; }; };;
++  --help | --hel | -h )
++    echo "$ac_cs_usage"; exit ;;
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil | --si | --s)
+     ac_cs_silent=: ;;
+   # This is an error.
+-  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&2;}
++  -*) { echo "$as_me: error: unrecognized option: $1
++Try \`$0 --help' for more information." >&2
+    { (exit 1); exit 1; }; } ;;
+-  *) ac_config_targets="$ac_config_targets $1" ;;
++  *) ac_config_targets="$ac_config_targets $1"
++     ac_need_defaults=false ;;
+   esac
+   shift
+@@ -11668,17 +12122,28 @@ fi
+ _ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ if \$ac_cs_recheck; then
+-  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
+-  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
++  echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
++  CONFIG_SHELL=$SHELL
++  export CONFIG_SHELL
++  exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+ fi
+ _ACEOF
++cat >>$CONFIG_STATUS <<\_ACEOF
++exec 5>>config.log
++{
++  echo
++  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
++## Running $as_me. ##
++_ASBOX
++  echo "$ac_log"
++} >&5
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ #
+-# INIT-COMMANDS section.
++# INIT-COMMANDS
+ #
+-
+ AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+ target_cpu_type=${target_cpu_type}
+  cgen_cpu_prefix=${cgen_cpu_prefix}
+@@ -11687,27 +12152,28 @@ target_cpu_type=${target_cpu_type}
+ _ACEOF
+-
+-
+ cat >>$CONFIG_STATUS <<\_ACEOF
++
++# Handling of arguments.
+ for ac_config_target in $ac_config_targets
+ do
+-  case "$ac_config_target" in
+-  # Handling of arguments.
+-  "gdb.ini" ) CONFIG_FILES="$CONFIG_FILES gdb.ini:gdbinit.in" ;;
+-  ".gdbinit" ) CONFIG_FILES="$CONFIG_FILES .gdbinit:gdbinit.in" ;;
+-  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+-  "doc/Makefile" ) CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
+-  "po/Makefile.in" ) CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
+-  "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+-  "default" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
+-  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++  case $ac_config_target in
++    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
++    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++    "gdb.ini") CONFIG_FILES="$CONFIG_FILES gdb.ini:gdbinit.in" ;;
++    ".gdbinit") CONFIG_FILES="$CONFIG_FILES .gdbinit:gdbinit.in" ;;
++    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
++    "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
++    "po/Makefile.in") CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
++    "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
++
+   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+ echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+    { (exit 1); exit 1; }; };;
+   esac
+ done
++
+ # If the user did not use the arguments to specify the items to instantiate,
+ # then the envvar interface is used.  Set only those that are not.
+ # We use the long form for the default assignment because of an extremely
+@@ -11719,388 +12185,493 @@ if $ac_need_defaults; then
+ fi
+ # Have a temporary directory for convenience.  Make it in the build tree
+-# simply because there is no reason to put it here, and in addition,
++# simply because there is no reason against having it here, and in addition,
+ # creating and moving files from /tmp can sometimes cause problems.
+-# Create a temporary directory, and hook for its removal unless debugging.
++# Hook for its removal unless debugging.
++# Note that there is a small window in which the directory will not be cleaned:
++# after its creation but before its name has been assigned to `$tmp'.
+ $debug ||
+ {
+-  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
++  tmp=
++  trap 'exit_status=$?
++  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
++' 0
+   trap '{ (exit 1); exit 1; }' 1 2 13 15
+ }
+-
+ # Create a (secure) tmp directory for tmp files.
+ {
+-  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
++  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+   test -n "$tmp" && test -d "$tmp"
+ }  ||
+ {
+-  tmp=./confstat$$-$RANDOM
+-  (umask 077 && mkdir $tmp)
++  tmp=./conf$$-$RANDOM
++  (umask 077 && mkdir "$tmp")
+ } ||
+ {
+    echo "$me: cannot create a temporary directory in ." >&2
+    { (exit 1); exit 1; }
+ }
+-_ACEOF
+-
+-cat >>$CONFIG_STATUS <<_ACEOF
+-
+ #
+-# CONFIG_FILES section.
++# Set up the sed scripts for CONFIG_FILES section.
+ #
+ # No need to generate the scripts if there are no CONFIG_FILES.
+ # This happens for instance when ./config.status config.h
+-if test -n "\$CONFIG_FILES"; then
+-  # Protect against being on the right side of a sed subst in config.status.
+-  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
+-   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
+-s,@SHELL@,$SHELL,;t t
+-s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
+-s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
+-s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
+-s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
+-s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
+-s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
+-s,@exec_prefix@,$exec_prefix,;t t
+-s,@prefix@,$prefix,;t t
+-s,@program_transform_name@,$program_transform_name,;t t
+-s,@bindir@,$bindir,;t t
+-s,@sbindir@,$sbindir,;t t
+-s,@libexecdir@,$libexecdir,;t t
+-s,@datadir@,$datadir,;t t
+-s,@sysconfdir@,$sysconfdir,;t t
+-s,@sharedstatedir@,$sharedstatedir,;t t
+-s,@localstatedir@,$localstatedir,;t t
+-s,@libdir@,$libdir,;t t
+-s,@includedir@,$includedir,;t t
+-s,@oldincludedir@,$oldincludedir,;t t
+-s,@infodir@,$infodir,;t t
+-s,@mandir@,$mandir,;t t
+-s,@build_alias@,$build_alias,;t t
+-s,@host_alias@,$host_alias,;t t
+-s,@target_alias@,$target_alias,;t t
+-s,@DEFS@,$DEFS,;t t
+-s,@ECHO_C@,$ECHO_C,;t t
+-s,@ECHO_N@,$ECHO_N,;t t
+-s,@ECHO_T@,$ECHO_T,;t t
+-s,@LIBS@,$LIBS,;t t
+-s,@build@,$build,;t t
+-s,@build_cpu@,$build_cpu,;t t
+-s,@build_vendor@,$build_vendor,;t t
+-s,@build_os@,$build_os,;t t
+-s,@host@,$host,;t t
+-s,@host_cpu@,$host_cpu,;t t
+-s,@host_vendor@,$host_vendor,;t t
+-s,@host_os@,$host_os,;t t
+-s,@target@,$target,;t t
+-s,@target_cpu@,$target_cpu,;t t
+-s,@target_vendor@,$target_vendor,;t t
+-s,@target_os@,$target_os,;t t
+-s,@CC@,$CC,;t t
+-s,@CFLAGS@,$CFLAGS,;t t
+-s,@LDFLAGS@,$LDFLAGS,;t t
+-s,@CPPFLAGS@,$CPPFLAGS,;t t
+-s,@ac_ct_CC@,$ac_ct_CC,;t t
+-s,@EXEEXT@,$EXEEXT,;t t
+-s,@OBJEXT@,$OBJEXT,;t t
+-s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
+-s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
+-s,@INSTALL_DATA@,$INSTALL_DATA,;t t
+-s,@CYGPATH_W@,$CYGPATH_W,;t t
+-s,@PACKAGE@,$PACKAGE,;t t
+-s,@VERSION@,$VERSION,;t t
+-s,@ACLOCAL@,$ACLOCAL,;t t
+-s,@AUTOCONF@,$AUTOCONF,;t t
+-s,@AUTOMAKE@,$AUTOMAKE,;t t
+-s,@AUTOHEADER@,$AUTOHEADER,;t t
+-s,@MAKEINFO@,$MAKEINFO,;t t
+-s,@install_sh@,$install_sh,;t t
+-s,@STRIP@,$STRIP,;t t
+-s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
+-s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
+-s,@mkdir_p@,$mkdir_p,;t t
+-s,@AWK@,$AWK,;t t
+-s,@SET_MAKE@,$SET_MAKE,;t t
+-s,@am__leading_dot@,$am__leading_dot,;t t
+-s,@AMTAR@,$AMTAR,;t t
+-s,@am__tar@,$am__tar,;t t
+-s,@am__untar@,$am__untar,;t t
+-s,@DEPDIR@,$DEPDIR,;t t
+-s,@am__include@,$am__include,;t t
+-s,@am__quote@,$am__quote,;t t
+-s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
+-s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
+-s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
+-s,@CCDEPMODE@,$CCDEPMODE,;t t
+-s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
+-s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
+-s,@LN_S@,$LN_S,;t t
+-s,@RANLIB@,$RANLIB,;t t
+-s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
+-s,@LIBTOOL@,$LIBTOOL,;t t
+-s,@WARN_CFLAGS@,$WARN_CFLAGS,;t t
+-s,@NO_WERROR@,$NO_WERROR,;t t
+-s,@GDBINIT@,$GDBINIT,;t t
+-s,@cgen_cpu_prefix@,$cgen_cpu_prefix,;t t
+-s,@extra_objects@,$extra_objects,;t t
+-s,@target_cpu_type@,$target_cpu_type,;t t
+-s,@obj_format@,$obj_format,;t t
+-s,@te_file@,$te_file,;t t
+-s,@install_tooldir@,$install_tooldir,;t t
+-s,@atof@,$atof,;t t
+-s,@BFDLIB@,$BFDLIB,;t t
+-s,@OPCODES_LIB@,$OPCODES_LIB,;t t
+-s,@BFDVER_H@,$BFDVER_H,;t t
+-s,@ALL_OBJ_DEPS@,$ALL_OBJ_DEPS,;t t
+-s,@YACC@,$YACC,;t t
+-s,@LEX@,$LEX,;t t
+-s,@LEXLIB@,$LEXLIB,;t t
+-s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
+-s,@CPP@,$CPP,;t t
+-s,@EGREP@,$EGREP,;t t
+-s,@ALLOCA@,$ALLOCA,;t t
+-s,@USE_NLS@,$USE_NLS,;t t
+-s,@MSGFMT@,$MSGFMT,;t t
+-s,@GMSGFMT@,$GMSGFMT,;t t
+-s,@XGETTEXT@,$XGETTEXT,;t t
+-s,@USE_INCLUDED_LIBINTL@,$USE_INCLUDED_LIBINTL,;t t
+-s,@CATALOGS@,$CATALOGS,;t t
+-s,@CATOBJEXT@,$CATOBJEXT,;t t
+-s,@DATADIRNAME@,$DATADIRNAME,;t t
+-s,@GMOFILES@,$GMOFILES,;t t
+-s,@INSTOBJEXT@,$INSTOBJEXT,;t t
+-s,@INTLDEPS@,$INTLDEPS,;t t
+-s,@INTLLIBS@,$INTLLIBS,;t t
+-s,@INTLOBJS@,$INTLOBJS,;t t
+-s,@POFILES@,$POFILES,;t t
+-s,@POSUB@,$POSUB,;t t
+-s,@INCLUDE_LOCALE_H@,$INCLUDE_LOCALE_H,;t t
+-s,@GT_NO@,$GT_NO,;t t
+-s,@GT_YES@,$GT_YES,;t t
+-s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t
+-s,@l@,$l,;t t
+-s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
+-s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
+-s,@MAINT@,$MAINT,;t t
+-s,@LIBM@,$LIBM,;t t
+-s,@datarootdir@,$datarootdir,;t t
+-s,@docdir@,$docdir,;t t
+-s,@htmldir@,$htmldir,;t t
+-s,@LIBOBJS@,$LIBOBJS,;t t
+-s,@LTLIBOBJS@,$LTLIBOBJS,;t t
+-CEOF
+-
+-_ACEOF
+-
+-  cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Split the substitutions into bite-sized pieces for seds with
+-  # small command number limits, like on Digital OSF/1 and HP-UX.
+-  ac_max_sed_lines=48
+-  ac_sed_frag=1 # Number of current file.
+-  ac_beg=1 # First line for current file.
+-  ac_end=$ac_max_sed_lines # Line after last line for current file.
+-  ac_more_lines=:
+-  ac_sed_cmds=
+-  while $ac_more_lines; do
+-    if test $ac_beg -gt 1; then
+-      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    else
+-      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    fi
+-    if test ! -s $tmp/subs.frag; then
+-      ac_more_lines=false
+-    else
+-      # The purpose of the label and of the branching condition is to
+-      # speed up the sed processing (if there are no `@' at all, there
+-      # is no need to browse any of the substitutions).
+-      # These are the two extra sed commands mentioned above.
+-      (echo ':t
+-  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
+-      if test -z "$ac_sed_cmds"; then
+-      ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
+-      else
+-      ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
+-      fi
+-      ac_sed_frag=`expr $ac_sed_frag + 1`
+-      ac_beg=$ac_end
+-      ac_end=`expr $ac_end + $ac_max_sed_lines`
+-    fi
+-  done
+-  if test -z "$ac_sed_cmds"; then
+-    ac_sed_cmds=cat
++if test -n "$CONFIG_FILES"; then
++
++_ACEOF
++
++
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++SHELL!$SHELL$ac_delim
++PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim
++PACKAGE_NAME!$PACKAGE_NAME$ac_delim
++PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim
++PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim
++PACKAGE_STRING!$PACKAGE_STRING$ac_delim
++PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim
++exec_prefix!$exec_prefix$ac_delim
++prefix!$prefix$ac_delim
++program_transform_name!$program_transform_name$ac_delim
++bindir!$bindir$ac_delim
++sbindir!$sbindir$ac_delim
++libexecdir!$libexecdir$ac_delim
++datarootdir!$datarootdir$ac_delim
++datadir!$datadir$ac_delim
++sysconfdir!$sysconfdir$ac_delim
++sharedstatedir!$sharedstatedir$ac_delim
++localstatedir!$localstatedir$ac_delim
++includedir!$includedir$ac_delim
++oldincludedir!$oldincludedir$ac_delim
++docdir!$docdir$ac_delim
++infodir!$infodir$ac_delim
++htmldir!$htmldir$ac_delim
++dvidir!$dvidir$ac_delim
++pdfdir!$pdfdir$ac_delim
++psdir!$psdir$ac_delim
++libdir!$libdir$ac_delim
++localedir!$localedir$ac_delim
++mandir!$mandir$ac_delim
++DEFS!$DEFS$ac_delim
++ECHO_C!$ECHO_C$ac_delim
++ECHO_N!$ECHO_N$ac_delim
++ECHO_T!$ECHO_T$ac_delim
++LIBS!$LIBS$ac_delim
++build_alias!$build_alias$ac_delim
++host_alias!$host_alias$ac_delim
++target_alias!$target_alias$ac_delim
++build!$build$ac_delim
++build_cpu!$build_cpu$ac_delim
++build_vendor!$build_vendor$ac_delim
++build_os!$build_os$ac_delim
++host!$host$ac_delim
++host_cpu!$host_cpu$ac_delim
++host_vendor!$host_vendor$ac_delim
++host_os!$host_os$ac_delim
++target!$target$ac_delim
++target_cpu!$target_cpu$ac_delim
++target_vendor!$target_vendor$ac_delim
++target_os!$target_os$ac_delim
++CC!$CC$ac_delim
++CFLAGS!$CFLAGS$ac_delim
++LDFLAGS!$LDFLAGS$ac_delim
++CPPFLAGS!$CPPFLAGS$ac_delim
++ac_ct_CC!$ac_ct_CC$ac_delim
++EXEEXT!$EXEEXT$ac_delim
++OBJEXT!$OBJEXT$ac_delim
++INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
++INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim
++INSTALL_DATA!$INSTALL_DATA$ac_delim
++CYGPATH_W!$CYGPATH_W$ac_delim
++PACKAGE!$PACKAGE$ac_delim
++VERSION!$VERSION$ac_delim
++ACLOCAL!$ACLOCAL$ac_delim
++AUTOCONF!$AUTOCONF$ac_delim
++AUTOMAKE!$AUTOMAKE$ac_delim
++AUTOHEADER!$AUTOHEADER$ac_delim
++MAKEINFO!$MAKEINFO$ac_delim
++install_sh!$install_sh$ac_delim
++STRIP!$STRIP$ac_delim
++INSTALL_STRIP_PROGRAM!$INSTALL_STRIP_PROGRAM$ac_delim
++mkdir_p!$mkdir_p$ac_delim
++AWK!$AWK$ac_delim
++SET_MAKE!$SET_MAKE$ac_delim
++am__leading_dot!$am__leading_dot$ac_delim
++AMTAR!$AMTAR$ac_delim
++am__tar!$am__tar$ac_delim
++am__untar!$am__untar$ac_delim
++DEPDIR!$DEPDIR$ac_delim
++am__include!$am__include$ac_delim
++am__quote!$am__quote$ac_delim
++AMDEP_TRUE!$AMDEP_TRUE$ac_delim
++AMDEP_FALSE!$AMDEP_FALSE$ac_delim
++AMDEPBACKSLASH!$AMDEPBACKSLASH$ac_delim
++CCDEPMODE!$CCDEPMODE$ac_delim
++am__fastdepCC_TRUE!$am__fastdepCC_TRUE$ac_delim
++am__fastdepCC_FALSE!$am__fastdepCC_FALSE$ac_delim
++LN_S!$LN_S$ac_delim
++RANLIB!$RANLIB$ac_delim
++LIBTOOL!$LIBTOOL$ac_delim
++WARN_CFLAGS!$WARN_CFLAGS$ac_delim
++NO_WERROR!$NO_WERROR$ac_delim
++GDBINIT!$GDBINIT$ac_delim
++CPP!$CPP$ac_delim
++GREP!$GREP$ac_delim
++EGREP!$EGREP$ac_delim
++cgen_cpu_prefix!$cgen_cpu_prefix$ac_delim
++extra_objects!$extra_objects$ac_delim
++_ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+   fi
+-fi # test -n "$CONFIG_FILES"
++done
++
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
++_ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++CEOF$ac_eof
++_ACEOF
++
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++target_cpu_type!$target_cpu_type$ac_delim
++obj_format!$obj_format$ac_delim
++te_file!$te_file$ac_delim
++install_tooldir!$install_tooldir$ac_delim
++atof!$atof$ac_delim
++BFDLIB!$BFDLIB$ac_delim
++OPCODES_LIB!$OPCODES_LIB$ac_delim
++BFDVER_H!$BFDVER_H$ac_delim
++ALL_OBJ_DEPS!$ALL_OBJ_DEPS$ac_delim
++YACC!$YACC$ac_delim
++YFLAGS!$YFLAGS$ac_delim
++LEX!$LEX$ac_delim
++LEX_OUTPUT_ROOT!$LEX_OUTPUT_ROOT$ac_delim
++LEXLIB!$LEXLIB$ac_delim
++ALLOCA!$ALLOCA$ac_delim
++USE_NLS!$USE_NLS$ac_delim
++MSGFMT!$MSGFMT$ac_delim
++GMSGFMT!$GMSGFMT$ac_delim
++XGETTEXT!$XGETTEXT$ac_delim
++USE_INCLUDED_LIBINTL!$USE_INCLUDED_LIBINTL$ac_delim
++CATALOGS!$CATALOGS$ac_delim
++CATOBJEXT!$CATOBJEXT$ac_delim
++DATADIRNAME!$DATADIRNAME$ac_delim
++GMOFILES!$GMOFILES$ac_delim
++INSTOBJEXT!$INSTOBJEXT$ac_delim
++INTLDEPS!$INTLDEPS$ac_delim
++INTLLIBS!$INTLLIBS$ac_delim
++INTLOBJS!$INTLOBJS$ac_delim
++POFILES!$POFILES$ac_delim
++POSUB!$POSUB$ac_delim
++INCLUDE_LOCALE_H!$INCLUDE_LOCALE_H$ac_delim
++GT_NO!$GT_NO$ac_delim
++GT_YES!$GT_YES$ac_delim
++MKINSTALLDIRS!$MKINSTALLDIRS$ac_delim
++l!$l$ac_delim
++MAINTAINER_MODE_TRUE!$MAINTAINER_MODE_TRUE$ac_delim
++MAINTAINER_MODE_FALSE!$MAINTAINER_MODE_FALSE$ac_delim
++MAINT!$MAINT$ac_delim
++LIBM!$LIBM$ac_delim
++LIBOBJS!$LIBOBJS$ac_delim
++LTLIBOBJS!$LTLIBOBJS$ac_delim
++_ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 41; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
++  fi
++done
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-2.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end
++_ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++:end
++s/|#_!!_#|//g
++CEOF$ac_eof
+ _ACEOF
++
++
++# VPATH may cause trouble with some makes, so we remove $(srcdir),
++# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
++# trailing colons and then remove the whole line if VPATH becomes empty
++# (actually we leave an empty line to preserve line numbers).
++if test "x$srcdir" = x.; then
++  ac_vpsub='/^[        ]*VPATH[        ]*=/{
++s/:*\$(srcdir):*/:/
++s/:*\${srcdir}:*/:/
++s/:*@srcdir@:*/:/
++s/^\([^=]*=[   ]*\):*/\1/
++s/:*$//
++s/^[^=]*=[     ]*$//
++}'
++fi
++
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+-  case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++fi # test -n "$CONFIG_FILES"
++
++
++for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS
++do
++  case $ac_tag in
++  :[FHLC]) ac_mode=$ac_tag; continue;;
++  esac
++  case $ac_mode$ac_tag in
++  :[FHL]*:*);;
++  :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
++echo "$as_me: error: Invalid tag $ac_tag." >&2;}
++   { (exit 1); exit 1; }; };;
++  :[FH]-) ac_tag=-:-;;
++  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
++  esac
++  ac_save_IFS=$IFS
++  IFS=:
++  set x $ac_tag
++  IFS=$ac_save_IFS
++  shift
++  ac_file=$1
++  shift
++
++  case $ac_mode in
++  :L) ac_source=$1;;
++  :[FH])
++    ac_file_inputs=
++    for ac_f
++    do
++      case $ac_f in
++      -) ac_f="$tmp/stdin";;
++      *) # Look for the file first in the build tree, then in the source tree
++       # (if the path is not absolute).  The absolute path cannot be DOS-style,
++       # because $ac_f cannot contain `:'.
++       test -f "$ac_f" ||
++         case $ac_f in
++         [\\/$]*) false;;
++         *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
++         esac ||
++         { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
++echo "$as_me: error: cannot find input file: $ac_f" >&2;}
++   { (exit 1); exit 1; }; };;
++      esac
++      ac_file_inputs="$ac_file_inputs $ac_f"
++    done
++
++    # Let's still pretend it is `configure' which instantiates (i.e., don't
++    # use $as_me), people would be surprised to read:
++    #    /* config.h.  Generated by config.status.  */
++    configure_input="Generated from "`IFS=:
++        echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."
++    if test x"$ac_file" != x-; then
++      configure_input="$ac_file.  $configure_input"
++      { echo "$as_me:$LINENO: creating $ac_file" >&5
++echo "$as_me: creating $ac_file" >&6;}
++    fi
++
++    case $ac_tag in
++    *:-:* | *:-) cat >"$tmp/stdin";;
++    esac
++    ;;
+   esac
+-  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
+-  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
++  ac_dir=`$as_dirname -- "$ac_file" ||
+ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$ac_file" : 'X\(//\)[^/]' \| \
+        X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++  { as_dir="$ac_dir"
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+   ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  case $ac_mode in
++  :F)
++  #
++  # CONFIG_FILE
++  #
+   case $INSTALL in
+   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+-  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
++  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+   esac
++_ACEOF
+-  if test x"$ac_file" != x-; then
+-    { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-    rm -f "$ac_file"
+-  fi
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    configure_input=
+-  else
+-    configure_input="$ac_file.  "
+-  fi
+-  configure_input=$configure_input"Generated from `echo $ac_file_in |
+-                                   sed 's,.*/,,'` by configure."
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
++cat >>$CONFIG_STATUS <<\_ACEOF
++# If the template does not know about datarootdir, expand it.
++# FIXME: This hack should be removed a few years after 2.60.
++ac_datarootdir_hack=; ac_datarootdir_seen=
++
++case `sed -n '/datarootdir/ {
++  p
++  q
++}
++/@datadir@/p
++/@docdir@/p
++/@infodir@/p
++/@localedir@/p
++/@mandir@/p
++' $ac_file_inputs` in
++*datarootdir*) ac_datarootdir_seen=yes;;
++*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
++  { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
++echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
++_ACEOF
++cat >>$CONFIG_STATUS <<_ACEOF
++  ac_datarootdir_hack='
++  s&@datadir@&$datadir&g
++  s&@docdir@&$docdir&g
++  s&@infodir@&$infodir&g
++  s&@localedir@&$localedir&g
++  s&@mandir@&$mandir&g
++    s&\\\${datarootdir}&$datarootdir&g' ;;
++esac
+ _ACEOF
++
++# Neutralize VPATH when `$srcdir' = `.'.
++# Shell code in configure.ac might set extrasub.
++# FIXME: do we really want to maintain this feature?
+ cat >>$CONFIG_STATUS <<_ACEOF
+   sed "$ac_vpsub
+ $extrasub
+@@ -12108,248 +12679,130 @@ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+ :t
+ /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+-s,@configure_input@,$configure_input,;t t
+-s,@srcdir@,$ac_srcdir,;t t
+-s,@abs_srcdir@,$ac_abs_srcdir,;t t
+-s,@top_srcdir@,$ac_top_srcdir,;t t
+-s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+-s,@builddir@,$ac_builddir,;t t
+-s,@abs_builddir@,$ac_abs_builddir,;t t
+-s,@top_builddir@,$ac_top_builddir,;t t
+-s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
+-s,@INSTALL@,$ac_INSTALL,;t t
+-" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
+-  rm -f $tmp/stdin
+-  if test x"$ac_file" != x-; then
+-    mv $tmp/out $ac_file
+-  else
+-    cat $tmp/out
+-    rm -f $tmp/out
+-  fi
+-
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_HEADER section.
+-#
+-
+-# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
+-# NAME is the cpp macro being defined and VALUE is the value it is being given.
+-#
+-# ac_d sets the value in "#define NAME VALUE" lines.
+-ac_dA='s,^\([  ]*\)#\([        ]*define[       ][      ]*\)'
+-ac_dB='[       ].*$,\1#\2'
+-ac_dC=' '
+-ac_dD=',;t'
+-# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
+-ac_uA='s,^\([  ]*\)#\([        ]*\)undef\([    ][      ]*\)'
+-ac_uB='$,\1#\2define\3'
+-ac_uC=' '
+-ac_uD=',;t'
++s&@configure_input@&$configure_input&;t t
++s&@top_builddir@&$ac_top_builddir_sub&;t t
++s&@srcdir@&$ac_srcdir&;t t
++s&@abs_srcdir@&$ac_abs_srcdir&;t t
++s&@top_srcdir@&$ac_top_srcdir&;t t
++s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
++s&@builddir@&$ac_builddir&;t t
++s&@abs_builddir@&$ac_abs_builddir&;t t
++s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
++s&@INSTALL@&$ac_INSTALL&;t t
++$ac_datarootdir_hack
++" $ac_file_inputs | sed -f "$tmp/subs-1.sed" | sed -f "$tmp/subs-2.sed" >$tmp/out
++
++test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
++  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
++  { ac_out=`sed -n '/^[        ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
++  { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&5
++echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&2;}
+-for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
++  rm -f "$tmp/stdin"
+   case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++  -) cat "$tmp/out"; rm -f "$tmp/out";;
++  *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;
+   esac
++ ;;
++  :H)
++  #
++  # CONFIG_HEADER
++  #
++_ACEOF
++
++# Transform confdefs.h into a sed script `conftest.defines', that
++# substitutes the proper values into config.h.in to produce config.h.
++rm -f conftest.defines conftest.tail
++# First, append a space to every undef/define line, to ease matching.
++echo 's/$/ /' >conftest.defines
++# Then, protect against being on the right side of a sed subst, or in
++# an unquoted here document, in config.status.  If some macros were
++# called several times there might be several #defines for the same
++# symbol, which is useless.  But do not sort them, since the last
++# AC_DEFINE must be honored.
++ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
++# These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where
++# NAME is the cpp macro being defined, VALUE is the value it is being given.
++# PARAMS is the parameter list in the macro definition--in most cases, it's
++# just an empty string.
++ac_dA='s,^\\([         #]*\\)[^        ]*\\([  ]*'
++ac_dB='\\)[    (].*,\\1define\\2'
++ac_dC=' '
++ac_dD=' ,'
+-  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       # Do quote $f, to prevent DOS paths from being IFS'd.
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
+-  # Remove the trailing spaces.
+-  sed 's/[     ]*$//' $ac_file_inputs >$tmp/in
+-
+-_ACEOF
+-
+-# Transform confdefs.h into two sed scripts, `conftest.defines' and
+-# `conftest.undefs', that substitutes the proper values into
+-# config.h.in to produce config.h.  The first handles `#define'
+-# templates, and the second `#undef' templates.
+-# And first: Protect against being on the right side of a sed subst in
+-# config.status.  Protect against being in an unquoted here document
+-# in config.status.
+-rm -f conftest.defines conftest.undefs
+-# Using a here document instead of a string reduces the quoting nightmare.
+-# Putting comments in sed scripts is not portable.
+-#
+-# `end' is used to avoid that the second main sed command (meant for
+-# 0-ary CPP macros) applies to n-ary macro definitions.
+-# See the Autoconf documentation for `clear'.
+-cat >confdef2sed.sed <<\_ACEOF
+-s/[\\&,]/\\&/g
+-s,[\\$`],\\&,g
+-t clear
+-: clear
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
+-t end
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
+-: end
+-_ACEOF
+-# If some macros were called several times there might be several times
+-# the same #defines, which is useless.  Nevertheless, we may not want to
+-# sort them, since we want the *last* AC-DEFINE to be honored.
+-uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
+-sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
+-rm -f confdef2sed.sed
++uniq confdefs.h |
++  sed -n '
++      t rset
++      :rset
++      s/^[     ]*#[    ]*define[       ][      ]*//
++      t ok
++      d
++      :ok
++      s/[\\&,]/\\&/g
++      s/^\('"$ac_word_re"'\)\(([^()]*)\)[      ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p
++      s/^\('"$ac_word_re"'\)[  ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p
++  ' >>conftest.defines
+-# This sed command replaces #undef with comments.  This is necessary, for
++# Remove the space that was appended to ease matching.
++# Then replace #undef with comments.  This is necessary, for
+ # example, in the case of _POSIX_SOURCE, which is predefined and required
+ # on some systems where configure will not decide to define it.
+-cat >>conftest.undefs <<\_ACEOF
+-s,^[   ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
++# (The regexp can be short, since the line contains either #define or #undef.)
++echo 's/ $//
++s,^[   #]*u.*,/* & */,' >>conftest.defines
++
++# Break up conftest.defines:
++ac_max_sed_lines=50
++
++# First sed command is:        sed -f defines.sed $ac_file_inputs >"$tmp/out1"
++# Second one is:       sed -f defines.sed "$tmp/out1" >"$tmp/out2"
++# Third one will be:   sed -f defines.sed "$tmp/out2" >"$tmp/out1"
++# et cetera.
++ac_in='$ac_file_inputs'
++ac_out='"$tmp/out1"'
++ac_nxt='"$tmp/out2"'
++
++while :
++do
++  # Write a here document:
++    cat >>$CONFIG_STATUS <<_ACEOF
++    # First, check the format of the line:
++    cat >"\$tmp/defines.sed" <<\\CEOF
++/^[    ]*#[    ]*undef[        ][      ]*$ac_word_re[  ]*\$/b def
++/^[    ]*#[    ]*define[       ][      ]*$ac_word_re[(         ]/b def
++b
++:def
+ _ACEOF
+-
+-# Break up conftest.defines because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
+-echo '  if grep "^[    ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
+-echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
+-echo '  :' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.defines >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/defines.sed.
+-  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#define' lines.
+-  echo '/^[    ]*#[    ]*define/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
++  sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS
+   echo 'CEOF
+-  sed -f $tmp/defines.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
++    sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS
++  ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in
++  sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail
++  grep . conftest.tail >/dev/null || break
+   rm -f conftest.defines
+   mv conftest.tail conftest.defines
+ done
+-rm -f conftest.defines
+-echo '  fi # grep' >>$CONFIG_STATUS
+-echo >>$CONFIG_STATUS
+-
+-# Break up conftest.undefs because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.undefs >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/undefs.sed.
+-  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#undef'
+-  echo '/^[    ]*#[    ]*undef/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
+-  echo 'CEOF
+-  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
+-  rm -f conftest.undefs
+-  mv conftest.tail conftest.undefs
+-done
+-rm -f conftest.undefs
++rm -f conftest.defines conftest.tail
++echo "ac_result=$ac_in" >>$CONFIG_STATUS
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    echo "/* Generated by configure.  */" >$tmp/config.h
+-  else
+-    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
+-  fi
+-  cat $tmp/in >>$tmp/config.h
+-  rm -f $tmp/in
+   if test x"$ac_file" != x-; then
+-    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
++    echo "/* $configure_input  */" >"$tmp/config.h"
++    cat "$ac_result" >>"$tmp/config.h"
++    if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then
+       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
+ echo "$as_me: $ac_file is unchanged" >&6;}
+     else
+-      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_file" : 'X\(//\)[^/]' \| \
+-       X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-      { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+       rm -f $ac_file
+-      mv $tmp/config.h $ac_file
++      mv "$tmp/config.h" $ac_file
+     fi
+   else
+-    cat $tmp/config.h
+-    rm -f $tmp/config.h
++    echo "/* $configure_input  */"
++    cat "$ac_result"
+   fi
++  rm -f "$tmp/out12"
+ # Compute $ac_file's index in $config_headers.
+ _am_stamp_count=1
+ for _am_header in $config_headers :; do
+@@ -12360,135 +12813,39 @@ for _am_header in $config_headers :; do
+       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+   esac
+ done
+-echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
++echo "timestamp for $ac_file" >`$as_dirname -- $ac_file ||
+ $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X$ac_file : 'X\(//\)[^/]' \| \
+        X$ac_file : 'X\(//\)$' \| \
+-       X$ac_file : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X$ac_file : 'X\(/\)' \| . 2>/dev/null ||
+ echo X$ac_file |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`/stamp-h$_am_stamp_count
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_COMMANDS section.
+-#
+-for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
+-  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
+-  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
+-$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_dest" : 'X\(//\)[^/]' \| \
+-       X"$ac_dest" : 'X\(//\)$' \| \
+-       X"$ac_dest" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_dest" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+-  ac_builddir=.
+-
+-if test "$ac_dir" != .; then
+-  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
+-
+-case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
+-    ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
+-    ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`/stamp-h$_am_stamp_count
++ ;;
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  :C)  { echo "$as_me:$LINENO: executing $ac_file commands" >&5
++echo "$as_me: executing $ac_file commands" >&6;}
++ ;;
++  esac
+-  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
+-echo "$as_me: executing $ac_dest commands" >&6;}
+-  case $ac_dest in
+-    depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
++  case $ac_file$ac_mode in
++    "depfiles":C) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
+   # Strip MF so we end up with the name of the file.
+   mf=`echo "$mf" | sed -e 's/:.*$//'`
+   # Check whether this is an Automake generated Makefile or not.
+@@ -12498,18 +12855,29 @@ echo "$as_me: executing $ac_dest command
+   # each Makefile.in and add a new line on top of each file to say so.
+   # So let's grep whole file.
+   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
+-    dirpart=`(dirname "$mf") 2>/dev/null ||
++    dirpart=`$as_dirname -- "$mf" ||
+ $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$mf" : 'X\(//\)[^/]' \| \
+        X"$mf" : 'X\(//\)$' \| \
+-       X"$mf" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$mf" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   else
+     continue
+   fi
+@@ -12531,49 +12899,76 @@ echo X"$mf" |
+        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+     # Make sure the directory exists.
+     test -f "$dirpart/$file" && continue
+-    fdir=`(dirname "$file") 2>/dev/null ||
++    fdir=`$as_dirname -- "$file" ||
+ $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$file" : 'X\(//\)[^/]' \| \
+        X"$file" : 'X\(//\)$' \| \
+-       X"$file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    { if $as_mkdir_p; then
+-    mkdir -p $dirpart/$fdir
+-  else
+-    as_dir=$dirpart/$fdir
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++    { as_dir=$dirpart/$fdir
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
+-echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+     # echo "creating $dirpart/$file"
+     echo '# dummy' > "$dirpart/$file"
+   done
+ done
+  ;;
+-    default ) rm -f targ-cpu.c targ-cpu.h obj-format.h obj-format.c targ-env.h atof-targ.c itbl-cpu.h
++    "default":C) rm -f targ-cpu.c targ-cpu.h obj-format.h obj-format.c targ-env.h atof-targ.c itbl-cpu.h
+  echo '#include "tc-'"${target_cpu_type}"'.h"' > targ-cpu.h
+  echo '#include "obj-'"${obj_format}"'.h"' > obj-format.h
+  echo '#include "te-'"${te_file}"'.h"' > targ-env.h
+@@ -12583,11 +12978,10 @@ done
+  fi
+  sed -e '/POTFILES =/r po/POTFILES' po/Makefile.in > po/Makefile ;;
++
+   esac
+-done
+-_ACEOF
++done # for ac_tag
+-cat >>$CONFIG_STATUS <<\_ACEOF
+ { (exit 0); exit 0; }
+ _ACEOF
+diff -Nrup binutils-2.17/gas/configure.tgt binutils-2.17-atmel/gas/configure.tgt
+--- binutils-2.17/gas/configure.tgt    2006-04-05 14:41:57.000000000 +0200
++++ binutils-2.17-atmel/gas/configure.tgt      2007-02-12 15:37:09.000000000 +0100
+@@ -33,6 +33,7 @@ case ${cpu} in
+   am33_2.0)           cpu_type=mn10300 endian=little ;;
+   arm*be|arm*b)               cpu_type=arm endian=big ;;
+   arm*)                       cpu_type=arm endian=little ;;
++  avr32*)             cpu_type=avr32 endian=big ;;
+   bfin*)              cpu_type=bfin endian=little ;;
+   c4x*)                       cpu_type=tic4x ;;
+   crisv32)            cpu_type=cris arch=crisv32 ;;
+@@ -122,6 +123,9 @@ case ${generic_target} in
+   bfin-*-*)                           fmt=elf bfd_gas=yes ;;
+   bfin-*elf)                          fmt=elf ;;
++  avr32-*-linux*)                     fmt=elf  em=linux bfd_gas=yes ;;
++  avr32*)                             fmt=elf  bfd_gas=yes ;;
++
+   cris-*-linux-* | crisv32-*-linux-*)
+                                       fmt=multi em=linux ;;
+   cris-*-* | crisv32-*-*)             fmt=multi ;;
+diff -Nrup binutils-2.17/gas/doc/all.texi binutils-2.17-atmel/gas/doc/all.texi
+--- binutils-2.17/gas/doc/all.texi     2006-02-17 15:36:25.000000000 +0100
++++ binutils-2.17-atmel/gas/doc/all.texi       2007-02-12 15:37:09.000000000 +0100
+@@ -29,6 +29,7 @@
+ @set ALPHA
+ @set ARC
+ @set ARM
++@set AVR32
+ @set BFIN
+ @set CRIS
+ @set D10V
+diff -Nrup binutils-2.17/gas/doc/as.texinfo binutils-2.17-atmel/gas/doc/as.texinfo
+--- binutils-2.17/gas/doc/as.texinfo   2006-04-17 17:16:27.000000000 +0200
++++ binutils-2.17-atmel/gas/doc/as.texinfo     2007-02-12 15:37:09.000000000 +0100
+@@ -6182,6 +6182,9 @@ subject, see the hardware manufacturer's
+ @ifset ARM
+ * ARM-Dependent::               ARM Dependent Features
+ @end ifset
++@ifset AVR32
++* AVR32-Dependent::             AVR32 Dependent Features
++@end ifset
+ @ifset BFIN
+ * BFIN-Dependent::            BFIN Dependent Features
+ @end ifset
+@@ -6298,6 +6301,10 @@ subject, see the hardware manufacturer's
+ @include c-arm.texi
+ @end ifset
++@ifset AVR32
++@include c-avr32.texi
++@end ifset
++
+ @ifset BFIN
+ @include c-bfin.texi
+ @end ifset
+diff -Nrup binutils-2.17/gas/doc/c-avr32.texi binutils-2.17-atmel/gas/doc/c-avr32.texi
+--- binutils-2.17/gas/doc/c-avr32.texi 1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/doc/c-avr32.texi   2006-09-25 10:30:13.000000000 +0200
+@@ -0,0 +1,247 @@
++@c Copyright 2005, 2006
++@c Atmel Corporation
++@c This is part of the GAS manual.
++@c For copying conditions, see the file as.texinfo.
++
++@ifset GENERIC
++@page
++@node AVR32-Dependent
++@chapter AVR32 Dependent Features
++@end ifset
++
++@ifclear GENERIC
++@node Machine Dependencies
++@chapter AVR32 Dependent Features
++@end ifclear
++
++@cindex AVR32 support
++@menu
++* AVR32 Options::               Options
++* AVR32 Syntax::                Syntax
++* AVR32 Directives::            Directives
++* AVR32 Opcodes::               Opcodes
++@end menu
++
++@node AVR32 Options
++@section Options
++@cindex AVR32 options
++@cindex options for AVR32
++
++There are currently no AVR32-specific options.  However, the following
++options are planned:
++
++@table @code
++
++@cindex @code{--pic} command line option, AVR32
++@cindex PIC code generation for AVR32
++@item --pic
++This option specifies that the output of the assembler should be marked
++as position-independent code (PIC).  It will also ensure that
++pseudo-instructions that deal with address calculation are output as
++PIC, and that all absolute address references in the code are marked as
++such.
++
++@cindex @code{--linkrelax} command line option, AVR32
++@item --linkrelax
++This option specifies that the output of the assembler should be marked
++as linker-relaxable.  It will also ensure that all PC-relative operands
++that may change during linker relaxation get appropriate relocations.
++
++@end table
++
++
++@node AVR32 Syntax
++@section Syntax
++@menu
++* AVR32-Chars::              Special Characters
++* AVR32-Symrefs::            Symbol references
++@end menu
++
++@node AVR32-Chars
++@subsection Special Characters
++
++@cindex line comment character, AVR32
++@cindex AVR32 line comment character
++The presence of a @samp{//} on a line indicates the start of a comment
++that extends to the end of the current line.  If a @samp{#} appears as
++the first character of a line, the whole line is treated as a comment.
++
++@cindex line separator, AVR32
++@cindex statement separator, AVR32
++@cindex AVR32 line separator
++The @samp{;} character can be used instead of a newline to separate
++statements.
++
++@node AVR32-Symrefs
++@subsection Symbol references
++
++The absolute value of a symbol can be obtained by simply naming the
++symbol.  However, as AVR32 symbols have 32-bit values, most symbols have
++values that are outside the range of any instructions.
++
++Instructions that take a PC-relative offset, e.g. @code{lddpc} or
++@code{rcall}, can also reference a symbol by simply naming the symbol
++(no explicit calculations necessary).  In this case, the assembler or
++linker subtracts the address of the instruction from the symbol's value
++and inserts the result into the instruction.  Note that even though an
++overflow is less likely to happen for a relative reference than for an
++absolute reference, the assembler or linker will generate an error if
++the referenced symbol is too far away from the current location.
++
++Relative references can be used for data as well.  For example:
++
++@smallexample
++        lddpc   r0, 2f
++1:      add     r0, pc
++        ...
++        .align  2
++2:      .int    @var{some_symbol} - 1b
++@end smallexample
++
++Here, r0 will end up with the run-time address of @var{some_symbol} even
++if the program was loaded at a different address than it was linked
++(position-independent code).
++
++@subsubsection Symbol modifiers
++
++@table @code
++
++@item @code{hi(@var{symbol})}
++Evaluates to the value of the symbol shifted right 16 bits.  This will
++work even if @var{symbol} is defined in a different module.
++
++@item @code{lo(@var{symbol})}
++Evaluates to the low 16 bits of the symbol's value.  This will work even
++if @var{symbol} is defined in a different module.
++
++@item @code{@var{symbol}@@got}
++Create a GOT entry for @var{symbol} and return the offset of that entry
++relative to the GOT base.
++
++@end table
++
++
++@node AVR32 Directives
++@section Directives
++@cindex machine directives, AVR32
++@cindex AVR32 directives
++
++@table @code
++
++@cindex @code{.cpool} directive, AVR32
++@item .cpool
++This directive causes the current contents of the constant pool to be
++dumped into the current section at the current location (aligned to a
++word boundary).  @code{GAS} maintains a separate constant pool for each
++section and each sub-section.  The @code{.cpool} directive will only
++affect the constant pool of the current section and sub-section.  At the
++end of assembly, all remaining, non-empty constant pools will
++automatically be dumped.
++
++@end table
++
++
++@node AVR32 Opcodes
++@section Opcodes
++@cindex AVR32 opcodes
++@cindex opcodes for AVR32
++
++@code{@value{AS}} implements all the standard AVR32 opcodes.  It also
++implements several pseudo-opcodes, which are recommended to use wherever
++possible because they give the tool chain better freedom to generate
++optimal code.
++
++@table @code
++
++@cindex @code{LDA.W reg, symbol} pseudo op, AVR32
++@item LDA.W
++@smallexample
++        lda.w   @var{reg}, @var{symbol}
++@end smallexample
++
++This instruction will load the address of @var{symbol} into
++@var{reg}. The instruction will evaluate to one of the following,
++depending on the relative distance to the symbol, the relative distance
++to the constant pool and whether the @code{--pic} option has been
++specified. If the @code{--pic} option has not been specified, the
++alternatives are as follows:
++@smallexample
++        /* @var{symbol} evaluates to a small enough value */
++        mov     @var{reg}, @var{symbol}
++
++        /* (. - @var{symbol}) evaluates to a small enough value */
++        sub     @var{reg}, pc, . - @var{symbol}
++
++        /* Constant pool is close enough */
++        lddpc   @var{reg}, @var{cpent}
++        ...
++@var{cpent}:
++        .long   @var{symbol}
++
++        /* Otherwise (not implemented yet, probably not necessary) */
++        mov     @var{reg}, lo(@var{symbol})
++        orh     @var{reg}, hi(@var{symbol})
++@end smallexample
++
++If the @code{--pic} option has been specified, the alternatives are as
++follows:
++@smallexample
++        /* (. - @var{symbol}) evaluates to a small enough value */
++        sub     @var{reg}, pc, . - @var{symbol}
++
++        /* If @code{--linkrelax} not specified */
++        ld.w    @var{reg}, r6[@var{symbol}@@got]
++
++        /* Otherwise */
++        mov     @var{reg}, @var{symbol}@@got / 4
++        ld.w    @var{reg}, r6[@var{reg} << 2]
++@end smallexample
++
++If @var{symbol} is not defined in the same file and section as the
++@code{LDA.W} instruction, the most pessimistic alternative of the
++above is selected. The linker may convert it back into the most
++optimal alternative when the final value of all symbols is known.
++
++@cindex @code{CALL symbol} pseudo op, AVR32
++@item CALL
++@smallexample
++        call    @var{symbol}
++@end smallexample
++
++This instruction will insert code to call the subroutine identified by
++@var{symbol}. It will evaluate to one of the following, depending on
++the relative distance to the symbol as well as the @code{--linkrelax}
++and @code{--pic} command-line options.
++
++If @var{symbol} is defined in the same section and input file, and the
++distance is small enough, an @code{rcall} instruction is inserted:
++@smallexample
++        rcall   @var{symbol}
++@end smallexample
++
++Otherwise, if the @code{--pic} option has not been specified:
++@smallexample
++        mcall   @var{cpent}
++        ...
++@var{cpent}:
++        .long   @var{symbol}
++@end smallexample
++
++Finally, if nothing else fits and the @code{--pic} option has been
++specified, the assembler will indirect the call through the Global
++Offset Table:
++@smallexample
++        /* If @code{--linkrelax} not specified */
++        mcall   r6[@var{symbol}@@got]
++
++        /* If @code{--linkrelax} specified */
++        mov     lr, @var{symbol}@@got / 4
++        ld.w    lr, r6[lr << 2]
++        icall   lr
++@end smallexample
++
++The linker, after determining the final value of @var{symbol}, may
++convert any of these into more optimal alternatives. This includes
++deleting any superfluous constant pool- and GOT-entries.
++
++@end table
+diff -Nrup binutils-2.17/gas/doc/Makefile.am binutils-2.17-atmel/gas/doc/Makefile.am
+--- binutils-2.17/gas/doc/Makefile.am  2006-06-03 06:45:50.000000000 +0200
++++ binutils-2.17-atmel/gas/doc/Makefile.am    2007-02-12 15:37:09.000000000 +0100
+@@ -29,6 +29,7 @@ CPU_DOCS = \
+       c-alpha.texi \
+       c-arc.texi \
+       c-arm.texi \
++      c-avr32.texi \
+       c-bfin.texi \
+       c-d10v.texi \
+       c-cris.texi \
+diff -Nrup binutils-2.17/gas/doc/Makefile.in binutils-2.17-atmel/gas/doc/Makefile.in
+--- binutils-2.17/gas/doc/Makefile.in  2006-06-03 06:45:50.000000000 +0200
++++ binutils-2.17-atmel/gas/doc/Makefile.in    2007-02-20 16:07:30.000000000 +0100
+@@ -97,6 +97,7 @@ EXEEXT = @EXEEXT@
+ GDBINIT = @GDBINIT@
+ GMOFILES = @GMOFILES@
+ GMSGFMT = @GMSGFMT@
++GREP = @GREP@
+ GT_NO = @GT_NO@
+ GT_YES = @GT_YES@
+ INCLUDE_LOCALE_H = @INCLUDE_LOCALE_H@
+@@ -146,9 +147,8 @@ VERSION = @VERSION@
+ WARN_CFLAGS = @WARN_CFLAGS@
+ XGETTEXT = @XGETTEXT@
+ YACC = @YACC@
++YFLAGS = @YFLAGS@
+ ac_ct_CC = @ac_ct_CC@
+-ac_ct_RANLIB = @ac_ct_RANLIB@
+-ac_ct_STRIP = @ac_ct_STRIP@
+ am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+ am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+ am__include = @am__include@
+@@ -167,6 +167,7 @@ cgen_cpu_prefix = @cgen_cpu_prefix@
+ datadir = @datadir@
+ datarootdir = @datarootdir@
+ docdir = @docdir@
++dvidir = @dvidir@
+ exec_prefix = @exec_prefix@
+ extra_objects = @extra_objects@
+ host = @host@
+@@ -182,13 +183,16 @@ install_tooldir = @install_tooldir@
+ l = @l@
+ libdir = @libdir@
+ libexecdir = @libexecdir@
++localedir = @localedir@
+ localstatedir = @localstatedir@
+ mandir = @mandir@
+ mkdir_p = @mkdir_p@
+ obj_format = @obj_format@
+ oldincludedir = @oldincludedir@
++pdfdir = @pdfdir@
+ prefix = @prefix@
+ program_transform_name = @program_transform_name@
++psdir = @psdir@
+ sbindir = @sbindir@
+ sharedstatedir = @sharedstatedir@
+ sysconfdir = @sysconfdir@
+@@ -218,6 +222,7 @@ CPU_DOCS = \
+       c-alpha.texi \
+       c-arc.texi \
+       c-arm.texi \
++      c-avr32.texi \
+       c-bfin.texi \
+       c-d10v.texi \
+       c-cris.texi \
+@@ -384,10 +389,13 @@ dist-info: $(INFO_DEPS)
+           $(srcdir)/*) base=`echo "$$base" | sed "s|^$$srcdirstrip/||"`;; \
+         esac; \
+         if test -f $$base; then d=.; else d=$(srcdir); fi; \
+-        for file in $$d/$$base*; do \
+-          relfile=`expr "$$file" : "$$d/\(.*\)"`; \
+-          test -f $(distdir)/$$relfile || \
+-            cp -p $$file $(distdir)/$$relfile; \
++        base_i=`echo "$$base" | sed 's|\.info$$||;s|$$|.i|'`; \
++        for file in $$d/$$base $$d/$$base-[0-9] $$d/$$base-[0-9][0-9] $$d/$$base_i[0-9] $$d/$$base_i[0-9][0-9]; do \
++          if test -f $$file; then \
++            relfile=`expr "$$file" : "$$d/\(.*\)"`; \
++            test -f $(distdir)/$$relfile || \
++              cp -p $$file $(distdir)/$$relfile; \
++          else :; fi; \
+         done; \
+       done
+diff -Nrup binutils-2.17/gas/Makefile.am binutils-2.17-atmel/gas/Makefile.am
+--- binutils-2.17/gas/Makefile.am      2006-04-06 23:49:30.000000000 +0200
++++ binutils-2.17-atmel/gas/Makefile.am        2007-02-12 15:37:09.000000000 +0100
+@@ -45,6 +45,7 @@ CPU_TYPES = \
+       arc \
+       arm \
+       avr \
++      avr32 \
+       bfin \
+       cris \
+       crx \
+@@ -229,6 +230,7 @@ TARGET_CPU_CFILES = \
+       config/tc-arc.c \
+       config/tc-arm.c \
+       config/tc-avr.c \
++      config/tc-avr32.c \
+       config/tc-bfin.c \
+       config/tc-cris.c \
+       config/tc-crx.c \
+@@ -280,6 +282,7 @@ TARGET_CPU_HFILES = \
+       config/tc-arc.h \
+       config/tc-arm.h \
+       config/tc-avr.h \
++      config/tc-avr32.h \
+       config/tc-bfin.h \
+       config/tc-cris.h \
+       config/tc-crx.h \
+@@ -1046,6 +1049,11 @@ DEPTC_avr_elf = $(INCDIR)/symcat.h $(src
+   $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr.h \
+   dwarf2dbg.h $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \
+   $(INCDIR)/opcode/avr.h
++DEPTC_avr32_elf = $(INCDIR)/symcat.h $(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-avr32.h \
++  $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \
++  $(srcdir)/../opcodes/avr32-opc.h $(srcdir)/../opcodes/avr32-asm.h
+ DEPTC_bfin_coff = $(INCDIR)/symcat.h $(srcdir)/config/obj-coff.h \
+   $(srcdir)/config/tc-bfin.h $(INCDIR)/coff/internal.h \
+   $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h struc-symbol.h \
+@@ -1628,6 +1636,11 @@ DEPOBJ_bfin_elf = $(INCDIR)/symcat.h $(s
+   $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(srcdir)/config/tc-bfin.h \
+   dwarf2dbg.h $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \
+   struc-symbol.h $(INCDIR)/aout/aout64.h
++DEPOBJ_avr32_elf = $(INCDIR)/symcat.h $(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-avr32.h \
++  $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \
++  struc-symbol.h dwarf2dbg.h
+ DEPOBJ_cris_aout = $(INCDIR)/symcat.h $(srcdir)/config/obj-aout.h \
+   $(srcdir)/config/tc-cris.h $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h \
+   $(INCDIR)/aout/aout64.h $(INCDIR)/obstack.h
+@@ -2095,6 +2108,9 @@ DEP_bfin_elf = $(srcdir)/config/obj-elf.
+   $(BFDDIR)/elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
+   $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(srcdir)/config/tc-bfin.h \
+   dwarf2dbg.h
++DEP_avr32_elf = $(srcdir)/config/obj-elf.h $(INCDIR)/symcat.h \
++  $(BFDDIR)/elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
++  $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr32.h
+ DEP_cris_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-cris.h \
+   $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h
+ DEP_cris_elf = $(srcdir)/config/obj-elf.h $(INCDIR)/symcat.h \
+diff -Nrup binutils-2.17/gas/Makefile.in binutils-2.17-atmel/gas/Makefile.in
+--- binutils-2.17/gas/Makefile.in      2006-04-17 17:59:40.000000000 +0200
++++ binutils-2.17-atmel/gas/Makefile.in        2007-02-20 16:07:31.000000000 +0100
+@@ -143,6 +143,7 @@ EXEEXT = @EXEEXT@
+ GDBINIT = @GDBINIT@
+ GMOFILES = @GMOFILES@
+ GMSGFMT = @GMSGFMT@
++GREP = @GREP@
+ GT_NO = @GT_NO@
+ GT_YES = @GT_YES@
+ INCLUDE_LOCALE_H = @INCLUDE_LOCALE_H@
+@@ -192,9 +193,8 @@ VERSION = @VERSION@
+ WARN_CFLAGS = @WARN_CFLAGS@
+ XGETTEXT = @XGETTEXT@
+ YACC = `if [ -f ../bison/bison ] ; then echo ../bison/bison -y -L../bison/bison ; else echo @YACC@ ; fi`
++YFLAGS = @YFLAGS@
+ ac_ct_CC = @ac_ct_CC@
+-ac_ct_RANLIB = @ac_ct_RANLIB@
+-ac_ct_STRIP = @ac_ct_STRIP@
+ am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+ am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+ am__include = @am__include@
+@@ -213,6 +213,7 @@ cgen_cpu_prefix = @cgen_cpu_prefix@
+ datadir = @datadir@
+ datarootdir = @datarootdir@
+ docdir = @docdir@
++dvidir = @dvidir@
+ exec_prefix = @exec_prefix@
+ extra_objects = @extra_objects@
+ host = @host@
+@@ -228,13 +229,16 @@ install_tooldir = @install_tooldir@
+ l = @l@
+ libdir = @libdir@
+ libexecdir = @libexecdir@
++localedir = @localedir@
+ localstatedir = @localstatedir@
+ mandir = @mandir@
+ mkdir_p = @mkdir_p@
+ obj_format = @obj_format@
+ oldincludedir = @oldincludedir@
++pdfdir = @pdfdir@
+ prefix = @prefix@
+ program_transform_name = @program_transform_name@
++psdir = @psdir@
+ sbindir = @sbindir@
+ sharedstatedir = @sharedstatedir@
+ sysconfdir = @sysconfdir@
+@@ -276,6 +280,7 @@ CPU_TYPES = \
+       arc \
+       arm \
+       avr \
++      avr32 \
+       bfin \
+       cris \
+       crx \
+@@ -458,6 +463,7 @@ TARGET_CPU_CFILES = \
+       config/tc-arc.c \
+       config/tc-arm.c \
+       config/tc-avr.c \
++      config/tc-avr32.c \
+       config/tc-bfin.c \
+       config/tc-cris.c \
+       config/tc-crx.c \
+@@ -509,6 +515,7 @@ TARGET_CPU_HFILES = \
+       config/tc-arc.h \
+       config/tc-arm.h \
+       config/tc-avr.h \
++      config/tc-avr32.h \
+       config/tc-bfin.h \
+       config/tc-cris.h \
+       config/tc-crx.h \
+@@ -798,6 +805,12 @@ DEPTC_avr_elf = $(INCDIR)/symcat.h $(src
+   dwarf2dbg.h $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \
+   $(INCDIR)/opcode/avr.h
++DEPTC_avr32_elf = $(INCDIR)/symcat.h $(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-avr32.h \
++  $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \
++  $(srcdir)/../opcodes/avr32-opc.h $(srcdir)/../opcodes/avr32-asm.h
++
+ DEPTC_bfin_coff = $(INCDIR)/symcat.h $(srcdir)/config/obj-coff.h \
+   $(srcdir)/config/tc-bfin.h $(INCDIR)/coff/internal.h \
+   $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h struc-symbol.h \
+@@ -1491,6 +1504,12 @@ DEPOBJ_bfin_elf = $(INCDIR)/symcat.h $(s
+   dwarf2dbg.h $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \
+   struc-symbol.h $(INCDIR)/aout/aout64.h
++DEPOBJ_avr32_elf = $(INCDIR)/symcat.h $(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-avr32.h \
++  $(INCDIR)/safe-ctype.h subsegs.h $(INCDIR)/obstack.h \
++  struc-symbol.h dwarf2dbg.h
++
+ DEPOBJ_cris_aout = $(INCDIR)/symcat.h $(srcdir)/config/obj-aout.h \
+   $(srcdir)/config/tc-cris.h $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h \
+   $(INCDIR)/aout/aout64.h $(INCDIR)/obstack.h
+@@ -2066,6 +2085,10 @@ DEP_bfin_elf = $(srcdir)/config/obj-elf.
+   $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(srcdir)/config/tc-bfin.h \
+   dwarf2dbg.h
++DEP_avr32_elf = $(srcdir)/config/obj-elf.h $(INCDIR)/symcat.h \
++  $(BFDDIR)/elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
++  $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr32.h
++
+ DEP_cris_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-cris.h \
+   $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/aliases.d binutils-2.17-atmel/gas/testsuite/gas/avr32/aliases.d
+--- binutils-2.17/gas/testsuite/gas/avr32/aliases.d    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/aliases.d      2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,19 @@
++#as:
++#objdump: -dr
++#name: aliases
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <ld_nodisp>:
++   0: 19 80      [ \t]+ld\.ub r0,r12\[0x0\]
++   2: f9 20 00 00[ \t]+ld\.sb r0,r12\[0\]
++   6: 98 80      [ \t]+ld\.uh r0,r12\[0x0\]
++   8: 98 00      [ \t]+ld\.sh r0,r12\[0x0\]
++   a: 78 00      [ \t]+ld\.w r0,r12\[0x0\]
++
++0000000c <st_nodisp>:
++   c: b8 80      [ \t]+st\.b r12\[0x0\],r0
++   e: b8 00      [ \t]+st\.h r12\[0x0\],r0
++  10: 99 00      [ \t]+st\.w r12\[0x0\],r0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/aliases.s binutils-2.17-atmel/gas/testsuite/gas/avr32/aliases.s
+--- binutils-2.17/gas/testsuite/gas/avr32/aliases.s    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/aliases.s      2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,14 @@
++      .text
++      .global ld_nodisp
++ld_nodisp:
++      ld.ub   r0, r12
++      ld.sb   r0, r12
++      ld.uh   r0, r12
++      ld.sh   r0, r12
++      ld.w    r0, r12
++
++      .global st_nodisp
++st_nodisp:
++      st.b    r12, r0
++      st.h    r12, r0
++      st.w    r12, r0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/allinsn.d binutils-2.17-atmel/gas/testsuite/gas/avr32/allinsn.d
+--- binutils-2.17/gas/testsuite/gas/avr32/allinsn.d    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/allinsn.d      2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,2900 @@
++#as:
++#objdump: -dr
++#name: allinsn
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++[0-9a-f]* <ld_d5>:
++ *[0-9a-f]*:  fe 0f 02 3e     ld\.d lr,pc\[pc<<0x3\]
++ *[0-9a-f]*:  e0 00 02 00     ld\.d r0,r0\[r0\]
++ *[0-9a-f]*:  ea 05 02 26     ld\.d r6,r5\[r5<<0x2\]
++ *[0-9a-f]*:  e8 04 02 14     ld\.d r4,r4\[r4<<0x1\]
++ *[0-9a-f]*:  fc 0e 02 1e     ld\.d lr,lr\[lr<<0x1\]
++ *[0-9a-f]*:  e6 0d 02 2a     ld\.d r10,r3\[sp<<0x2\]
++ *[0-9a-f]*:  f4 06 02 28     ld\.d r8,r10\[r6<<0x2\]
++ *[0-9a-f]*:  ee 09 02 02     ld\.d r2,r7\[r9\]
++
++[0-9a-f]* <ld_w5>:
++ *[0-9a-f]*:  fe 0f 03 0f     ld\.w pc,pc\[pc\]
++ *[0-9a-f]*:  f8 0c 03 3c     ld\.w r12,r12\[r12<<0x3\]
++ *[0-9a-f]*:  ea 05 03 25     ld\.w r5,r5\[r5<<0x2\]
++ *[0-9a-f]*:  e8 04 03 14     ld\.w r4,r4\[r4<<0x1\]
++ *[0-9a-f]*:  fc 0e 03 1e     ld\.w lr,lr\[lr<<0x1\]
++ *[0-9a-f]*:  f2 09 03 02     ld\.w r2,r9\[r9\]
++ *[0-9a-f]*:  e4 06 03 0b     ld\.w r11,r2\[r6\]
++ *[0-9a-f]*:  e4 0d 03 30     ld\.w r0,r2\[sp<<0x3\]
++
++[0-9a-f]* <ld_sh5>:
++ *[0-9a-f]*:  fe 0f 04 0f     ld\.sh pc,pc\[pc\]
++ *[0-9a-f]*:  f8 0c 04 3c     ld\.sh r12,r12\[r12<<0x3\]
++ *[0-9a-f]*:  ea 05 04 25     ld\.sh r5,r5\[r5<<0x2\]
++ *[0-9a-f]*:  e8 04 04 14     ld\.sh r4,r4\[r4<<0x1\]
++ *[0-9a-f]*:  fc 0e 04 1e     ld\.sh lr,lr\[lr<<0x1\]
++ *[0-9a-f]*:  e0 0f 04 2b     ld\.sh r11,r0\[pc<<0x2\]
++ *[0-9a-f]*:  fa 06 04 2a     ld\.sh r10,sp\[r6<<0x2\]
++ *[0-9a-f]*:  e4 02 04 0c     ld\.sh r12,r2\[r2\]
++
++[0-9a-f]* <ld_uh5>:
++ *[0-9a-f]*:  fe 0f 05 0f     ld\.uh pc,pc\[pc\]
++ *[0-9a-f]*:  f8 0c 05 3c     ld\.uh r12,r12\[r12<<0x3\]
++ *[0-9a-f]*:  ea 05 05 25     ld\.uh r5,r5\[r5<<0x2\]
++ *[0-9a-f]*:  e8 04 05 14     ld\.uh r4,r4\[r4<<0x1\]
++ *[0-9a-f]*:  fc 0e 05 1e     ld\.uh lr,lr\[lr<<0x1\]
++ *[0-9a-f]*:  fe 0e 05 38     ld\.uh r8,pc\[lr<<0x3\]
++ *[0-9a-f]*:  e2 0f 05 16     ld\.uh r6,r1\[pc<<0x1\]
++ *[0-9a-f]*:  fc 0d 05 16     ld\.uh r6,lr\[sp<<0x1\]
++
++[0-9a-f]* <ld_sb2>:
++ *[0-9a-f]*:  fe 0f 06 0f     ld\.sb pc,pc\[pc\]
++ *[0-9a-f]*:  f8 0c 06 3c     ld\.sb r12,r12\[r12<<0x3\]
++ *[0-9a-f]*:  ea 05 06 25     ld\.sb r5,r5\[r5<<0x2\]
++ *[0-9a-f]*:  e8 04 06 14     ld\.sb r4,r4\[r4<<0x1\]
++ *[0-9a-f]*:  fc 0e 06 1e     ld\.sb lr,lr\[lr<<0x1\]
++ *[0-9a-f]*:  e2 0f 06 39     ld\.sb r9,r1\[pc<<0x3\]
++ *[0-9a-f]*:  e6 0b 06 10     ld\.sb r0,r3\[r11<<0x1\]
++ *[0-9a-f]*:  ea 05 06 1a     ld\.sb r10,r5\[r5<<0x1\]
++
++[0-9a-f]* <ld_ub5>:
++ *[0-9a-f]*:  fe 0f 07 0f     ld\.ub pc,pc\[pc\]
++ *[0-9a-f]*:  f8 0c 07 3c     ld\.ub r12,r12\[r12<<0x3\]
++ *[0-9a-f]*:  ea 05 07 25     ld\.ub r5,r5\[r5<<0x2\]
++ *[0-9a-f]*:  e8 04 07 14     ld\.ub r4,r4\[r4<<0x1\]
++ *[0-9a-f]*:  fc 0e 07 1e     ld\.ub lr,lr\[lr<<0x1\]
++ *[0-9a-f]*:  f8 07 07 36     ld\.ub r6,r12\[r7<<0x3\]
++ *[0-9a-f]*:  ec 0c 07 02     ld\.ub r2,r6\[r12\]
++ *[0-9a-f]*:  ee 0b 07 10     ld\.ub r0,r7\[r11<<0x1\]
++
++[0-9a-f]* <st_d5>:
++ *[0-9a-f]*:  fe 0f 08 0e     st\.d pc\[pc\],lr
++ *[0-9a-f]*:  f8 0c 08 3c     st\.d r12\[r12<<0x3\],r12
++ *[0-9a-f]*:  ea 05 08 26     st\.d r5\[r5<<0x2\],r6
++ *[0-9a-f]*:  e8 04 08 14     st\.d r4\[r4<<0x1\],r4
++ *[0-9a-f]*:  fc 0e 08 1e     st\.d lr\[lr<<0x1\],lr
++ *[0-9a-f]*:  e2 09 08 14     st\.d r1\[r9<<0x1\],r4
++ *[0-9a-f]*:  f4 02 08 14     st\.d r10\[r2<<0x1\],r4
++ *[0-9a-f]*:  f8 06 08 0e     st\.d r12\[r6\],lr
++
++[0-9a-f]* <st_w5>:
++ *[0-9a-f]*:  fe 0f 09 0f     st\.w pc\[pc\],pc
++ *[0-9a-f]*:  f8 0c 09 3c     st\.w r12\[r12<<0x3\],r12
++ *[0-9a-f]*:  ea 05 09 25     st\.w r5\[r5<<0x2\],r5
++ *[0-9a-f]*:  e8 04 09 14     st\.w r4\[r4<<0x1\],r4
++ *[0-9a-f]*:  fc 0e 09 1e     st\.w lr\[lr<<0x1\],lr
++ *[0-9a-f]*:  e2 0a 09 03     st\.w r1\[r10\],r3
++ *[0-9a-f]*:  e0 0a 09 19     st\.w r0\[r10<<0x1\],r9
++ *[0-9a-f]*:  e8 05 09 3f     st\.w r4\[r5<<0x3\],pc
++
++[0-9a-f]* <st_h5>:
++ *[0-9a-f]*:  fe 0f 0a 0f     st\.h pc\[pc\],pc
++ *[0-9a-f]*:  f8 0c 0a 3c     st\.h r12\[r12<<0x3\],r12
++ *[0-9a-f]*:  ea 05 0a 25     st\.h r5\[r5<<0x2\],r5
++ *[0-9a-f]*:  e8 04 0a 14     st\.h r4\[r4<<0x1\],r4
++ *[0-9a-f]*:  fc 0e 0a 1e     st\.h lr\[lr<<0x1\],lr
++ *[0-9a-f]*:  e4 09 0a 0b     st\.h r2\[r9\],r11
++ *[0-9a-f]*:  ea 01 0a 2c     st\.h r5\[r1<<0x2\],r12
++ *[0-9a-f]*:  fe 08 0a 23     st\.h pc\[r8<<0x2\],r3
++
++[0-9a-f]* <st_b5>:
++ *[0-9a-f]*:  fe 0f 0b 0f     st\.b pc\[pc\],pc
++ *[0-9a-f]*:  f8 0c 0b 3c     st\.b r12\[r12<<0x3\],r12
++ *[0-9a-f]*:  ea 05 0b 25     st\.b r5\[r5<<0x2\],r5
++ *[0-9a-f]*:  e8 04 0b 14     st\.b r4\[r4<<0x1\],r4
++ *[0-9a-f]*:  fc 0e 0b 1e     st\.b lr\[lr<<0x1\],lr
++ *[0-9a-f]*:  e2 08 0b 16     st\.b r1\[r8<<0x1\],r6
++ *[0-9a-f]*:  fc 0e 0b 31     st\.b lr\[lr<<0x3\],r1
++ *[0-9a-f]*:  ea 00 0b 2f     st\.b r5\[r0<<0x2\],pc
++
++[0-9a-f]* <divs>:
++ *[0-9a-f]*:  fe 0f 0c 0f     divs pc,pc,pc
++ *[0-9a-f]*:  f8 0c 0c 0c     divs r12,r12,r12
++ *[0-9a-f]*:  ea 05 0c 05     divs r5,r5,r5
++ *[0-9a-f]*:  e8 04 0c 04     divs r4,r4,r4
++ *[0-9a-f]*:  fc 0e 0c 0e     divs lr,lr,lr
++ *[0-9a-f]*:  fe 0f 0c 03     divs r3,pc,pc
++ *[0-9a-f]*:  f8 02 0c 09     divs r9,r12,r2
++ *[0-9a-f]*:  e8 01 0c 07     divs r7,r4,r1
++
++[0-9a-f]* <add1>:
++ *[0-9a-f]*:  1e 0f           add pc,pc
++ *[0-9a-f]*:  18 0c           add r12,r12
++ *[0-9a-f]*:  0a 05           add r5,r5
++ *[0-9a-f]*:  08 04           add r4,r4
++ *[0-9a-f]*:  1c 0e           add lr,lr
++ *[0-9a-f]*:  12 0c           add r12,r9
++ *[0-9a-f]*:  06 06           add r6,r3
++ *[0-9a-f]*:  18 0a           add r10,r12
++
++[0-9a-f]* <sub1>:
++ *[0-9a-f]*:  1e 1f           sub pc,pc
++ *[0-9a-f]*:  18 1c           sub r12,r12
++ *[0-9a-f]*:  0a 15           sub r5,r5
++ *[0-9a-f]*:  08 14           sub r4,r4
++ *[0-9a-f]*:  1c 1e           sub lr,lr
++ *[0-9a-f]*:  0c 1e           sub lr,r6
++ *[0-9a-f]*:  1a 10           sub r0,sp
++ *[0-9a-f]*:  18 16           sub r6,r12
++
++[0-9a-f]* <rsub1>:
++ *[0-9a-f]*:  1e 2f           rsub pc,pc
++ *[0-9a-f]*:  18 2c           rsub r12,r12
++ *[0-9a-f]*:  0a 25           rsub r5,r5
++ *[0-9a-f]*:  08 24           rsub r4,r4
++ *[0-9a-f]*:  1c 2e           rsub lr,lr
++ *[0-9a-f]*:  1a 2b           rsub r11,sp
++ *[0-9a-f]*:  08 27           rsub r7,r4
++ *[0-9a-f]*:  02 29           rsub r9,r1
++
++[0-9a-f]* <cp1>:
++ *[0-9a-f]*:  1e 3f           cp\.w pc,pc
++ *[0-9a-f]*:  18 3c           cp\.w r12,r12
++ *[0-9a-f]*:  0a 35           cp\.w r5,r5
++ *[0-9a-f]*:  08 34           cp\.w r4,r4
++ *[0-9a-f]*:  1c 3e           cp\.w lr,lr
++ *[0-9a-f]*:  04 36           cp\.w r6,r2
++ *[0-9a-f]*:  12 30           cp\.w r0,r9
++ *[0-9a-f]*:  1a 33           cp\.w r3,sp
++
++[0-9a-f]* <or1>:
++ *[0-9a-f]*:  1e 4f           or pc,pc
++ *[0-9a-f]*:  18 4c           or r12,r12
++ *[0-9a-f]*:  0a 45           or r5,r5
++ *[0-9a-f]*:  08 44           or r4,r4
++ *[0-9a-f]*:  1c 4e           or lr,lr
++ *[0-9a-f]*:  12 44           or r4,r9
++ *[0-9a-f]*:  08 4b           or r11,r4
++ *[0-9a-f]*:  00 44           or r4,r0
++
++[0-9a-f]* <eor1>:
++ *[0-9a-f]*:  1e 5f           eor pc,pc
++ *[0-9a-f]*:  18 5c           eor r12,r12
++ *[0-9a-f]*:  0a 55           eor r5,r5
++ *[0-9a-f]*:  08 54           eor r4,r4
++ *[0-9a-f]*:  1c 5e           eor lr,lr
++ *[0-9a-f]*:  16 5c           eor r12,r11
++ *[0-9a-f]*:  02 50           eor r0,r1
++ *[0-9a-f]*:  1e 55           eor r5,pc
++
++[0-9a-f]* <and1>:
++ *[0-9a-f]*:  1e 6f           and pc,pc
++ *[0-9a-f]*:  18 6c           and r12,r12
++ *[0-9a-f]*:  0a 65           and r5,r5
++ *[0-9a-f]*:  08 64           and r4,r4
++ *[0-9a-f]*:  1c 6e           and lr,lr
++ *[0-9a-f]*:  02 68           and r8,r1
++ *[0-9a-f]*:  1a 60           and r0,sp
++ *[0-9a-f]*:  0a 6a           and r10,r5
++
++[0-9a-f]* <tst>:
++ *[0-9a-f]*:  1e 7f           tst pc,pc
++ *[0-9a-f]*:  18 7c           tst r12,r12
++ *[0-9a-f]*:  0a 75           tst r5,r5
++ *[0-9a-f]*:  08 74           tst r4,r4
++ *[0-9a-f]*:  1c 7e           tst lr,lr
++ *[0-9a-f]*:  18 70           tst r0,r12
++ *[0-9a-f]*:  0c 7a           tst r10,r6
++ *[0-9a-f]*:  08 7d           tst sp,r4
++
++[0-9a-f]* <andn>:
++ *[0-9a-f]*:  1e 8f           andn pc,pc
++ *[0-9a-f]*:  18 8c           andn r12,r12
++ *[0-9a-f]*:  0a 85           andn r5,r5
++ *[0-9a-f]*:  08 84           andn r4,r4
++ *[0-9a-f]*:  1c 8e           andn lr,lr
++ *[0-9a-f]*:  18 89           andn r9,r12
++ *[0-9a-f]*:  1a 8b           andn r11,sp
++ *[0-9a-f]*:  0a 8c           andn r12,r5
++
++[0-9a-f]* <mov3>:
++ *[0-9a-f]*:  1e 9f           mov pc,pc
++ *[0-9a-f]*:  18 9c           mov r12,r12
++ *[0-9a-f]*:  0a 95           mov r5,r5
++ *[0-9a-f]*:  08 94           mov r4,r4
++ *[0-9a-f]*:  1c 9e           mov lr,lr
++ *[0-9a-f]*:  12 95           mov r5,r9
++ *[0-9a-f]*:  16 9b           mov r11,r11
++ *[0-9a-f]*:  1c 92           mov r2,lr
++
++[0-9a-f]* <st_w1>:
++ *[0-9a-f]*:  1e af           st\.w pc\+\+,pc
++ *[0-9a-f]*:  18 ac           st\.w r12\+\+,r12
++ *[0-9a-f]*:  0a a5           st\.w r5\+\+,r5
++ *[0-9a-f]*:  08 a4           st\.w r4\+\+,r4
++ *[0-9a-f]*:  1c ae           st\.w lr\+\+,lr
++ *[0-9a-f]*:  02 ab           st\.w r1\+\+,r11
++ *[0-9a-f]*:  1a a0           st\.w sp\+\+,r0
++ *[0-9a-f]*:  1a a1           st\.w sp\+\+,r1
++
++[0-9a-f]* <st_h1>:
++ *[0-9a-f]*:  1e bf           st\.h pc\+\+,pc
++ *[0-9a-f]*:  18 bc           st\.h r12\+\+,r12
++ *[0-9a-f]*:  0a b5           st\.h r5\+\+,r5
++ *[0-9a-f]*:  08 b4           st\.h r4\+\+,r4
++ *[0-9a-f]*:  1c be           st\.h lr\+\+,lr
++ *[0-9a-f]*:  18 bd           st\.h r12\+\+,sp
++ *[0-9a-f]*:  0e be           st\.h r7\+\+,lr
++ *[0-9a-f]*:  0e b4           st\.h r7\+\+,r4
++
++[0-9a-f]* <st_b1>:
++ *[0-9a-f]*:  1e cf           st\.b pc\+\+,pc
++ *[0-9a-f]*:  18 cc           st\.b r12\+\+,r12
++ *[0-9a-f]*:  0a c5           st\.b r5\+\+,r5
++ *[0-9a-f]*:  08 c4           st\.b r4\+\+,r4
++ *[0-9a-f]*:  1c ce           st\.b lr\+\+,lr
++ *[0-9a-f]*:  12 cd           st\.b r9\+\+,sp
++ *[0-9a-f]*:  02 cd           st\.b r1\+\+,sp
++ *[0-9a-f]*:  00 c4           st\.b r0\+\+,r4
++
++[0-9a-f]* <st_w2>:
++ *[0-9a-f]*:  1e df           st\.w --pc,pc
++ *[0-9a-f]*:  18 dc           st\.w --r12,r12
++ *[0-9a-f]*:  0a d5           st\.w --r5,r5
++ *[0-9a-f]*:  08 d4           st\.w --r4,r4
++ *[0-9a-f]*:  1c de           st\.w --lr,lr
++ *[0-9a-f]*:  02 d7           st\.w --r1,r7
++ *[0-9a-f]*:  06 d9           st\.w --r3,r9
++ *[0-9a-f]*:  0a d5           st\.w --r5,r5
++
++[0-9a-f]* <st_h2>:
++ *[0-9a-f]*:  1e ef           st\.h --pc,pc
++ *[0-9a-f]*:  18 ec           st\.h --r12,r12
++ *[0-9a-f]*:  0a e5           st\.h --r5,r5
++ *[0-9a-f]*:  08 e4           st\.h --r4,r4
++ *[0-9a-f]*:  1c ee           st\.h --lr,lr
++ *[0-9a-f]*:  0a e7           st\.h --r5,r7
++ *[0-9a-f]*:  10 e8           st\.h --r8,r8
++ *[0-9a-f]*:  0e e2           st\.h --r7,r2
++
++[0-9a-f]* <st_b2>:
++ *[0-9a-f]*:  1e ff           st\.b --pc,pc
++ *[0-9a-f]*:  18 fc           st\.b --r12,r12
++ *[0-9a-f]*:  0a f5           st\.b --r5,r5
++ *[0-9a-f]*:  08 f4           st\.b --r4,r4
++ *[0-9a-f]*:  1c fe           st\.b --lr,lr
++ *[0-9a-f]*:  1a fd           st\.b --sp,sp
++ *[0-9a-f]*:  1a fb           st\.b --sp,r11
++ *[0-9a-f]*:  08 f5           st\.b --r4,r5
++
++[0-9a-f]* <ld_w1>:
++ *[0-9a-f]*:  1f 0f           ld\.w pc,pc\+\+
++ *[0-9a-f]*:  19 0c           ld\.w r12,r12\+\+
++ *[0-9a-f]*:  0b 05           ld\.w r5,r5\+\+
++ *[0-9a-f]*:  09 04           ld\.w r4,r4\+\+
++ *[0-9a-f]*:  1d 0e           ld\.w lr,lr\+\+
++ *[0-9a-f]*:  0f 03           ld\.w r3,r7\+\+
++ *[0-9a-f]*:  1d 03           ld\.w r3,lr\+\+
++ *[0-9a-f]*:  0b 0c           ld\.w r12,r5\+\+
++
++[0-9a-f]* <ld_sh1>:
++ *[0-9a-f]*:  1f 1f           ld\.sh pc,pc\+\+
++ *[0-9a-f]*:  19 1c           ld\.sh r12,r12\+\+
++ *[0-9a-f]*:  0b 15           ld\.sh r5,r5\+\+
++ *[0-9a-f]*:  09 14           ld\.sh r4,r4\+\+
++ *[0-9a-f]*:  1d 1e           ld\.sh lr,lr\+\+
++ *[0-9a-f]*:  05 1b           ld\.sh r11,r2\+\+
++ *[0-9a-f]*:  11 12           ld\.sh r2,r8\+\+
++ *[0-9a-f]*:  0d 17           ld\.sh r7,r6\+\+
++
++[0-9a-f]* <ld_uh1>:
++ *[0-9a-f]*:  1f 2f           ld\.uh pc,pc\+\+
++ *[0-9a-f]*:  19 2c           ld\.uh r12,r12\+\+
++ *[0-9a-f]*:  0b 25           ld\.uh r5,r5\+\+
++ *[0-9a-f]*:  09 24           ld\.uh r4,r4\+\+
++ *[0-9a-f]*:  1d 2e           ld\.uh lr,lr\+\+
++ *[0-9a-f]*:  0f 26           ld\.uh r6,r7\+\+
++ *[0-9a-f]*:  17 2a           ld\.uh r10,r11\+\+
++ *[0-9a-f]*:  09 2e           ld\.uh lr,r4\+\+
++
++[0-9a-f]* <ld_ub1>:
++ *[0-9a-f]*:  1f 3f           ld\.ub pc,pc\+\+
++ *[0-9a-f]*:  19 3c           ld\.ub r12,r12\+\+
++ *[0-9a-f]*:  0b 35           ld\.ub r5,r5\+\+
++ *[0-9a-f]*:  09 34           ld\.ub r4,r4\+\+
++ *[0-9a-f]*:  1d 3e           ld\.ub lr,lr\+\+
++ *[0-9a-f]*:  1d 38           ld\.ub r8,lr\+\+
++ *[0-9a-f]*:  19 3c           ld\.ub r12,r12\+\+
++ *[0-9a-f]*:  15 3b           ld\.ub r11,r10\+\+
++
++[0-9a-f]* <ld_w2>:
++ *[0-9a-f]*:  1f 4f           ld\.w pc,--pc
++ *[0-9a-f]*:  19 4c           ld\.w r12,--r12
++ *[0-9a-f]*:  0b 45           ld\.w r5,--r5
++ *[0-9a-f]*:  09 44           ld\.w r4,--r4
++ *[0-9a-f]*:  1d 4e           ld\.w lr,--lr
++ *[0-9a-f]*:  1d 4a           ld\.w r10,--lr
++ *[0-9a-f]*:  13 4c           ld\.w r12,--r9
++ *[0-9a-f]*:  0b 46           ld\.w r6,--r5
++
++[0-9a-f]* <ld_sh2>:
++ *[0-9a-f]*:  1f 5f           ld\.sh pc,--pc
++ *[0-9a-f]*:  19 5c           ld\.sh r12,--r12
++ *[0-9a-f]*:  0b 55           ld\.sh r5,--r5
++ *[0-9a-f]*:  09 54           ld\.sh r4,--r4
++ *[0-9a-f]*:  1d 5e           ld\.sh lr,--lr
++ *[0-9a-f]*:  15 5f           ld\.sh pc,--r10
++ *[0-9a-f]*:  07 56           ld\.sh r6,--r3
++ *[0-9a-f]*:  0d 54           ld\.sh r4,--r6
++
++[0-9a-f]* <ld_uh2>:
++ *[0-9a-f]*:  1f 6f           ld\.uh pc,--pc
++ *[0-9a-f]*:  19 6c           ld\.uh r12,--r12
++ *[0-9a-f]*:  0b 65           ld\.uh r5,--r5
++ *[0-9a-f]*:  09 64           ld\.uh r4,--r4
++ *[0-9a-f]*:  1d 6e           ld\.uh lr,--lr
++ *[0-9a-f]*:  05 63           ld\.uh r3,--r2
++ *[0-9a-f]*:  01 61           ld\.uh r1,--r0
++ *[0-9a-f]*:  13 62           ld\.uh r2,--r9
++
++[0-9a-f]* <ld_ub2>:
++ *[0-9a-f]*:  1f 7f           ld\.ub pc,--pc
++ *[0-9a-f]*:  19 7c           ld\.ub r12,--r12
++ *[0-9a-f]*:  0b 75           ld\.ub r5,--r5
++ *[0-9a-f]*:  09 74           ld\.ub r4,--r4
++ *[0-9a-f]*:  1d 7e           ld\.ub lr,--lr
++ *[0-9a-f]*:  03 71           ld\.ub r1,--r1
++ *[0-9a-f]*:  0d 70           ld\.ub r0,--r6
++ *[0-9a-f]*:  0f 72           ld\.ub r2,--r7
++
++[0-9a-f]* <ld_ub3>:
++ *[0-9a-f]*:  1f 8f           ld\.ub pc,pc\[0x0\]
++ *[0-9a-f]*:  19 fc           ld\.ub r12,r12\[0x7\]
++ *[0-9a-f]*:  0b c5           ld\.ub r5,r5\[0x4\]
++ *[0-9a-f]*:  09 b4           ld\.ub r4,r4\[0x3\]
++ *[0-9a-f]*:  1d 9e           ld\.ub lr,lr\[0x1\]
++ *[0-9a-f]*:  13 e6           ld\.ub r6,r9\[0x6\]
++ *[0-9a-f]*:  1d c2           ld\.ub r2,lr\[0x4\]
++ *[0-9a-f]*:  11 81           ld\.ub r1,r8\[0x0\]
++
++[0-9a-f]* <sub3_sp>:
++ *[0-9a-f]*:  20 0d           sub sp,0
++ *[0-9a-f]*:  2f fd           sub sp,-4
++ *[0-9a-f]*:  28 0d           sub sp,-512
++ *[0-9a-f]*:  27 fd           sub sp,508
++ *[0-9a-f]*:  20 1d           sub sp,4
++ *[0-9a-f]*:  20 bd           sub sp,44
++ *[0-9a-f]*:  20 2d           sub sp,8
++ *[0-9a-f]*:  25 7d           sub sp,348
++
++[0-9a-f]* <sub3>:
++ *[0-9a-f]*:  20 0f           sub pc,0
++ *[0-9a-f]*:  2f fc           sub r12,-1
++ *[0-9a-f]*:  28 05           sub r5,-128
++ *[0-9a-f]*:  27 f4           sub r4,127
++ *[0-9a-f]*:  20 1e           sub lr,1
++ *[0-9a-f]*:  2d 76           sub r6,-41
++ *[0-9a-f]*:  22 54           sub r4,37
++ *[0-9a-f]*:  23 8c           sub r12,56
++
++[0-9a-f]* <mov1>:
++ *[0-9a-f]*:  30 0f           mov pc,0
++ *[0-9a-f]*:  3f fc           mov r12,-1
++ *[0-9a-f]*:  38 05           mov r5,-128
++ *[0-9a-f]*:  37 f4           mov r4,127
++ *[0-9a-f]*:  30 1e           mov lr,1
++ *[0-9a-f]*:  30 ef           mov pc,14
++ *[0-9a-f]*:  39 c6           mov r6,-100
++ *[0-9a-f]*:  38 6e           mov lr,-122
++
++[0-9a-f]* <lddsp>:
++ *[0-9a-f]*:  40 0f           lddsp pc,sp\[0x0\]
++ *[0-9a-f]*:  47 fc           lddsp r12,sp\[0x1fc\]
++ *[0-9a-f]*:  44 05           lddsp r5,sp\[0x100\]
++ *[0-9a-f]*:  43 f4           lddsp r4,sp\[0xfc\]
++ *[0-9a-f]*:  40 1e           lddsp lr,sp\[0x4\]
++ *[0-9a-f]*:  44 0e           lddsp lr,sp\[0x100\]
++ *[0-9a-f]*:  40 5c           lddsp r12,sp\[0x14\]
++ *[0-9a-f]*:  47 69           lddsp r9,sp\[0x1d8\]
++
++[0-9a-f]* <lddpc>:
++ *[0-9a-f]*:  48 0f           lddpc pc,[0-9a-f]* <.*>
++ *[0-9a-f]*:  4f f0           lddpc r0,[0-9a-f]* <.*>
++ *[0-9a-f]*:  4c 08           lddpc r8,[0-9a-f]* <.*>
++ *[0-9a-f]*:  4b f7           lddpc r7,[0-9a-f]* <.*>
++ *[0-9a-f]*:  48 1e           lddpc lr,[0-9a-f]* <.*>
++ *[0-9a-f]*:  4f 6d           lddpc sp,[0-9a-f]* <.*>
++ *[0-9a-f]*:  49 e6           lddpc r6,[0-9a-f]* <.*>
++ *[0-9a-f]*:  48 7b           lddpc r11,[0-9a-f]* <.*>
++
++[0-9a-f]* <stdsp>:
++ *[0-9a-f]*:  50 0f           stdsp sp\[0x0\],pc
++ *[0-9a-f]*:  57 fc           stdsp sp\[0x1fc\],r12
++ *[0-9a-f]*:  54 05           stdsp sp\[0x100\],r5
++ *[0-9a-f]*:  53 f4           stdsp sp\[0xfc\],r4
++ *[0-9a-f]*:  50 1e           stdsp sp\[0x4\],lr
++ *[0-9a-f]*:  54 cf           stdsp sp\[0x130\],pc
++ *[0-9a-f]*:  54 00           stdsp sp\[0x100\],r0
++ *[0-9a-f]*:  55 45           stdsp sp\[0x150\],r5
++
++[0-9a-f]* <cp2>:
++ *[0-9a-f]*:  58 0f           cp.w pc,0
++ *[0-9a-f]*:  5b fc           cp.w r12,-1
++ *[0-9a-f]*:  5a 05           cp.w r5,-32
++ *[0-9a-f]*:  59 f4           cp.w r4,31
++ *[0-9a-f]*:  58 1e           cp.w lr,1
++ *[0-9a-f]*:  58 38           cp.w r8,3
++ *[0-9a-f]*:  59 0e           cp.w lr,16
++ *[0-9a-f]*:  5a 67           cp.w r7,-26
++
++[0-9a-f]* <acr>:
++ *[0-9a-f]*:  5c 0f           acr pc
++ *[0-9a-f]*:  5c 0c           acr r12
++ *[0-9a-f]*:  5c 05           acr r5
++ *[0-9a-f]*:  5c 04           acr r4
++ *[0-9a-f]*:  5c 0e           acr lr
++ *[0-9a-f]*:  5c 02           acr r2
++ *[0-9a-f]*:  5c 0c           acr r12
++ *[0-9a-f]*:  5c 0f           acr pc
++
++[0-9a-f]* <scr>:
++ *[0-9a-f]*:  5c 1f           scr pc
++ *[0-9a-f]*:  5c 1c           scr r12
++ *[0-9a-f]*:  5c 15           scr r5
++ *[0-9a-f]*:  5c 14           scr r4
++ *[0-9a-f]*:  5c 1e           scr lr
++ *[0-9a-f]*:  5c 1f           scr pc
++ *[0-9a-f]*:  5c 16           scr r6
++ *[0-9a-f]*:  5c 11           scr r1
++
++[0-9a-f]* <cpc0>:
++ *[0-9a-f]*:  5c 2f           cpc pc
++ *[0-9a-f]*:  5c 2c           cpc r12
++ *[0-9a-f]*:  5c 25           cpc r5
++ *[0-9a-f]*:  5c 24           cpc r4
++ *[0-9a-f]*:  5c 2e           cpc lr
++ *[0-9a-f]*:  5c 2f           cpc pc
++ *[0-9a-f]*:  5c 24           cpc r4
++ *[0-9a-f]*:  5c 29           cpc r9
++
++[0-9a-f]* <neg>:
++ *[0-9a-f]*:  5c 3f           neg pc
++ *[0-9a-f]*:  5c 3c           neg r12
++ *[0-9a-f]*:  5c 35           neg r5
++ *[0-9a-f]*:  5c 34           neg r4
++ *[0-9a-f]*:  5c 3e           neg lr
++ *[0-9a-f]*:  5c 37           neg r7
++ *[0-9a-f]*:  5c 31           neg r1
++ *[0-9a-f]*:  5c 39           neg r9
++
++[0-9a-f]* <abs>:
++ *[0-9a-f]*:  5c 4f           abs pc
++ *[0-9a-f]*:  5c 4c           abs r12
++ *[0-9a-f]*:  5c 45           abs r5
++ *[0-9a-f]*:  5c 44           abs r4
++ *[0-9a-f]*:  5c 4e           abs lr
++ *[0-9a-f]*:  5c 46           abs r6
++ *[0-9a-f]*:  5c 46           abs r6
++ *[0-9a-f]*:  5c 44           abs r4
++
++[0-9a-f]* <castu_b>:
++ *[0-9a-f]*:  5c 5f           castu\.b pc
++ *[0-9a-f]*:  5c 5c           castu\.b r12
++ *[0-9a-f]*:  5c 55           castu\.b r5
++ *[0-9a-f]*:  5c 54           castu\.b r4
++ *[0-9a-f]*:  5c 5e           castu\.b lr
++ *[0-9a-f]*:  5c 57           castu\.b r7
++ *[0-9a-f]*:  5c 5d           castu\.b sp
++ *[0-9a-f]*:  5c 59           castu\.b r9
++
++[0-9a-f]* <casts_b>:
++ *[0-9a-f]*:  5c 6f           casts\.b pc
++ *[0-9a-f]*:  5c 6c           casts\.b r12
++ *[0-9a-f]*:  5c 65           casts\.b r5
++ *[0-9a-f]*:  5c 64           casts\.b r4
++ *[0-9a-f]*:  5c 6e           casts\.b lr
++ *[0-9a-f]*:  5c 6b           casts\.b r11
++ *[0-9a-f]*:  5c 61           casts\.b r1
++ *[0-9a-f]*:  5c 6a           casts\.b r10
++
++[0-9a-f]* <castu_h>:
++ *[0-9a-f]*:  5c 7f           castu\.h pc
++ *[0-9a-f]*:  5c 7c           castu\.h r12
++ *[0-9a-f]*:  5c 75           castu\.h r5
++ *[0-9a-f]*:  5c 74           castu\.h r4
++ *[0-9a-f]*:  5c 7e           castu\.h lr
++ *[0-9a-f]*:  5c 7a           castu\.h r10
++ *[0-9a-f]*:  5c 7b           castu\.h r11
++ *[0-9a-f]*:  5c 71           castu\.h r1
++
++[0-9a-f]* <casts_h>:
++ *[0-9a-f]*:  5c 8f           casts\.h pc
++ *[0-9a-f]*:  5c 8c           casts\.h r12
++ *[0-9a-f]*:  5c 85           casts\.h r5
++ *[0-9a-f]*:  5c 84           casts\.h r4
++ *[0-9a-f]*:  5c 8e           casts\.h lr
++ *[0-9a-f]*:  5c 80           casts\.h r0
++ *[0-9a-f]*:  5c 85           casts\.h r5
++ *[0-9a-f]*:  5c 89           casts\.h r9
++
++[0-9a-f]* <brev>:
++ *[0-9a-f]*:  5c 9f           brev pc
++ *[0-9a-f]*:  5c 9c           brev r12
++ *[0-9a-f]*:  5c 95           brev r5
++ *[0-9a-f]*:  5c 94           brev r4
++ *[0-9a-f]*:  5c 9e           brev lr
++ *[0-9a-f]*:  5c 95           brev r5
++ *[0-9a-f]*:  5c 9a           brev r10
++ *[0-9a-f]*:  5c 98           brev r8
++
++[0-9a-f]* <swap_h>:
++ *[0-9a-f]*:  5c af           swap\.h pc
++ *[0-9a-f]*:  5c ac           swap\.h r12
++ *[0-9a-f]*:  5c a5           swap\.h r5
++ *[0-9a-f]*:  5c a4           swap\.h r4
++ *[0-9a-f]*:  5c ae           swap\.h lr
++ *[0-9a-f]*:  5c a7           swap\.h r7
++ *[0-9a-f]*:  5c a0           swap\.h r0
++ *[0-9a-f]*:  5c a8           swap\.h r8
++
++[0-9a-f]* <swap_b>:
++ *[0-9a-f]*:  5c bf           swap\.b pc
++ *[0-9a-f]*:  5c bc           swap\.b r12
++ *[0-9a-f]*:  5c b5           swap\.b r5
++ *[0-9a-f]*:  5c b4           swap\.b r4
++ *[0-9a-f]*:  5c be           swap\.b lr
++ *[0-9a-f]*:  5c ba           swap\.b r10
++ *[0-9a-f]*:  5c bc           swap\.b r12
++ *[0-9a-f]*:  5c b1           swap\.b r1
++
++[0-9a-f]* <swap_bh>:
++ *[0-9a-f]*:  5c cf           swap\.bh pc
++ *[0-9a-f]*:  5c cc           swap\.bh r12
++ *[0-9a-f]*:  5c c5           swap\.bh r5
++ *[0-9a-f]*:  5c c4           swap\.bh r4
++ *[0-9a-f]*:  5c ce           swap\.bh lr
++ *[0-9a-f]*:  5c c9           swap\.bh r9
++ *[0-9a-f]*:  5c c4           swap\.bh r4
++ *[0-9a-f]*:  5c c1           swap\.bh r1
++
++[0-9a-f]* <One_s_compliment>:
++ *[0-9a-f]*:  5c df           com pc
++ *[0-9a-f]*:  5c dc           com r12
++ *[0-9a-f]*:  5c d5           com r5
++ *[0-9a-f]*:  5c d4           com r4
++ *[0-9a-f]*:  5c de           com lr
++ *[0-9a-f]*:  5c d2           com r2
++ *[0-9a-f]*:  5c d2           com r2
++ *[0-9a-f]*:  5c d7           com r7
++
++[0-9a-f]* <tnbz>:
++ *[0-9a-f]*:  5c ef           tnbz pc
++ *[0-9a-f]*:  5c ec           tnbz r12
++ *[0-9a-f]*:  5c e5           tnbz r5
++ *[0-9a-f]*:  5c e4           tnbz r4
++ *[0-9a-f]*:  5c ee           tnbz lr
++ *[0-9a-f]*:  5c e8           tnbz r8
++ *[0-9a-f]*:  5c ec           tnbz r12
++ *[0-9a-f]*:  5c ef           tnbz pc
++
++[0-9a-f]* <rol>:
++ *[0-9a-f]*:  5c ff           rol pc
++ *[0-9a-f]*:  5c fc           rol r12
++ *[0-9a-f]*:  5c f5           rol r5
++ *[0-9a-f]*:  5c f4           rol r4
++ *[0-9a-f]*:  5c fe           rol lr
++ *[0-9a-f]*:  5c fa           rol r10
++ *[0-9a-f]*:  5c f9           rol r9
++ *[0-9a-f]*:  5c f5           rol r5
++
++[0-9a-f]* <ror>:
++ *[0-9a-f]*:  5d 0f           ror pc
++ *[0-9a-f]*:  5d 0c           ror r12
++ *[0-9a-f]*:  5d 05           ror r5
++ *[0-9a-f]*:  5d 04           ror r4
++ *[0-9a-f]*:  5d 0e           ror lr
++ *[0-9a-f]*:  5d 08           ror r8
++ *[0-9a-f]*:  5d 04           ror r4
++ *[0-9a-f]*:  5d 07           ror r7
++
++[0-9a-f]* <icall>:
++ *[0-9a-f]*:  5d 1f           icall pc
++ *[0-9a-f]*:  5d 1c           icall r12
++ *[0-9a-f]*:  5d 15           icall r5
++ *[0-9a-f]*:  5d 14           icall r4
++ *[0-9a-f]*:  5d 1e           icall lr
++ *[0-9a-f]*:  5d 13           icall r3
++ *[0-9a-f]*:  5d 11           icall r1
++ *[0-9a-f]*:  5d 13           icall r3
++
++[0-9a-f]* <mustr>:
++ *[0-9a-f]*:  5d 2f           mustr pc
++ *[0-9a-f]*:  5d 2c           mustr r12
++ *[0-9a-f]*:  5d 25           mustr r5
++ *[0-9a-f]*:  5d 24           mustr r4
++ *[0-9a-f]*:  5d 2e           mustr lr
++ *[0-9a-f]*:  5d 21           mustr r1
++ *[0-9a-f]*:  5d 24           mustr r4
++ *[0-9a-f]*:  5d 2c           mustr r12
++
++[0-9a-f]* <musfr>:
++ *[0-9a-f]*:  5d 3f           musfr pc
++ *[0-9a-f]*:  5d 3c           musfr r12
++ *[0-9a-f]*:  5d 35           musfr r5
++ *[0-9a-f]*:  5d 34           musfr r4
++ *[0-9a-f]*:  5d 3e           musfr lr
++ *[0-9a-f]*:  5d 3b           musfr r11
++ *[0-9a-f]*:  5d 3c           musfr r12
++ *[0-9a-f]*:  5d 32           musfr r2
++
++[0-9a-f]* <ret_cond>:
++ *[0-9a-f]*:  5e 0f           reteq 1
++ *[0-9a-f]*:  5e fc           retal r12
++ *[0-9a-f]*:  5e 85           retls r5
++ *[0-9a-f]*:  5e 74           retpl r4
++ *[0-9a-f]*:  5e 1e           retne -1
++ *[0-9a-f]*:  5e 90           retgt r0
++ *[0-9a-f]*:  5e 9c           retgt r12
++ *[0-9a-f]*:  5e 4a           retge r10
++
++[0-9a-f]* <sr_cond>:
++ *[0-9a-f]*:  5f 0f           sreq pc
++ *[0-9a-f]*:  5f fc           sral r12
++ *[0-9a-f]*:  5f 85           srls r5
++ *[0-9a-f]*:  5f 74           srpl r4
++ *[0-9a-f]*:  5f 1e           srne lr
++ *[0-9a-f]*:  5f 50           srlt r0
++ *[0-9a-f]*:  5f fd           sral sp
++ *[0-9a-f]*:  5f 49           srge r9
++
++[0-9a-f]* <ld_w3>:
++ *[0-9a-f]*:  7e 0f           ld\.w pc,pc\[0x0\]
++ *[0-9a-f]*:  79 fc           ld\.w r12,r12\[0x7c\]
++ *[0-9a-f]*:  6b 05           ld\.w r5,r5\[0x40\]
++ *[0-9a-f]*:  68 f4           ld\.w r4,r4\[0x3c\]
++ *[0-9a-f]*:  7c 1e           ld\.w lr,lr\[0x4\]
++ *[0-9a-f]*:  64 dd           ld\.w sp,r2\[0x34\]
++ *[0-9a-f]*:  62 29           ld\.w r9,r1\[0x8\]
++ *[0-9a-f]*:  7a f5           ld\.w r5,sp\[0x3c\]
++
++[0-9a-f]* <ld_sh3>:
++ *[0-9a-f]*:  9e 0f           ld\.sh pc,pc\[0x0\]
++ *[0-9a-f]*:  98 7c           ld\.sh r12,r12\[0xe\]
++ *[0-9a-f]*:  8a 45           ld\.sh r5,r5\[0x8\]
++ *[0-9a-f]*:  88 34           ld\.sh r4,r4\[0x6\]
++ *[0-9a-f]*:  9c 1e           ld\.sh lr,lr\[0x2\]
++ *[0-9a-f]*:  84 44           ld\.sh r4,r2\[0x8\]
++ *[0-9a-f]*:  9c 5d           ld\.sh sp,lr\[0xa\]
++ *[0-9a-f]*:  96 12           ld\.sh r2,r11\[0x2\]
++
++[0-9a-f]* <ld_uh3>:
++ *[0-9a-f]*:  9e 8f           ld\.uh pc,pc\[0x0\]
++ *[0-9a-f]*:  98 fc           ld\.uh r12,r12\[0xe\]
++ *[0-9a-f]*:  8a c5           ld\.uh r5,r5\[0x8\]
++ *[0-9a-f]*:  88 b4           ld\.uh r4,r4\[0x6\]
++ *[0-9a-f]*:  9c 9e           ld\.uh lr,lr\[0x2\]
++ *[0-9a-f]*:  80 da           ld\.uh r10,r0\[0xa\]
++ *[0-9a-f]*:  96 c8           ld\.uh r8,r11\[0x8\]
++ *[0-9a-f]*:  84 ea           ld\.uh r10,r2\[0xc\]
++
++[0-9a-f]* <st_w3>:
++ *[0-9a-f]*:  9f 0f           st\.w pc\[0x0\],pc
++ *[0-9a-f]*:  99 fc           st\.w r12\[0x3c\],r12
++ *[0-9a-f]*:  8b 85           st\.w r5\[0x20\],r5
++ *[0-9a-f]*:  89 74           st\.w r4\[0x1c\],r4
++ *[0-9a-f]*:  9d 1e           st\.w lr\[0x4\],lr
++ *[0-9a-f]*:  8f bb           st\.w r7\[0x2c\],r11
++ *[0-9a-f]*:  85 66           st\.w r2\[0x18\],r6
++ *[0-9a-f]*:  89 39           st\.w r4\[0xc\],r9
++
++[0-9a-f]* <st_h3>:
++ *[0-9a-f]*:  be 0f           st\.h pc\[0x0\],pc
++ *[0-9a-f]*:  b8 7c           st\.h r12\[0xe\],r12
++ *[0-9a-f]*:  aa 45           st\.h r5\[0x8\],r5
++ *[0-9a-f]*:  a8 34           st\.h r4\[0x6\],r4
++ *[0-9a-f]*:  bc 1e           st\.h lr\[0x2\],lr
++ *[0-9a-f]*:  bc 5c           st\.h lr\[0xa\],r12
++ *[0-9a-f]*:  ac 20           st\.h r6\[0x4\],r0
++ *[0-9a-f]*:  aa 6d           st\.h r5\[0xc\],sp
++
++[0-9a-f]* <st_b3>:
++ *[0-9a-f]*:  be 8f           st\.b pc\[0x0\],pc
++ *[0-9a-f]*:  b8 fc           st\.b r12\[0x7\],r12
++ *[0-9a-f]*:  aa c5           st\.b r5\[0x4\],r5
++ *[0-9a-f]*:  a8 b4           st\.b r4\[0x3\],r4
++ *[0-9a-f]*:  bc 9e           st\.b lr\[0x1\],lr
++ *[0-9a-f]*:  b8 e9           st\.b r12\[0x6\],r9
++ *[0-9a-f]*:  a4 be           st\.b r2\[0x3\],lr
++ *[0-9a-f]*:  a2 bb           st\.b r1\[0x3\],r11
++
++[0-9a-f]* <ldd>:
++ *[0-9a-f]*:  bf 00           ld\.d r0,pc
++ *[0-9a-f]*:  b9 0e           ld\.d lr,r12
++ *[0-9a-f]*:  ab 08           ld\.d r8,r5
++ *[0-9a-f]*:  a9 06           ld\.d r6,r4
++ *[0-9a-f]*:  bd 02           ld\.d r2,lr
++ *[0-9a-f]*:  af 0e           ld\.d lr,r7
++ *[0-9a-f]*:  a9 04           ld\.d r4,r4
++ *[0-9a-f]*:  bf 0e           ld\.d lr,pc
++
++[0-9a-f]* <ldd_postinc>:
++ *[0-9a-f]*:  bf 01           ld\.d r0,pc\+\+
++ *[0-9a-f]*:  b9 0f           ld\.d lr,r12\+\+
++ *[0-9a-f]*:  ab 09           ld\.d r8,r5\+\+
++ *[0-9a-f]*:  a9 07           ld\.d r6,r4\+\+
++ *[0-9a-f]*:  bd 03           ld\.d r2,lr\+\+
++ *[0-9a-f]*:  ab 0f           ld\.d lr,r5\+\+
++ *[0-9a-f]*:  b7 0d           ld\.d r12,r11\+\+
++ *[0-9a-f]*:  b9 03           ld\.d r2,r12\+\+
++
++[0-9a-f]* <ldd_predec>:
++ *[0-9a-f]*:  bf 10           ld\.d r0,--pc
++ *[0-9a-f]*:  b9 1e           ld\.d lr,--r12
++ *[0-9a-f]*:  ab 18           ld\.d r8,--r5
++ *[0-9a-f]*:  a9 16           ld\.d r6,--r4
++ *[0-9a-f]*:  bd 12           ld\.d r2,--lr
++ *[0-9a-f]*:  a1 18           ld\.d r8,--r0
++ *[0-9a-f]*:  bf 1a           ld\.d r10,--pc
++ *[0-9a-f]*:  a9 12           ld\.d r2,--r4
++
++[0-9a-f]* <std>:
++ *[0-9a-f]*:  bf 11           st\.d pc,r0
++ *[0-9a-f]*:  b9 1f           st\.d r12,lr
++ *[0-9a-f]*:  ab 19           st\.d r5,r8
++ *[0-9a-f]*:  a9 17           st\.d r4,r6
++ *[0-9a-f]*:  bd 13           st\.d lr,r2
++ *[0-9a-f]*:  a1 1d           st\.d r0,r12
++ *[0-9a-f]*:  bb 15           st\.d sp,r4
++ *[0-9a-f]*:  b9 1d           st\.d r12,r12
++
++[0-9a-f]* <std_postinc>:
++ *[0-9a-f]*:  bf 20           st\.d pc\+\+,r0
++ *[0-9a-f]*:  b9 2e           st\.d r12\+\+,lr
++ *[0-9a-f]*:  ab 28           st\.d r5\+\+,r8
++ *[0-9a-f]*:  a9 26           st\.d r4\+\+,r6
++ *[0-9a-f]*:  bd 22           st\.d lr\+\+,r2
++ *[0-9a-f]*:  bb 26           st\.d sp\+\+,r6
++ *[0-9a-f]*:  b5 26           st\.d r10\+\+,r6
++ *[0-9a-f]*:  af 22           st\.d r7\+\+,r2
++
++[0-9a-f]* <std_predec>:
++ *[0-9a-f]*:  bf 21           st\.d --pc,r0
++ *[0-9a-f]*:  b9 2f           st\.d --r12,lr
++ *[0-9a-f]*:  ab 29           st\.d --r5,r8
++ *[0-9a-f]*:  a9 27           st\.d --r4,r6
++ *[0-9a-f]*:  bd 23           st\.d --lr,r2
++ *[0-9a-f]*:  a7 27           st\.d --r3,r6
++ *[0-9a-f]*:  bd 23           st\.d --lr,r2
++ *[0-9a-f]*:  a1 25           st\.d --r0,r4
++
++[0-9a-f]* <mul>:
++ *[0-9a-f]*:  bf 3f           mul pc,pc
++ *[0-9a-f]*:  b9 3c           mul r12,r12
++ *[0-9a-f]*:  ab 35           mul r5,r5
++ *[0-9a-f]*:  a9 34           mul r4,r4
++ *[0-9a-f]*:  bd 3e           mul lr,lr
++ *[0-9a-f]*:  bd 3a           mul r10,lr
++ *[0-9a-f]*:  b1 30           mul r0,r8
++ *[0-9a-f]*:  ab 38           mul r8,r5
++
++[0-9a-f]* <asr_imm5>:
++ *[0-9a-f]*:  a1 4f           asr pc,0x0
++ *[0-9a-f]*:  bf 5c           asr r12,0x1f
++ *[0-9a-f]*:  b1 45           asr r5,0x10
++ *[0-9a-f]*:  af 54           asr r4,0xf
++ *[0-9a-f]*:  a1 5e           asr lr,0x1
++ *[0-9a-f]*:  b7 56           asr r6,0x17
++ *[0-9a-f]*:  b3 46           asr r6,0x12
++ *[0-9a-f]*:  a9 45           asr r5,0x8
++
++[0-9a-f]* <lsl_imm5>:
++ *[0-9a-f]*:  a1 6f           lsl pc,0x0
++ *[0-9a-f]*:  bf 7c           lsl r12,0x1f
++ *[0-9a-f]*:  b1 65           lsl r5,0x10
++ *[0-9a-f]*:  af 74           lsl r4,0xf
++ *[0-9a-f]*:  a1 7e           lsl lr,0x1
++ *[0-9a-f]*:  ad 7c           lsl r12,0xd
++ *[0-9a-f]*:  b1 66           lsl r6,0x10
++ *[0-9a-f]*:  b9 71           lsl r1,0x19
++
++[0-9a-f]* <lsr_imm5>:
++ *[0-9a-f]*:  a1 8f           lsr pc,0x0
++ *[0-9a-f]*:  bf 9c           lsr r12,0x1f
++ *[0-9a-f]*:  b1 85           lsr r5,0x10
++ *[0-9a-f]*:  af 94           lsr r4,0xf
++ *[0-9a-f]*:  a1 9e           lsr lr,0x1
++ *[0-9a-f]*:  a1 90           lsr r0,0x1
++ *[0-9a-f]*:  ab 88           lsr r8,0xa
++ *[0-9a-f]*:  bb 87           lsr r7,0x1a
++
++[0-9a-f]* <sbr>:
++ *[0-9a-f]*:  a1 af           sbr pc,0x0
++ *[0-9a-f]*:  bf bc           sbr r12,0x1f
++ *[0-9a-f]*:  b1 a5           sbr r5,0x10
++ *[0-9a-f]*:  af b4           sbr r4,0xf
++ *[0-9a-f]*:  a1 be           sbr lr,0x1
++ *[0-9a-f]*:  bf b8           sbr r8,0x1f
++ *[0-9a-f]*:  b7 a6           sbr r6,0x16
++ *[0-9a-f]*:  b7 b1           sbr r1,0x17
++
++[0-9a-f]* <cbr>:
++ *[0-9a-f]*:  a1 cf           cbr pc,0x0
++ *[0-9a-f]*:  bf dc           cbr r12,0x1f
++ *[0-9a-f]*:  b1 c5           cbr r5,0x10
++ *[0-9a-f]*:  af d4           cbr r4,0xf
++ *[0-9a-f]*:  a1 de           cbr lr,0x1
++ *[0-9a-f]*:  ab cc           cbr r12,0xa
++ *[0-9a-f]*:  b7 c7           cbr r7,0x16
++ *[0-9a-f]*:  a9 d8           cbr r8,0x9
++
++[0-9a-f]* <brc1>:
++ *[0-9a-f]*:  c0 00           breq [0-9a-f]* <.*>
++ *[0-9a-f]*:  cf f7           brpl [0-9a-f]* <.*>
++ *[0-9a-f]*:  c8 04           brge [0-9a-f]* <.*>
++ *[0-9a-f]*:  c7 f3           brcs [0-9a-f]* <.*>
++ *[0-9a-f]*:  c0 11           brne [0-9a-f]* <.*>
++ *[0-9a-f]*:  c7 33           brcs [0-9a-f]* <.*>
++ *[0-9a-f]*:  cf 70           breq [0-9a-f]* <.*>
++ *[0-9a-f]*:  c0 60           breq [0-9a-f]* <.*>
++
++[0-9a-f]* <rjmp>:
++ *[0-9a-f]*:  c0 08           rjmp [0-9a-f]* <.*>
++ *[0-9a-f]*:  cf fb           rjmp [0-9a-f]* <.*>
++ *[0-9a-f]*:  c0 0a           rjmp [0-9a-f]* <.*>
++ *[0-9a-f]*:  cf f9           rjmp [0-9a-f]* <.*>
++ *[0-9a-f]*:  c0 18           rjmp [0-9a-f]* <.*>
++ *[0-9a-f]*:  c1 fa           rjmp [0-9a-f]* <.*>
++ *[0-9a-f]*:  c0 78           rjmp [0-9a-f]* <.*>
++ *[0-9a-f]*:  cf ea           rjmp [0-9a-f]* <.*>
++
++[0-9a-f]* <rcall1>:
++ *[0-9a-f]*:  c0 0c           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  cf ff           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  c0 0e           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  cf fd           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  c0 1c           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  c6 cc           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  cf 7e           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  c1 ae           rcall [0-9a-f]* <.*>
++
++[0-9a-f]* <acall>:
++ *[0-9a-f]*:  d0 00           acall 0x0
++ *[0-9a-f]*:  df f0           acall 0x3fc
++ *[0-9a-f]*:  d8 00           acall 0x200
++ *[0-9a-f]*:  d7 f0           acall 0x1fc
++ *[0-9a-f]*:  d0 10           acall 0x4
++ *[0-9a-f]*:  d5 90           acall 0x164
++ *[0-9a-f]*:  d4 c0           acall 0x130
++ *[0-9a-f]*:  d2 b0           acall 0xac
++
++[0-9a-f]* <scall>:
++ *[0-9a-f]*:  d7 33           scall
++ *[0-9a-f]*:  d7 33           scall
++ *[0-9a-f]*:  d7 33           scall
++ *[0-9a-f]*:  d7 33           scall
++ *[0-9a-f]*:  d7 33           scall
++ *[0-9a-f]*:  d7 33           scall
++ *[0-9a-f]*:  d7 33           scall
++ *[0-9a-f]*:  d7 33           scall
++
++[0-9a-f]* <popm>:
++ *[0-9a-f]*:  d8 02           popm pc
++ *[0-9a-f]*:  dd fa           popm r0-r11,pc,r12=-1
++ *[0-9a-f]*:  d4 02           popm lr
++ *[0-9a-f]*:  db fa           popm r0-r11,pc,r12=1
++ *[0-9a-f]*:  d0 12           popm r0-r3
++ *[0-9a-f]*:  d8 e2           popm r4-r10,pc
++ *[0-9a-f]*:  d9 1a           popm r0-r3,r11,pc,r12=0
++ *[0-9a-f]*:  d7 b2           popm r0-r7,r10-r12,lr
++
++[0-9a-f]* <pushm>:
++ *[0-9a-f]*:  d8 01           pushm pc
++ *[0-9a-f]*:  df f1           pushm r0-r12,lr-pc
++ *[0-9a-f]*:  d8 01           pushm pc
++ *[0-9a-f]*:  d7 f1           pushm r0-r12,lr
++ *[0-9a-f]*:  d0 11           pushm r0-r3
++ *[0-9a-f]*:  dc c1           pushm r8-r10,lr-pc
++ *[0-9a-f]*:  d0 91           pushm r0-r3,r10
++ *[0-9a-f]*:  d2 41           pushm r8-r9,r12
++
++[0-9a-f]* <popm_n>:
++.*
++.*
++.*
++.*
++.*
++.*
++.*
++.*
++
++[0-9a-f]* <pushm_n>:
++.*
++.*
++.*
++.*
++.*
++.*
++.*
++.*
++
++[0-9a-f]* <csrfcz>:
++ *[0-9a-f]*:  d0 03           csrfcz 0x0
++ *[0-9a-f]*:  d1 f3           csrfcz 0x1f
++ *[0-9a-f]*:  d1 03           csrfcz 0x10
++ *[0-9a-f]*:  d0 f3           csrfcz 0xf
++ *[0-9a-f]*:  d0 13           csrfcz 0x1
++ *[0-9a-f]*:  d0 53           csrfcz 0x5
++ *[0-9a-f]*:  d0 d3           csrfcz 0xd
++ *[0-9a-f]*:  d1 73           csrfcz 0x17
++
++[0-9a-f]* <ssrf>:
++ *[0-9a-f]*:  d2 03           ssrf 0x0
++ *[0-9a-f]*:  d3 f3           ssrf 0x1f
++ *[0-9a-f]*:  d3 03           ssrf 0x10
++ *[0-9a-f]*:  d2 f3           ssrf 0xf
++ *[0-9a-f]*:  d2 13           ssrf 0x1
++ *[0-9a-f]*:  d3 d3           ssrf 0x1d
++ *[0-9a-f]*:  d2 d3           ssrf 0xd
++ *[0-9a-f]*:  d2 d3           ssrf 0xd
++
++[0-9a-f]* <csrf>:
++ *[0-9a-f]*:  d4 03           csrf 0x0
++ *[0-9a-f]*:  d5 f3           csrf 0x1f
++ *[0-9a-f]*:  d5 03           csrf 0x10
++ *[0-9a-f]*:  d4 f3           csrf 0xf
++ *[0-9a-f]*:  d4 13           csrf 0x1
++ *[0-9a-f]*:  d4 a3           csrf 0xa
++ *[0-9a-f]*:  d4 f3           csrf 0xf
++ *[0-9a-f]*:  d4 b3           csrf 0xb
++
++[0-9a-f]* <rete>:
++ *[0-9a-f]*:  d6 03           rete
++
++[0-9a-f]* <rets>:
++ *[0-9a-f]*:  d6 13           rets
++
++[0-9a-f]* <retd>:
++ *[0-9a-f]*:  d6 23           retd
++
++[0-9a-f]* <retj>:
++ *[0-9a-f]*:  d6 33           retj
++
++[0-9a-f]* <tlbr>:
++ *[0-9a-f]*:  d6 43           tlbr
++
++[0-9a-f]* <tlbs>:
++ *[0-9a-f]*:  d6 53           tlbs
++
++[0-9a-f]* <tlbw>:
++ *[0-9a-f]*:  d6 63           tlbw
++
++[0-9a-f]* <breakpoint>:
++ *[0-9a-f]*:  d6 73           breakpoint
++
++[0-9a-f]* <incjosp>:
++ *[0-9a-f]*:  d6 83           incjosp 1
++ *[0-9a-f]*:  d6 93           incjosp 2
++ *[0-9a-f]*:  d6 a3           incjosp 3
++ *[0-9a-f]*:  d6 b3           incjosp 4
++ *[0-9a-f]*:  d6 c3           incjosp -4
++ *[0-9a-f]*:  d6 d3           incjosp -3
++ *[0-9a-f]*:  d6 e3           incjosp -2
++ *[0-9a-f]*:  d6 f3           incjosp -1
++
++[0-9a-f]* <nop>:
++ *[0-9a-f]*:  d7 03           nop
++
++[0-9a-f]* <popjc>:
++ *[0-9a-f]*:  d7 13           popjc
++
++[0-9a-f]* <pushjc>:
++ *[0-9a-f]*:  d7 23           pushjc
++
++[0-9a-f]* <add2>:
++ *[0-9a-f]*:  fe 0f 00 0f     add pc,pc,pc
++ *[0-9a-f]*:  f8 0c 00 3c     add r12,r12,r12<<0x3
++ *[0-9a-f]*:  ea 05 00 25     add r5,r5,r5<<0x2
++ *[0-9a-f]*:  e8 04 00 14     add r4,r4,r4<<0x1
++ *[0-9a-f]*:  fc 0e 00 1e     add lr,lr,lr<<0x1
++ *[0-9a-f]*:  f8 00 00 10     add r0,r12,r0<<0x1
++ *[0-9a-f]*:  f8 04 00 09     add r9,r12,r4
++ *[0-9a-f]*:  f8 07 00 2c     add r12,r12,r7<<0x2
++
++[0-9a-f]* <sub2>:
++ *[0-9a-f]*:  fe 0f 01 0f     sub pc,pc,pc
++ *[0-9a-f]*:  f8 0c 01 3c     sub r12,r12,r12<<0x3
++ *[0-9a-f]*:  ea 05 01 25     sub r5,r5,r5<<0x2
++ *[0-9a-f]*:  e8 04 01 14     sub r4,r4,r4<<0x1
++ *[0-9a-f]*:  fc 0e 01 1e     sub lr,lr,lr<<0x1
++ *[0-9a-f]*:  e6 04 01 0d     sub sp,r3,r4
++ *[0-9a-f]*:  ee 03 01 03     sub r3,r7,r3
++ *[0-9a-f]*:  f4 0d 01 1d     sub sp,r10,sp<<0x1
++
++[0-9a-f]* <divu>:
++ *[0-9a-f]*:  fe 0f 0d 0f     divu pc,pc,pc
++ *[0-9a-f]*:  f8 0c 0d 0c     divu r12,r12,r12
++ *[0-9a-f]*:  ea 05 0d 05     divu r5,r5,r5
++ *[0-9a-f]*:  e8 04 0d 04     divu r4,r4,r4
++ *[0-9a-f]*:  fc 0e 0d 0e     divu lr,lr,lr
++ *[0-9a-f]*:  e8 0f 0d 0d     divu sp,r4,pc
++ *[0-9a-f]*:  ea 0d 0d 05     divu r5,r5,sp
++ *[0-9a-f]*:  fa 00 0d 0a     divu r10,sp,r0
++
++[0-9a-f]* <addhh_w>:
++ *[0-9a-f]*:  fe 0f 0e 0f     addhh\.w pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 0e 3c     addhh\.w r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 0e 35     addhh\.w r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 0e 04     addhh\.w r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 0e 3e     addhh\.w lr,lr:t,lr:t
++ *[0-9a-f]*:  e0 03 0e 00     addhh\.w r0,r0:b,r3:b
++ *[0-9a-f]*:  f8 07 0e 2e     addhh\.w lr,r12:t,r7:b
++ *[0-9a-f]*:  f4 02 0e 23     addhh\.w r3,r10:t,r2:b
++
++[0-9a-f]* <subhh_w>:
++ *[0-9a-f]*:  fe 0f 0f 0f     subhh\.w pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 0f 3c     subhh\.w r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 0f 35     subhh\.w r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 0f 04     subhh\.w r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 0f 3e     subhh\.w lr,lr:t,lr:t
++ *[0-9a-f]*:  e2 07 0f 2a     subhh\.w r10,r1:t,r7:b
++ *[0-9a-f]*:  f4 0e 0f 3f     subhh\.w pc,r10:t,lr:t
++ *[0-9a-f]*:  e0 0c 0f 23     subhh\.w r3,r0:t,r12:b
++
++[0-9a-f]* <adc>:
++ *[0-9a-f]*:  fe 0f 00 4f     adc pc,pc,pc
++ *[0-9a-f]*:  f8 0c 00 4c     adc r12,r12,r12
++ *[0-9a-f]*:  ea 05 00 45     adc r5,r5,r5
++ *[0-9a-f]*:  e8 04 00 44     adc r4,r4,r4
++ *[0-9a-f]*:  fc 0e 00 4e     adc lr,lr,lr
++ *[0-9a-f]*:  e0 07 00 44     adc r4,r0,r7
++ *[0-9a-f]*:  e8 03 00 4d     adc sp,r4,r3
++ *[0-9a-f]*:  f8 00 00 42     adc r2,r12,r0
++
++[0-9a-f]* <sbc>:
++ *[0-9a-f]*:  fe 0f 01 4f     sbc pc,pc,pc
++ *[0-9a-f]*:  f8 0c 01 4c     sbc r12,r12,r12
++ *[0-9a-f]*:  ea 05 01 45     sbc r5,r5,r5
++ *[0-9a-f]*:  e8 04 01 44     sbc r4,r4,r4
++ *[0-9a-f]*:  fc 0e 01 4e     sbc lr,lr,lr
++ *[0-9a-f]*:  ee 09 01 46     sbc r6,r7,r9
++ *[0-9a-f]*:  f0 05 01 40     sbc r0,r8,r5
++ *[0-9a-f]*:  e0 04 01 41     sbc r1,r0,r4
++
++[0-9a-f]* <mul_2>:
++ *[0-9a-f]*:  fe 0f 02 4f     mul pc,pc,pc
++ *[0-9a-f]*:  f8 0c 02 4c     mul r12,r12,r12
++ *[0-9a-f]*:  ea 05 02 45     mul r5,r5,r5
++ *[0-9a-f]*:  e8 04 02 44     mul r4,r4,r4
++ *[0-9a-f]*:  fc 0e 02 4e     mul lr,lr,lr
++ *[0-9a-f]*:  e0 00 02 4f     mul pc,r0,r0
++ *[0-9a-f]*:  fe 0e 02 48     mul r8,pc,lr
++ *[0-9a-f]*:  f8 0f 02 44     mul r4,r12,pc
++
++[0-9a-f]* <mac>:
++ *[0-9a-f]*:  fe 0f 03 4f     mac pc,pc,pc
++ *[0-9a-f]*:  f8 0c 03 4c     mac r12,r12,r12
++ *[0-9a-f]*:  ea 05 03 45     mac r5,r5,r5
++ *[0-9a-f]*:  e8 04 03 44     mac r4,r4,r4
++ *[0-9a-f]*:  fc 0e 03 4e     mac lr,lr,lr
++ *[0-9a-f]*:  e8 00 03 4a     mac r10,r4,r0
++ *[0-9a-f]*:  fc 00 03 47     mac r7,lr,r0
++ *[0-9a-f]*:  f2 0c 03 42     mac r2,r9,r12
++
++[0-9a-f]* <mulsd>:
++ *[0-9a-f]*:  fe 0f 04 4f     muls\.d pc,pc,pc
++ *[0-9a-f]*:  f8 0c 04 4c     muls\.d r12,r12,r12
++ *[0-9a-f]*:  ea 05 04 45     muls\.d r5,r5,r5
++ *[0-9a-f]*:  e8 04 04 44     muls\.d r4,r4,r4
++ *[0-9a-f]*:  fc 0e 04 4e     muls\.d lr,lr,lr
++ *[0-9a-f]*:  f0 0e 04 42     muls\.d r2,r8,lr
++ *[0-9a-f]*:  e0 0b 04 44     muls\.d r4,r0,r11
++ *[0-9a-f]*:  fc 06 04 45     muls\.d r5,lr,r6
++
++[0-9a-f]* <macsd>:
++ *[0-9a-f]*:  fe 0f 05 40     macs\.d r0,pc,pc
++ *[0-9a-f]*:  f8 0c 05 4e     macs\.d lr,r12,r12
++ *[0-9a-f]*:  ea 05 05 48     macs\.d r8,r5,r5
++ *[0-9a-f]*:  e8 04 05 46     macs\.d r6,r4,r4
++ *[0-9a-f]*:  fc 0e 05 42     macs\.d r2,lr,lr
++ *[0-9a-f]*:  e2 09 05 48     macs\.d r8,r1,r9
++ *[0-9a-f]*:  f0 08 05 4e     macs\.d lr,r8,r8
++ *[0-9a-f]*:  e6 0c 05 44     macs\.d r4,r3,r12
++
++[0-9a-f]* <mulud>:
++ *[0-9a-f]*:  fe 0f 06 40     mulu\.d r0,pc,pc
++ *[0-9a-f]*:  f8 0c 06 4e     mulu\.d lr,r12,r12
++ *[0-9a-f]*:  ea 05 06 48     mulu\.d r8,r5,r5
++ *[0-9a-f]*:  e8 04 06 46     mulu\.d r6,r4,r4
++ *[0-9a-f]*:  fc 0e 06 42     mulu\.d r2,lr,lr
++ *[0-9a-f]*:  ea 00 06 46     mulu\.d r6,r5,r0
++ *[0-9a-f]*:  ec 01 06 44     mulu\.d r4,r6,r1
++ *[0-9a-f]*:  f0 02 06 48     mulu\.d r8,r8,r2
++
++[0-9a-f]* <macud>:
++ *[0-9a-f]*:  fe 0f 07 40     macu\.d r0,pc,pc
++ *[0-9a-f]*:  f8 0c 07 4e     macu\.d lr,r12,r12
++ *[0-9a-f]*:  ea 05 07 48     macu\.d r8,r5,r5
++ *[0-9a-f]*:  e8 04 07 46     macu\.d r6,r4,r4
++ *[0-9a-f]*:  fc 0e 07 42     macu\.d r2,lr,lr
++ *[0-9a-f]*:  fa 0b 07 46     macu\.d r6,sp,r11
++ *[0-9a-f]*:  e8 08 07 42     macu\.d r2,r4,r8
++ *[0-9a-f]*:  f4 09 07 46     macu\.d r6,r10,r9
++
++[0-9a-f]* <asr_1>:
++ *[0-9a-f]*:  fe 0f 08 4f     asr pc,pc,pc
++ *[0-9a-f]*:  f8 0c 08 4c     asr r12,r12,r12
++ *[0-9a-f]*:  ea 05 08 45     asr r5,r5,r5
++ *[0-9a-f]*:  e8 04 08 44     asr r4,r4,r4
++ *[0-9a-f]*:  fc 0e 08 4e     asr lr,lr,lr
++ *[0-9a-f]*:  ec 0f 08 4f     asr pc,r6,pc
++ *[0-9a-f]*:  ec 0c 08 40     asr r0,r6,r12
++ *[0-9a-f]*:  fa 00 08 44     asr r4,sp,r0
++
++[0-9a-f]* <lsl_1>:
++ *[0-9a-f]*:  fe 0f 09 4f     lsl pc,pc,pc
++ *[0-9a-f]*:  f8 0c 09 4c     lsl r12,r12,r12
++ *[0-9a-f]*:  ea 05 09 45     lsl r5,r5,r5
++ *[0-9a-f]*:  e8 04 09 44     lsl r4,r4,r4
++ *[0-9a-f]*:  fc 0e 09 4e     lsl lr,lr,lr
++ *[0-9a-f]*:  ea 0e 09 4e     lsl lr,r5,lr
++ *[0-9a-f]*:  fe 03 09 45     lsl r5,pc,r3
++ *[0-9a-f]*:  fe 09 09 41     lsl r1,pc,r9
++
++[0-9a-f]* <lsr_1>:
++ *[0-9a-f]*:  fe 0f 0a 4f     lsr pc,pc,pc
++ *[0-9a-f]*:  f8 0c 0a 4c     lsr r12,r12,r12
++ *[0-9a-f]*:  ea 05 0a 45     lsr r5,r5,r5
++ *[0-9a-f]*:  e8 04 0a 44     lsr r4,r4,r4
++ *[0-9a-f]*:  fc 0e 0a 4e     lsr lr,lr,lr
++ *[0-9a-f]*:  e8 01 0a 42     lsr r2,r4,r1
++ *[0-9a-f]*:  e2 06 0a 45     lsr r5,r1,r6
++ *[0-9a-f]*:  ec 07 0a 4d     lsr sp,r6,r7
++
++[0-9a-f]* <xchg>:
++ *[0-9a-f]*:  fe 0f 0b 4f     xchg pc,pc,pc
++ *[0-9a-f]*:  f8 0c 0b 4c     xchg r12,r12,r12
++ *[0-9a-f]*:  ea 05 0b 45     xchg r5,r5,r5
++ *[0-9a-f]*:  e8 04 0b 44     xchg r4,r4,r4
++ *[0-9a-f]*:  fc 0e 0b 4e     xchg lr,lr,lr
++ *[0-9a-f]*:  e8 0d 0b 4e     xchg lr,r4,sp
++ *[0-9a-f]*:  ea 0c 0b 41     xchg r1,r5,r12
++ *[0-9a-f]*:  f8 00 0b 4e     xchg lr,r12,r0
++
++[0-9a-f]* <max>:
++ *[0-9a-f]*:  fe 0f 0c 4f     max pc,pc,pc
++ *[0-9a-f]*:  f8 0c 0c 4c     max r12,r12,r12
++ *[0-9a-f]*:  ea 05 0c 45     max r5,r5,r5
++ *[0-9a-f]*:  e8 04 0c 44     max r4,r4,r4
++ *[0-9a-f]*:  fc 0e 0c 4e     max lr,lr,lr
++ *[0-9a-f]*:  e4 0d 0c 4e     max lr,r2,sp
++ *[0-9a-f]*:  f4 09 0c 44     max r4,r10,r9
++ *[0-9a-f]*:  f2 0e 0c 4e     max lr,r9,lr
++
++[0-9a-f]* <min>:
++ *[0-9a-f]*:  fe 0f 0d 4f     min pc,pc,pc
++ *[0-9a-f]*:  f8 0c 0d 4c     min r12,r12,r12
++ *[0-9a-f]*:  ea 05 0d 45     min r5,r5,r5
++ *[0-9a-f]*:  e8 04 0d 44     min r4,r4,r4
++ *[0-9a-f]*:  fc 0e 0d 4e     min lr,lr,lr
++ *[0-9a-f]*:  ee 08 0d 49     min r9,r7,r8
++ *[0-9a-f]*:  ea 05 0d 4d     min sp,r5,r5
++ *[0-9a-f]*:  e2 04 0d 44     min r4,r1,r4
++
++[0-9a-f]* <addabs>:
++ *[0-9a-f]*:  fe 0f 0e 4f     addabs pc,pc,pc
++ *[0-9a-f]*:  f8 0c 0e 4c     addabs r12,r12,r12
++ *[0-9a-f]*:  ea 05 0e 45     addabs r5,r5,r5
++ *[0-9a-f]*:  e8 04 0e 44     addabs r4,r4,r4
++ *[0-9a-f]*:  fc 0e 0e 4e     addabs lr,lr,lr
++ *[0-9a-f]*:  f4 00 0e 47     addabs r7,r10,r0
++ *[0-9a-f]*:  f2 07 0e 49     addabs r9,r9,r7
++ *[0-9a-f]*:  f0 0c 0e 42     addabs r2,r8,r12
++
++[0-9a-f]* <mulnhh_w>:
++ *[0-9a-f]*:  fe 0f 01 8f     mulnhh\.w pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 01 bc     mulnhh\.w r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 01 b5     mulnhh\.w r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 01 84     mulnhh\.w r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 01 be     mulnhh\.w lr,lr:t,lr:t
++ *[0-9a-f]*:  fa 09 01 ab     mulnhh\.w r11,sp:t,r9:b
++ *[0-9a-f]*:  e8 0e 01 9d     mulnhh\.w sp,r4:b,lr:t
++ *[0-9a-f]*:  e4 0b 01 ac     mulnhh\.w r12,r2:t,r11:b
++
++[0-9a-f]* <mulnwh_d>:
++ *[0-9a-f]*:  fe 0f 02 80     mulnwh\.d r0,pc,pc:b
++ *[0-9a-f]*:  f8 0c 02 9e     mulnwh\.d lr,r12,r12:t
++ *[0-9a-f]*:  ea 05 02 98     mulnwh\.d r8,r5,r5:t
++ *[0-9a-f]*:  e8 04 02 86     mulnwh\.d r6,r4,r4:b
++ *[0-9a-f]*:  fc 0e 02 92     mulnwh\.d r2,lr,lr:t
++ *[0-9a-f]*:  e6 02 02 9e     mulnwh\.d lr,r3,r2:t
++ *[0-9a-f]*:  ea 09 02 84     mulnwh\.d r4,r5,r9:b
++ *[0-9a-f]*:  e8 04 02 9c     mulnwh\.d r12,r4,r4:t
++
++[0-9a-f]* <machh_w>:
++ *[0-9a-f]*:  fe 0f 04 8f     machh\.w pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 04 bc     machh\.w r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 04 b5     machh\.w r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 04 84     machh\.w r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 04 be     machh\.w lr,lr:t,lr:t
++ *[0-9a-f]*:  ea 01 04 9e     machh\.w lr,r5:b,r1:t
++ *[0-9a-f]*:  ec 07 04 89     machh\.w r9,r6:b,r7:b
++ *[0-9a-f]*:  fc 0c 04 a5     machh\.w r5,lr:t,r12:b
++
++[0-9a-f]* <machh_d>:
++ *[0-9a-f]*:  fe 0f 05 80     machh\.d r0,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 05 be     machh\.d lr,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 05 b8     machh\.d r8,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 05 86     machh\.d r6,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 05 b2     machh\.d r2,lr:t,lr:t
++ *[0-9a-f]*:  e0 08 05 8a     machh\.d r10,r0:b,r8:b
++ *[0-9a-f]*:  e8 05 05 9e     machh\.d lr,r4:b,r5:t
++ *[0-9a-f]*:  e0 04 05 98     machh\.d r8,r0:b,r4:t
++
++[0-9a-f]* <macsathh_w>:
++ *[0-9a-f]*:  fe 0f 06 8f     macsathh\.w pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 06 bc     macsathh\.w r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 06 b5     macsathh\.w r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 06 84     macsathh\.w r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 06 be     macsathh\.w lr,lr:t,lr:t
++ *[0-9a-f]*:  ee 0f 06 b7     macsathh\.w r7,r7:t,pc:t
++ *[0-9a-f]*:  e4 04 06 a4     macsathh\.w r4,r2:t,r4:b
++ *[0-9a-f]*:  f0 03 06 b4     macsathh\.w r4,r8:t,r3:t
++
++[0-9a-f]* <mulhh_w>:
++ *[0-9a-f]*:  fe 0f 07 8f     mulhh\.w pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 07 bc     mulhh\.w r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 07 b5     mulhh\.w r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 07 84     mulhh\.w r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 07 be     mulhh\.w lr,lr:t,lr:t
++ *[0-9a-f]*:  e8 09 07 a7     mulhh\.w r7,r4:t,r9:b
++ *[0-9a-f]*:  e6 07 07 bf     mulhh\.w pc,r3:t,r7:t
++ *[0-9a-f]*:  e8 09 07 9f     mulhh\.w pc,r4:b,r9:t
++
++[0-9a-f]* <mulsathh_h>:
++ *[0-9a-f]*:  fe 0f 08 8f     mulsathh\.h pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 08 bc     mulsathh\.h r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 08 b5     mulsathh\.h r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 08 84     mulsathh\.h r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 08 be     mulsathh\.h lr,lr:t,lr:t
++ *[0-9a-f]*:  e2 0d 08 83     mulsathh\.h r3,r1:b,sp:b
++ *[0-9a-f]*:  fc 0b 08 ab     mulsathh\.h r11,lr:t,r11:b
++ *[0-9a-f]*:  f0 0b 08 98     mulsathh\.h r8,r8:b,r11:t
++
++[0-9a-f]* <mulsathh_w>:
++ *[0-9a-f]*:  fe 0f 09 8f     mulsathh\.w pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 09 bc     mulsathh\.w r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 09 b5     mulsathh\.w r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 09 84     mulsathh\.w r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 09 be     mulsathh\.w lr,lr:t,lr:t
++ *[0-9a-f]*:  f6 06 09 ae     mulsathh\.w lr,r11:t,r6:b
++ *[0-9a-f]*:  ec 07 09 96     mulsathh\.w r6,r6:b,r7:t
++ *[0-9a-f]*:  e4 03 09 8a     mulsathh\.w r10,r2:b,r3:b
++
++[0-9a-f]* <mulsatrndhh_h>:
++ *[0-9a-f]*:  fe 0f 0a 8f     mulsatrndhh\.h pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 0a bc     mulsatrndhh\.h r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 0a b5     mulsatrndhh\.h r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 0a 84     mulsatrndhh\.h r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 0a be     mulsatrndhh\.h lr,lr:t,lr:t
++ *[0-9a-f]*:  ec 09 0a 8b     mulsatrndhh\.h r11,r6:b,r9:b
++ *[0-9a-f]*:  e6 08 0a 9b     mulsatrndhh\.h r11,r3:b,r8:t
++ *[0-9a-f]*:  fa 07 0a b5     mulsatrndhh\.h r5,sp:t,r7:t
++
++[0-9a-f]* <mulsatrndwh_w>:
++ *[0-9a-f]*:  fe 0f 0b 8f     mulsatrndwh\.w pc,pc,pc:b
++ *[0-9a-f]*:  f8 0c 0b 9c     mulsatrndwh\.w r12,r12,r12:t
++ *[0-9a-f]*:  ea 05 0b 95     mulsatrndwh\.w r5,r5,r5:t
++ *[0-9a-f]*:  e8 04 0b 84     mulsatrndwh\.w r4,r4,r4:b
++ *[0-9a-f]*:  fc 0e 0b 9e     mulsatrndwh\.w lr,lr,lr:t
++ *[0-9a-f]*:  f8 00 0b 85     mulsatrndwh\.w r5,r12,r0:b
++ *[0-9a-f]*:  f4 0f 0b 87     mulsatrndwh\.w r7,r10,pc:b
++ *[0-9a-f]*:  f0 05 0b 9a     mulsatrndwh\.w r10,r8,r5:t
++
++[0-9a-f]* <macwh_d>:
++ *[0-9a-f]*:  fe 0f 0c 80     macwh\.d r0,pc,pc:b
++ *[0-9a-f]*:  f8 0c 0c 9e     macwh\.d lr,r12,r12:t
++ *[0-9a-f]*:  ea 05 0c 98     macwh\.d r8,r5,r5:t
++ *[0-9a-f]*:  e8 04 0c 86     macwh\.d r6,r4,r4:b
++ *[0-9a-f]*:  fc 0e 0c 92     macwh\.d r2,lr,lr:t
++ *[0-9a-f]*:  f4 0c 0c 94     macwh\.d r4,r10,r12:t
++ *[0-9a-f]*:  ee 0d 0c 84     macwh\.d r4,r7,sp:b
++ *[0-9a-f]*:  f2 0b 0c 8e     macwh\.d lr,r9,r11:b
++
++[0-9a-f]* <mulwh_d>:
++ *[0-9a-f]*:  fe 0f 0d 80     mulwh\.d r0,pc,pc:b
++ *[0-9a-f]*:  f8 0c 0d 9e     mulwh\.d lr,r12,r12:t
++ *[0-9a-f]*:  ea 05 0d 98     mulwh\.d r8,r5,r5:t
++ *[0-9a-f]*:  e8 04 0d 86     mulwh\.d r6,r4,r4:b
++ *[0-9a-f]*:  fc 0e 0d 92     mulwh\.d r2,lr,lr:t
++ *[0-9a-f]*:  ea 01 0d 8c     mulwh\.d r12,r5,r1:b
++ *[0-9a-f]*:  e2 03 0d 90     mulwh\.d r0,r1,r3:t
++ *[0-9a-f]*:  f2 02 0d 80     mulwh\.d r0,r9,r2:b
++
++[0-9a-f]* <mulsatwh_w>:
++ *[0-9a-f]*:  fe 0f 0e 8f     mulsatwh\.w pc,pc,pc:b
++ *[0-9a-f]*:  f8 0c 0e 9c     mulsatwh\.w r12,r12,r12:t
++ *[0-9a-f]*:  ea 05 0e 95     mulsatwh\.w r5,r5,r5:t
++ *[0-9a-f]*:  e8 04 0e 84     mulsatwh\.w r4,r4,r4:b
++ *[0-9a-f]*:  fc 0e 0e 9e     mulsatwh\.w lr,lr,lr:t
++ *[0-9a-f]*:  fe 0a 0e 9b     mulsatwh\.w r11,pc,r10:t
++ *[0-9a-f]*:  f8 09 0e 9d     mulsatwh\.w sp,r12,r9:t
++ *[0-9a-f]*:  e6 02 0e 90     mulsatwh\.w r0,r3,r2:t
++
++[0-9a-f]* <ldw7>:
++ *[0-9a-f]*:  fe 0f 0f 8f     ld\.w pc,pc\[pc:b<<2\]
++ *[0-9a-f]*:  f8 0c 0f bc     ld\.w r12,r12\[r12:t<<2\]
++ *[0-9a-f]*:  ea 05 0f a5     ld\.w r5,r5\[r5:u<<2\]
++ *[0-9a-f]*:  e8 04 0f 94     ld\.w r4,r4\[r4:l<<2\]
++ *[0-9a-f]*:  fc 0e 0f 9e     ld\.w lr,lr\[lr:l<<2\]
++ *[0-9a-f]*:  f4 06 0f 99     ld\.w r9,r10\[r6:l<<2\]
++ *[0-9a-f]*:  f4 0a 0f 82     ld\.w r2,r10\[r10:b<<2\]
++ *[0-9a-f]*:  ea 0f 0f 8b     ld\.w r11,r5\[pc:b<<2\]
++
++[0-9a-f]* <satadd_w>:
++ *[0-9a-f]*:  fe 0f 00 cf     satadd\.w pc,pc,pc
++ *[0-9a-f]*:  f8 0c 00 cc     satadd\.w r12,r12,r12
++ *[0-9a-f]*:  ea 05 00 c5     satadd\.w r5,r5,r5
++ *[0-9a-f]*:  e8 04 00 c4     satadd\.w r4,r4,r4
++ *[0-9a-f]*:  fc 0e 00 ce     satadd\.w lr,lr,lr
++ *[0-9a-f]*:  f0 0b 00 c4     satadd\.w r4,r8,r11
++ *[0-9a-f]*:  f8 06 00 c3     satadd\.w r3,r12,r6
++ *[0-9a-f]*:  fc 09 00 c3     satadd\.w r3,lr,r9
++
++[0-9a-f]* <satsub_w1>:
++ *[0-9a-f]*:  fe 0f 01 cf     satsub\.w pc,pc,pc
++ *[0-9a-f]*:  f8 0c 01 cc     satsub\.w r12,r12,r12
++ *[0-9a-f]*:  ea 05 01 c5     satsub\.w r5,r5,r5
++ *[0-9a-f]*:  e8 04 01 c4     satsub\.w r4,r4,r4
++ *[0-9a-f]*:  fc 0e 01 ce     satsub\.w lr,lr,lr
++ *[0-9a-f]*:  fa 00 01 c8     satsub\.w r8,sp,r0
++ *[0-9a-f]*:  f0 04 01 c9     satsub\.w r9,r8,r4
++ *[0-9a-f]*:  fc 02 01 cf     satsub\.w pc,lr,r2
++
++[0-9a-f]* <satadd_h>:
++ *[0-9a-f]*:  fe 0f 02 cf     satadd\.h pc,pc,pc
++ *[0-9a-f]*:  f8 0c 02 cc     satadd\.h r12,r12,r12
++ *[0-9a-f]*:  ea 05 02 c5     satadd\.h r5,r5,r5
++ *[0-9a-f]*:  e8 04 02 c4     satadd\.h r4,r4,r4
++ *[0-9a-f]*:  fc 0e 02 ce     satadd\.h lr,lr,lr
++ *[0-9a-f]*:  e6 09 02 c7     satadd\.h r7,r3,r9
++ *[0-9a-f]*:  e0 02 02 c1     satadd\.h r1,r0,r2
++ *[0-9a-f]*:  e8 0e 02 c1     satadd\.h r1,r4,lr
++
++[0-9a-f]* <satsub_h>:
++ *[0-9a-f]*:  fe 0f 03 cf     satsub\.h pc,pc,pc
++ *[0-9a-f]*:  f8 0c 03 cc     satsub\.h r12,r12,r12
++ *[0-9a-f]*:  ea 05 03 c5     satsub\.h r5,r5,r5
++ *[0-9a-f]*:  e8 04 03 c4     satsub\.h r4,r4,r4
++ *[0-9a-f]*:  fc 0e 03 ce     satsub\.h lr,lr,lr
++ *[0-9a-f]*:  fc 03 03 ce     satsub\.h lr,lr,r3
++ *[0-9a-f]*:  ec 05 03 cb     satsub\.h r11,r6,r5
++ *[0-9a-f]*:  fa 00 03 c3     satsub\.h r3,sp,r0
++
++[0-9a-f]* <mul3>:
++ *[0-9a-f]*:  fe 0f 10 00     mul pc,pc,0
++ *[0-9a-f]*:  f8 0c 10 ff     mul r12,r12,-1
++ *[0-9a-f]*:  ea 05 10 80     mul r5,r5,-128
++ *[0-9a-f]*:  e8 04 10 7f     mul r4,r4,127
++ *[0-9a-f]*:  fc 0e 10 01     mul lr,lr,1
++ *[0-9a-f]*:  e4 0c 10 f9     mul r12,r2,-7
++ *[0-9a-f]*:  fe 01 10 5f     mul r1,pc,95
++ *[0-9a-f]*:  ec 04 10 13     mul r4,r6,19
++
++[0-9a-f]* <rsub2>:
++ *[0-9a-f]*:  fe 0f 11 00     rsub pc,pc,0
++ *[0-9a-f]*:  f8 0c 11 ff     rsub r12,r12,-1
++ *[0-9a-f]*:  ea 05 11 80     rsub r5,r5,-128
++ *[0-9a-f]*:  e8 04 11 7f     rsub r4,r4,127
++ *[0-9a-f]*:  fc 0e 11 01     rsub lr,lr,1
++ *[0-9a-f]*:  fc 09 11 60     rsub r9,lr,96
++ *[0-9a-f]*:  e2 0b 11 38     rsub r11,r1,56
++ *[0-9a-f]*:  ee 00 11 a9     rsub r0,r7,-87
++
++[0-9a-f]* <clz>:
++ *[0-9a-f]*:  fe 0f 12 00     clz pc,pc
++ *[0-9a-f]*:  f8 0c 12 00     clz r12,r12
++ *[0-9a-f]*:  ea 05 12 00     clz r5,r5
++ *[0-9a-f]*:  e8 04 12 00     clz r4,r4
++ *[0-9a-f]*:  fc 0e 12 00     clz lr,lr
++ *[0-9a-f]*:  e6 02 12 00     clz r2,r3
++ *[0-9a-f]*:  f6 05 12 00     clz r5,r11
++ *[0-9a-f]*:  e6 0f 12 00     clz pc,r3
++
++[0-9a-f]* <cpc1>:
++ *[0-9a-f]*:  fe 0f 13 00     cpc pc,pc
++ *[0-9a-f]*:  f8 0c 13 00     cpc r12,r12
++ *[0-9a-f]*:  ea 05 13 00     cpc r5,r5
++ *[0-9a-f]*:  e8 04 13 00     cpc r4,r4
++ *[0-9a-f]*:  fc 0e 13 00     cpc lr,lr
++ *[0-9a-f]*:  e8 0f 13 00     cpc pc,r4
++ *[0-9a-f]*:  f2 05 13 00     cpc r5,r9
++ *[0-9a-f]*:  ee 06 13 00     cpc r6,r7
++
++[0-9a-f]* <asr3>:
++ *[0-9a-f]*:  fe 0f 14 00     asr pc,pc,0x0
++ *[0-9a-f]*:  f8 0c 14 1f     asr r12,r12,0x1f
++ *[0-9a-f]*:  ea 05 14 10     asr r5,r5,0x10
++ *[0-9a-f]*:  e8 04 14 0f     asr r4,r4,0xf
++ *[0-9a-f]*:  fc 0e 14 01     asr lr,lr,0x1
++ *[0-9a-f]*:  f6 04 14 13     asr r4,r11,0x13
++ *[0-9a-f]*:  fe 0d 14 1a     asr sp,pc,0x1a
++ *[0-9a-f]*:  fa 0b 14 08     asr r11,sp,0x8
++
++[0-9a-f]* <lsl3>:
++ *[0-9a-f]*:  fe 0f 15 00     lsl pc,pc,0x0
++ *[0-9a-f]*:  f8 0c 15 1f     lsl r12,r12,0x1f
++ *[0-9a-f]*:  ea 05 15 10     lsl r5,r5,0x10
++ *[0-9a-f]*:  e8 04 15 0f     lsl r4,r4,0xf
++ *[0-9a-f]*:  fc 0e 15 01     lsl lr,lr,0x1
++ *[0-9a-f]*:  f4 08 15 11     lsl r8,r10,0x11
++ *[0-9a-f]*:  fc 02 15 03     lsl r2,lr,0x3
++ *[0-9a-f]*:  f6 0e 15 0e     lsl lr,r11,0xe
++
++[0-9a-f]* <lsr3>:
++ *[0-9a-f]*:  fe 0f 16 00     lsr pc,pc,0x0
++ *[0-9a-f]*:  f8 0c 16 1f     lsr r12,r12,0x1f
++ *[0-9a-f]*:  ea 05 16 10     lsr r5,r5,0x10
++ *[0-9a-f]*:  e8 04 16 0f     lsr r4,r4,0xf
++ *[0-9a-f]*:  fc 0e 16 01     lsr lr,lr,0x1
++ *[0-9a-f]*:  e6 04 16 1f     lsr r4,r3,0x1f
++ *[0-9a-f]*:  f2 0f 16 0e     lsr pc,r9,0xe
++ *[0-9a-f]*:  e0 03 16 06     lsr r3,r0,0x6
++
++[0-9a-f]* <movc1>:
++ *[0-9a-f]*:  fe 0f 17 00     moveq pc,pc
++ *[0-9a-f]*:  f8 0c 17 f0     moval r12,r12
++ *[0-9a-f]*:  ea 05 17 80     movls r5,r5
++ *[0-9a-f]*:  e8 04 17 70     movpl r4,r4
++ *[0-9a-f]*:  fc 0e 17 10     movne lr,lr
++ *[0-9a-f]*:  f6 0f 17 10     movne pc,r11
++ *[0-9a-f]*:  e4 0a 17 60     movmi r10,r2
++ *[0-9a-f]*:  f8 08 17 80     movls r8,r12
++
++[0-9a-f]* <padd_h>:
++ *[0-9a-f]*:  fe 0f 20 0f     padd\.h pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 0c     padd\.h r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 05     padd\.h r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 04     padd\.h r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 0e     padd\.h lr,lr,lr
++ *[0-9a-f]*:  e4 07 20 08     padd\.h r8,r2,r7
++ *[0-9a-f]*:  e0 03 20 00     padd\.h r0,r0,r3
++ *[0-9a-f]*:  f6 06 20 0d     padd\.h sp,r11,r6
++
++[0-9a-f]* <psub_h>:
++ *[0-9a-f]*:  fe 0f 20 1f     psub\.h pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 1c     psub\.h r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 15     psub\.h r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 14     psub\.h r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 1e     psub\.h lr,lr,lr
++ *[0-9a-f]*:  ec 08 20 1e     psub\.h lr,r6,r8
++ *[0-9a-f]*:  e2 0d 20 10     psub\.h r0,r1,sp
++ *[0-9a-f]*:  fe 0d 20 1f     psub\.h pc,pc,sp
++
++[0-9a-f]* <paddx_h>:
++ *[0-9a-f]*:  fe 0f 20 2f     paddx\.h pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 2c     paddx\.h r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 25     paddx\.h r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 24     paddx\.h r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 2e     paddx\.h lr,lr,lr
++ *[0-9a-f]*:  fe 01 20 2f     paddx\.h pc,pc,r1
++ *[0-9a-f]*:  e8 05 20 2a     paddx\.h r10,r4,r5
++ *[0-9a-f]*:  fe 02 20 25     paddx\.h r5,pc,r2
++
++[0-9a-f]* <psubx_h>:
++ *[0-9a-f]*:  fe 0f 20 3f     psubx\.h pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 3c     psubx\.h r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 35     psubx\.h r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 34     psubx\.h r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 3e     psubx\.h lr,lr,lr
++ *[0-9a-f]*:  f8 05 20 35     psubx\.h r5,r12,r5
++ *[0-9a-f]*:  f0 03 20 33     psubx\.h r3,r8,r3
++ *[0-9a-f]*:  e4 03 20 35     psubx\.h r5,r2,r3
++
++[0-9a-f]* <padds_sh>:
++ *[0-9a-f]*:  fe 0f 20 4f     padds\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 4c     padds\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 45     padds\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 44     padds\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 4e     padds\.sh lr,lr,lr
++ *[0-9a-f]*:  fc 02 20 49     padds\.sh r9,lr,r2
++ *[0-9a-f]*:  f0 01 20 46     padds\.sh r6,r8,r1
++ *[0-9a-f]*:  e8 0a 20 46     padds\.sh r6,r4,r10
++
++[0-9a-f]* <psubs_sh>:
++ *[0-9a-f]*:  fe 0f 20 5f     psubs\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 5c     psubs\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 55     psubs\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 54     psubs\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 5e     psubs\.sh lr,lr,lr
++ *[0-9a-f]*:  fc 0b 20 56     psubs\.sh r6,lr,r11
++ *[0-9a-f]*:  f8 04 20 52     psubs\.sh r2,r12,r4
++ *[0-9a-f]*:  f2 00 20 50     psubs\.sh r0,r9,r0
++
++[0-9a-f]* <paddxs_sh>:
++ *[0-9a-f]*:  fe 0f 20 6f     paddxs\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 6c     paddxs\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 65     paddxs\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 64     paddxs\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 6e     paddxs\.sh lr,lr,lr
++ *[0-9a-f]*:  e6 09 20 60     paddxs\.sh r0,r3,r9
++ *[0-9a-f]*:  f4 0b 20 6f     paddxs\.sh pc,r10,r11
++ *[0-9a-f]*:  f4 0f 20 6f     paddxs\.sh pc,r10,pc
++
++[0-9a-f]* <psubxs_sh>:
++ *[0-9a-f]*:  fe 0f 20 7f     psubxs\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 7c     psubxs\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 75     psubxs\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 74     psubxs\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 7e     psubxs\.sh lr,lr,lr
++ *[0-9a-f]*:  e8 04 20 77     psubxs\.sh r7,r4,r4
++ *[0-9a-f]*:  f0 03 20 77     psubxs\.sh r7,r8,r3
++ *[0-9a-f]*:  ec 05 20 7f     psubxs\.sh pc,r6,r5
++
++[0-9a-f]* <padds_uh>:
++ *[0-9a-f]*:  fe 0f 20 8f     padds\.uh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 8c     padds\.uh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 85     padds\.uh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 84     padds\.uh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 8e     padds\.uh lr,lr,lr
++ *[0-9a-f]*:  f6 07 20 8c     padds\.uh r12,r11,r7
++ *[0-9a-f]*:  f0 0e 20 87     padds\.uh r7,r8,lr
++ *[0-9a-f]*:  f2 07 20 86     padds\.uh r6,r9,r7
++
++[0-9a-f]* <psubs_uh>:
++ *[0-9a-f]*:  fe 0f 20 9f     psubs\.uh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 9c     psubs\.uh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 95     psubs\.uh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 94     psubs\.uh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 9e     psubs\.uh lr,lr,lr
++ *[0-9a-f]*:  f4 06 20 9e     psubs\.uh lr,r10,r6
++ *[0-9a-f]*:  e4 0f 20 9d     psubs\.uh sp,r2,pc
++ *[0-9a-f]*:  f2 02 20 92     psubs\.uh r2,r9,r2
++
++[0-9a-f]* <paddxs_uh>:
++ *[0-9a-f]*:  fe 0f 20 af     paddxs\.uh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 ac     paddxs\.uh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 a5     paddxs\.uh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 a4     paddxs\.uh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 ae     paddxs\.uh lr,lr,lr
++ *[0-9a-f]*:  f2 05 20 a7     paddxs\.uh r7,r9,r5
++ *[0-9a-f]*:  e2 04 20 a9     paddxs\.uh r9,r1,r4
++ *[0-9a-f]*:  e4 03 20 a5     paddxs\.uh r5,r2,r3
++
++[0-9a-f]* <psubxs_uh>:
++ *[0-9a-f]*:  fe 0f 20 bf     psubxs\.uh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 bc     psubxs\.uh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 b5     psubxs\.uh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 b4     psubxs\.uh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 be     psubxs\.uh lr,lr,lr
++ *[0-9a-f]*:  ea 0d 20 bd     psubxs\.uh sp,r5,sp
++ *[0-9a-f]*:  ec 06 20 bd     psubxs\.uh sp,r6,r6
++ *[0-9a-f]*:  f6 08 20 b3     psubxs\.uh r3,r11,r8
++
++[0-9a-f]* <paddh_sh>:
++ *[0-9a-f]*:  fe 0f 20 cf     paddh\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 cc     paddh\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 c5     paddh\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 c4     paddh\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 ce     paddh\.sh lr,lr,lr
++ *[0-9a-f]*:  fa 03 20 cc     paddh\.sh r12,sp,r3
++ *[0-9a-f]*:  ea 03 20 cf     paddh\.sh pc,r5,r3
++ *[0-9a-f]*:  f0 0d 20 c8     paddh\.sh r8,r8,sp
++
++[0-9a-f]* <psubh_sh>:
++ *[0-9a-f]*:  fe 0f 20 df     psubh\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 dc     psubh\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 d5     psubh\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 d4     psubh\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 de     psubh\.sh lr,lr,lr
++ *[0-9a-f]*:  ea 08 20 d1     psubh\.sh r1,r5,r8
++ *[0-9a-f]*:  e6 06 20 d7     psubh\.sh r7,r3,r6
++ *[0-9a-f]*:  e6 03 20 d4     psubh\.sh r4,r3,r3
++
++[0-9a-f]* <paddxh_sh>:
++ *[0-9a-f]*:  fe 0f 20 ef     paddxh\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 ec     paddxh\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 e5     paddxh\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 e4     paddxh\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 ee     paddxh\.sh lr,lr,lr
++ *[0-9a-f]*:  e0 04 20 e6     paddxh\.sh r6,r0,r4
++ *[0-9a-f]*:  f0 09 20 e9     paddxh\.sh r9,r8,r9
++ *[0-9a-f]*:  e0 0d 20 e3     paddxh\.sh r3,r0,sp
++
++[0-9a-f]* <psubxh_sh>:
++ *[0-9a-f]*:  fe 0f 20 ff     psubxh\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 20 fc     psubxh\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 20 f5     psubxh\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 20 f4     psubxh\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 20 fe     psubxh\.sh lr,lr,lr
++ *[0-9a-f]*:  fe 0c 20 f4     psubxh\.sh r4,pc,r12
++ *[0-9a-f]*:  e8 06 20 f8     psubxh\.sh r8,r4,r6
++ *[0-9a-f]*:  f2 04 20 fc     psubxh\.sh r12,r9,r4
++
++[0-9a-f]* <paddsub_h>:
++ *[0-9a-f]*:  fe 0f 21 0f     paddsub\.h pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 21 3c     paddsub\.h r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 21 35     paddsub\.h r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 21 04     paddsub\.h r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 21 3e     paddsub\.h lr,lr:t,lr:t
++ *[0-9a-f]*:  e4 0e 21 25     paddsub\.h r5,r2:t,lr:b
++ *[0-9a-f]*:  e2 08 21 07     paddsub\.h r7,r1:b,r8:b
++ *[0-9a-f]*:  f4 05 21 36     paddsub\.h r6,r10:t,r5:t
++
++[0-9a-f]* <psubadd_h>:
++ *[0-9a-f]*:  fe 0f 21 4f     psubadd\.h pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 21 7c     psubadd\.h r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 21 75     psubadd\.h r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 21 44     psubadd\.h r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 21 7e     psubadd\.h lr,lr:t,lr:t
++ *[0-9a-f]*:  f6 08 21 79     psubadd\.h r9,r11:t,r8:t
++ *[0-9a-f]*:  ee 0e 21 7a     psubadd\.h r10,r7:t,lr:t
++ *[0-9a-f]*:  fe 0f 21 66     psubadd\.h r6,pc:t,pc:b
++
++[0-9a-f]* <paddsubs_sh>:
++ *[0-9a-f]*:  fe 0f 21 8f     paddsubs\.sh pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 21 bc     paddsubs\.sh r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 21 b5     paddsubs\.sh r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 21 84     paddsubs\.sh r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 21 be     paddsubs\.sh lr,lr:t,lr:t
++ *[0-9a-f]*:  fc 00 21 a0     paddsubs\.sh r0,lr:t,r0:b
++ *[0-9a-f]*:  e4 04 21 b9     paddsubs\.sh r9,r2:t,r4:t
++ *[0-9a-f]*:  f2 0d 21 bc     paddsubs\.sh r12,r9:t,sp:t
++
++[0-9a-f]* <psubadds_sh>:
++ *[0-9a-f]*:  fe 0f 21 cf     psubadds\.sh pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 21 fc     psubadds\.sh r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 21 f5     psubadds\.sh r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 21 c4     psubadds\.sh r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 21 fe     psubadds\.sh lr,lr:t,lr:t
++ *[0-9a-f]*:  fc 01 21 df     psubadds\.sh pc,lr:b,r1:t
++ *[0-9a-f]*:  e6 0c 21 cb     psubadds\.sh r11,r3:b,r12:b
++ *[0-9a-f]*:  e4 08 21 fa     psubadds\.sh r10,r2:t,r8:t
++
++[0-9a-f]* <paddsubs_uh>:
++ *[0-9a-f]*:  fe 0f 22 0f     paddsubs\.uh pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 22 3c     paddsubs\.uh r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 22 35     paddsubs\.uh r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 22 04     paddsubs\.uh r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 22 3e     paddsubs\.uh lr,lr:t,lr:t
++ *[0-9a-f]*:  e4 03 22 09     paddsubs\.uh r9,r2:b,r3:b
++ *[0-9a-f]*:  fa 07 22 1d     paddsubs\.uh sp,sp:b,r7:t
++ *[0-9a-f]*:  e0 0a 22 1e     paddsubs\.uh lr,r0:b,r10:t
++
++[0-9a-f]* <psubadds_uh>:
++ *[0-9a-f]*:  fe 0f 22 4f     psubadds\.uh pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 22 7c     psubadds\.uh r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 22 75     psubadds\.uh r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 22 44     psubadds\.uh r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 22 7e     psubadds\.uh lr,lr:t,lr:t
++ *[0-9a-f]*:  f2 0f 22 7c     psubadds\.uh r12,r9:t,pc:t
++ *[0-9a-f]*:  ec 08 22 48     psubadds\.uh r8,r6:b,r8:b
++ *[0-9a-f]*:  f0 04 22 48     psubadds\.uh r8,r8:b,r4:b
++
++[0-9a-f]* <paddsubh_sh>:
++ *[0-9a-f]*:  fe 0f 22 8f     paddsubh\.sh pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 22 bc     paddsubh\.sh r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 22 b5     paddsubh\.sh r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 22 84     paddsubh\.sh r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 22 be     paddsubh\.sh lr,lr:t,lr:t
++ *[0-9a-f]*:  f2 09 22 a8     paddsubh\.sh r8,r9:t,r9:b
++ *[0-9a-f]*:  fa 01 22 b0     paddsubh\.sh r0,sp:t,r1:t
++ *[0-9a-f]*:  e2 00 22 93     paddsubh\.sh r3,r1:b,r0:t
++
++[0-9a-f]* <psubaddh_sh>:
++ *[0-9a-f]*:  fe 0f 22 cf     psubaddh\.sh pc,pc:b,pc:b
++ *[0-9a-f]*:  f8 0c 22 fc     psubaddh\.sh r12,r12:t,r12:t
++ *[0-9a-f]*:  ea 05 22 f5     psubaddh\.sh r5,r5:t,r5:t
++ *[0-9a-f]*:  e8 04 22 c4     psubaddh\.sh r4,r4:b,r4:b
++ *[0-9a-f]*:  fc 0e 22 fe     psubaddh\.sh lr,lr:t,lr:t
++ *[0-9a-f]*:  e6 0a 22 e7     psubaddh\.sh r7,r3:t,r10:b
++ *[0-9a-f]*:  e4 01 22 f7     psubaddh\.sh r7,r2:t,r1:t
++ *[0-9a-f]*:  e6 06 22 cb     psubaddh\.sh r11,r3:b,r6:b
++
++[0-9a-f]* <padd_b>:
++ *[0-9a-f]*:  fe 0f 23 0f     padd\.b pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 0c     padd\.b r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 05     padd\.b r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 04     padd\.b r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 0e     padd\.b lr,lr,lr
++ *[0-9a-f]*:  ec 0f 23 02     padd\.b r2,r6,pc
++ *[0-9a-f]*:  f2 0c 23 08     padd\.b r8,r9,r12
++ *[0-9a-f]*:  f8 03 23 05     padd\.b r5,r12,r3
++
++[0-9a-f]* <psub_b>:
++ *[0-9a-f]*:  fe 0f 23 1f     psub\.b pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 1c     psub\.b r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 15     psub\.b r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 14     psub\.b r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 1e     psub\.b lr,lr,lr
++ *[0-9a-f]*:  f8 0f 23 10     psub\.b r0,r12,pc
++ *[0-9a-f]*:  fa 0a 23 17     psub\.b r7,sp,r10
++ *[0-9a-f]*:  fa 0c 23 15     psub\.b r5,sp,r12
++
++[0-9a-f]* <padds_sb>:
++ *[0-9a-f]*:  fe 0f 23 2f     padds\.sb pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 2c     padds\.sb r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 25     padds\.sb r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 24     padds\.sb r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 2e     padds\.sb lr,lr,lr
++ *[0-9a-f]*:  f6 04 23 2d     padds\.sb sp,r11,r4
++ *[0-9a-f]*:  f4 0b 23 2b     padds\.sb r11,r10,r11
++ *[0-9a-f]*:  f8 06 23 25     padds\.sb r5,r12,r6
++
++[0-9a-f]* <psubs_sb>:
++ *[0-9a-f]*:  fe 0f 23 3f     psubs\.sb pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 3c     psubs\.sb r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 35     psubs\.sb r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 34     psubs\.sb r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 3e     psubs\.sb lr,lr,lr
++ *[0-9a-f]*:  ec 08 23 37     psubs\.sb r7,r6,r8
++ *[0-9a-f]*:  f4 09 23 3c     psubs\.sb r12,r10,r9
++ *[0-9a-f]*:  f6 00 23 3f     psubs\.sb pc,r11,r0
++
++[0-9a-f]* <padds_ub>:
++ *[0-9a-f]*:  fe 0f 23 4f     padds\.ub pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 4c     padds\.ub r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 45     padds\.ub r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 44     padds\.ub r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 4e     padds\.ub lr,lr,lr
++ *[0-9a-f]*:  e4 0b 23 43     padds\.ub r3,r2,r11
++ *[0-9a-f]*:  f0 01 23 4a     padds\.ub r10,r8,r1
++ *[0-9a-f]*:  f0 0a 23 4b     padds\.ub r11,r8,r10
++
++[0-9a-f]* <psubs_ub>:
++ *[0-9a-f]*:  fe 0f 23 5f     psubs\.ub pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 5c     psubs\.ub r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 55     psubs\.ub r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 54     psubs\.ub r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 5e     psubs\.ub lr,lr,lr
++ *[0-9a-f]*:  e4 07 23 50     psubs\.ub r0,r2,r7
++ *[0-9a-f]*:  ea 03 23 5e     psubs\.ub lr,r5,r3
++ *[0-9a-f]*:  ee 09 23 56     psubs\.ub r6,r7,r9
++
++[0-9a-f]* <paddh_ub>:
++ *[0-9a-f]*:  fe 0f 23 6f     paddh\.ub pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 6c     paddh\.ub r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 65     paddh\.ub r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 64     paddh\.ub r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 6e     paddh\.ub lr,lr,lr
++ *[0-9a-f]*:  e2 00 23 6e     paddh\.ub lr,r1,r0
++ *[0-9a-f]*:  ee 07 23 62     paddh\.ub r2,r7,r7
++ *[0-9a-f]*:  e2 02 23 62     paddh\.ub r2,r1,r2
++
++[0-9a-f]* <psubh_ub>:
++ *[0-9a-f]*:  fe 0f 23 7f     psubh\.ub pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 7c     psubh\.ub r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 75     psubh\.ub r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 74     psubh\.ub r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 7e     psubh\.ub lr,lr,lr
++ *[0-9a-f]*:  e2 06 23 70     psubh\.ub r0,r1,r6
++ *[0-9a-f]*:  fc 0a 23 74     psubh\.ub r4,lr,r10
++ *[0-9a-f]*:  f0 01 23 79     psubh\.ub r9,r8,r1
++
++[0-9a-f]* <pmax_ub>:
++ *[0-9a-f]*:  fe 0f 23 8f     pmax\.ub pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 8c     pmax\.ub r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 85     pmax\.ub r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 84     pmax\.ub r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 8e     pmax\.ub lr,lr,lr
++ *[0-9a-f]*:  e4 0b 23 8f     pmax\.ub pc,r2,r11
++ *[0-9a-f]*:  e2 01 23 8c     pmax\.ub r12,r1,r1
++ *[0-9a-f]*:  e4 00 23 85     pmax\.ub r5,r2,r0
++
++[0-9a-f]* <pmax_sh>:
++ *[0-9a-f]*:  fe 0f 23 9f     pmax\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 9c     pmax\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 95     pmax\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 94     pmax\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 9e     pmax\.sh lr,lr,lr
++ *[0-9a-f]*:  ec 0c 23 9e     pmax\.sh lr,r6,r12
++ *[0-9a-f]*:  fe 05 23 92     pmax\.sh r2,pc,r5
++ *[0-9a-f]*:  e4 07 23 9f     pmax\.sh pc,r2,r7
++
++[0-9a-f]* <pmin_ub>:
++ *[0-9a-f]*:  fe 0f 23 af     pmin\.ub pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 ac     pmin\.ub r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 a5     pmin\.ub r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 a4     pmin\.ub r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 ae     pmin\.ub lr,lr,lr
++ *[0-9a-f]*:  e2 05 23 a8     pmin\.ub r8,r1,r5
++ *[0-9a-f]*:  f0 03 23 a1     pmin\.ub r1,r8,r3
++ *[0-9a-f]*:  e4 07 23 a0     pmin\.ub r0,r2,r7
++
++[0-9a-f]* <pmin_sh>:
++ *[0-9a-f]*:  fe 0f 23 bf     pmin\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 bc     pmin\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 b5     pmin\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 b4     pmin\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 be     pmin\.sh lr,lr,lr
++ *[0-9a-f]*:  e8 0a 23 b8     pmin\.sh r8,r4,r10
++ *[0-9a-f]*:  f4 0c 23 be     pmin\.sh lr,r10,r12
++ *[0-9a-f]*:  ec 02 23 b2     pmin\.sh r2,r6,r2
++
++[0-9a-f]* <pavg_ub>:
++ *[0-9a-f]*:  fe 0f 23 cf     pavg\.ub pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 cc     pavg\.ub r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 c5     pavg\.ub r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 c4     pavg\.ub r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 ce     pavg\.ub lr,lr,lr
++ *[0-9a-f]*:  e2 06 23 c0     pavg\.ub r0,r1,r6
++ *[0-9a-f]*:  e6 06 23 c8     pavg\.ub r8,r3,r6
++ *[0-9a-f]*:  f8 0a 23 cf     pavg\.ub pc,r12,r10
++
++[0-9a-f]* <pavg_sh>:
++ *[0-9a-f]*:  fe 0f 23 df     pavg\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 23 dc     pavg\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 23 d5     pavg\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 23 d4     pavg\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 23 de     pavg\.sh lr,lr,lr
++ *[0-9a-f]*:  fe 0d 23 d9     pavg\.sh r9,pc,sp
++ *[0-9a-f]*:  fa 03 23 df     pavg\.sh pc,sp,r3
++ *[0-9a-f]*:  e2 09 23 d6     pavg\.sh r6,r1,r9
++
++[0-9a-f]* <pabs_sb>:
++ *[0-9a-f]*:  e0 0f 23 ef     pabs\.sb pc,pc
++ *[0-9a-f]*:  e0 0c 23 ec     pabs\.sb r12,r12
++ *[0-9a-f]*:  e0 05 23 e5     pabs\.sb r5,r5
++ *[0-9a-f]*:  e0 04 23 e4     pabs\.sb r4,r4
++ *[0-9a-f]*:  e0 0e 23 ee     pabs\.sb lr,lr
++ *[0-9a-f]*:  e0 06 23 eb     pabs\.sb r11,r6
++ *[0-9a-f]*:  e0 09 23 ee     pabs\.sb lr,r9
++ *[0-9a-f]*:  e0 07 23 ed     pabs\.sb sp,r7
++
++[0-9a-f]* <pabs_sh>:
++ *[0-9a-f]*:  e0 0f 23 ff     pabs\.sh pc,pc
++ *[0-9a-f]*:  e0 0c 23 fc     pabs\.sh r12,r12
++ *[0-9a-f]*:  e0 05 23 f5     pabs\.sh r5,r5
++ *[0-9a-f]*:  e0 04 23 f4     pabs\.sh r4,r4
++ *[0-9a-f]*:  e0 0e 23 fe     pabs\.sh lr,lr
++ *[0-9a-f]*:  e0 03 23 ff     pabs\.sh pc,r3
++ *[0-9a-f]*:  e0 07 23 f5     pabs\.sh r5,r7
++ *[0-9a-f]*:  e0 00 23 f4     pabs\.sh r4,r0
++
++[0-9a-f]* <psad>:
++ *[0-9a-f]*:  fe 0f 24 0f     psad pc,pc,pc
++ *[0-9a-f]*:  f8 0c 24 0c     psad r12,r12,r12
++ *[0-9a-f]*:  ea 05 24 05     psad r5,r5,r5
++ *[0-9a-f]*:  e8 04 24 04     psad r4,r4,r4
++ *[0-9a-f]*:  fc 0e 24 0e     psad lr,lr,lr
++ *[0-9a-f]*:  f6 0b 24 09     psad r9,r11,r11
++ *[0-9a-f]*:  e8 0d 24 0e     psad lr,r4,sp
++ *[0-9a-f]*:  e8 05 24 0e     psad lr,r4,r5
++
++[0-9a-f]* <pasr_b>:
++ *[0-9a-f]*:  fe 00 24 1f     pasr\.b pc,pc,0x0
++ *[0-9a-f]*:  f8 07 24 1c     pasr\.b r12,r12,0x7
++ *[0-9a-f]*:  ea 04 24 15     pasr\.b r5,r5,0x4
++ *[0-9a-f]*:  e8 03 24 14     pasr\.b r4,r4,0x3
++ *[0-9a-f]*:  fc 01 24 1e     pasr\.b lr,lr,0x1
++ *[0-9a-f]*:  ee 01 24 1f     pasr\.b pc,r7,0x1
++ *[0-9a-f]*:  fc 06 24 1d     pasr\.b sp,lr,0x6
++ *[0-9a-f]*:  e6 02 24 1d     pasr\.b sp,r3,0x2
++
++[0-9a-f]* <plsl_b>:
++ *[0-9a-f]*:  fe 00 24 2f     plsl\.b pc,pc,0x0
++ *[0-9a-f]*:  f8 07 24 2c     plsl\.b r12,r12,0x7
++ *[0-9a-f]*:  ea 04 24 25     plsl\.b r5,r5,0x4
++ *[0-9a-f]*:  e8 03 24 24     plsl\.b r4,r4,0x3
++ *[0-9a-f]*:  fc 01 24 2e     plsl\.b lr,lr,0x1
++ *[0-9a-f]*:  f6 04 24 22     plsl\.b r2,r11,0x4
++ *[0-9a-f]*:  ea 07 24 28     plsl\.b r8,r5,0x7
++ *[0-9a-f]*:  e0 02 24 2f     plsl\.b pc,r0,0x2
++
++[0-9a-f]* <plsr_b>:
++ *[0-9a-f]*:  fe 00 24 3f     plsr\.b pc,pc,0x0
++ *[0-9a-f]*:  f8 07 24 3c     plsr\.b r12,r12,0x7
++ *[0-9a-f]*:  ea 04 24 35     plsr\.b r5,r5,0x4
++ *[0-9a-f]*:  e8 03 24 34     plsr\.b r4,r4,0x3
++ *[0-9a-f]*:  fc 01 24 3e     plsr\.b lr,lr,0x1
++ *[0-9a-f]*:  e2 02 24 3c     plsr\.b r12,r1,0x2
++ *[0-9a-f]*:  fe 07 24 36     plsr\.b r6,pc,0x7
++ *[0-9a-f]*:  f6 02 24 3c     plsr\.b r12,r11,0x2
++
++[0-9a-f]* <pasr_h>:
++ *[0-9a-f]*:  fe 00 24 4f     pasr\.h pc,pc,0x0
++ *[0-9a-f]*:  f8 0f 24 4c     pasr\.h r12,r12,0xf
++ *[0-9a-f]*:  ea 08 24 45     pasr\.h r5,r5,0x8
++ *[0-9a-f]*:  e8 07 24 44     pasr\.h r4,r4,0x7
++ *[0-9a-f]*:  fc 01 24 4e     pasr\.h lr,lr,0x1
++ *[0-9a-f]*:  f6 0a 24 40     pasr\.h r0,r11,0xa
++ *[0-9a-f]*:  ec 08 24 44     pasr\.h r4,r6,0x8
++ *[0-9a-f]*:  e4 04 24 46     pasr\.h r6,r2,0x4
++
++[0-9a-f]* <plsl_h>:
++ *[0-9a-f]*:  fe 00 24 5f     plsl\.h pc,pc,0x0
++ *[0-9a-f]*:  f8 0f 24 5c     plsl\.h r12,r12,0xf
++ *[0-9a-f]*:  ea 08 24 55     plsl\.h r5,r5,0x8
++ *[0-9a-f]*:  e8 07 24 54     plsl\.h r4,r4,0x7
++ *[0-9a-f]*:  fc 01 24 5e     plsl\.h lr,lr,0x1
++ *[0-9a-f]*:  f4 09 24 55     plsl\.h r5,r10,0x9
++ *[0-9a-f]*:  fc 08 24 5d     plsl\.h sp,lr,0x8
++ *[0-9a-f]*:  fc 07 24 50     plsl\.h r0,lr,0x7
++
++[0-9a-f]* <plsr_h>:
++ *[0-9a-f]*:  fe 00 24 6f     plsr\.h pc,pc,0x0
++ *[0-9a-f]*:  f8 0f 24 6c     plsr\.h r12,r12,0xf
++ *[0-9a-f]*:  ea 08 24 65     plsr\.h r5,r5,0x8
++ *[0-9a-f]*:  e8 07 24 64     plsr\.h r4,r4,0x7
++ *[0-9a-f]*:  fc 01 24 6e     plsr\.h lr,lr,0x1
++ *[0-9a-f]*:  e0 0f 24 6b     plsr\.h r11,r0,0xf
++ *[0-9a-f]*:  e6 03 24 6e     plsr\.h lr,r3,0x3
++ *[0-9a-f]*:  fc 0a 24 68     plsr\.h r8,lr,0xa
++
++[0-9a-f]* <packw_sh>:
++ *[0-9a-f]*:  fe 0f 24 7f     packw\.sh pc,pc,pc
++ *[0-9a-f]*:  f8 0c 24 7c     packw\.sh r12,r12,r12
++ *[0-9a-f]*:  ea 05 24 75     packw\.sh r5,r5,r5
++ *[0-9a-f]*:  e8 04 24 74     packw\.sh r4,r4,r4
++ *[0-9a-f]*:  fc 0e 24 7e     packw\.sh lr,lr,lr
++ *[0-9a-f]*:  f6 0a 24 7d     packw\.sh sp,r11,r10
++ *[0-9a-f]*:  e4 0c 24 78     packw\.sh r8,r2,r12
++ *[0-9a-f]*:  e2 05 24 78     packw\.sh r8,r1,r5
++
++[0-9a-f]* <punpckub_h>:
++ *[0-9a-f]*:  fe 00 24 8f     punpckub\.h pc,pc:b
++ *[0-9a-f]*:  f8 00 24 9c     punpckub\.h r12,r12:t
++ *[0-9a-f]*:  ea 00 24 95     punpckub\.h r5,r5:t
++ *[0-9a-f]*:  e8 00 24 84     punpckub\.h r4,r4:b
++ *[0-9a-f]*:  fc 00 24 9e     punpckub\.h lr,lr:t
++ *[0-9a-f]*:  e2 00 24 96     punpckub\.h r6,r1:t
++ *[0-9a-f]*:  ea 00 24 8e     punpckub\.h lr,r5:b
++ *[0-9a-f]*:  e4 00 24 9e     punpckub\.h lr,r2:t
++
++[0-9a-f]* <punpcksb_h>:
++ *[0-9a-f]*:  fe 00 24 af     punpcksb\.h pc,pc:b
++ *[0-9a-f]*:  f8 00 24 bc     punpcksb\.h r12,r12:t
++ *[0-9a-f]*:  ea 00 24 b5     punpcksb\.h r5,r5:t
++ *[0-9a-f]*:  e8 00 24 a4     punpcksb\.h r4,r4:b
++ *[0-9a-f]*:  fc 00 24 be     punpcksb\.h lr,lr:t
++ *[0-9a-f]*:  ee 00 24 b4     punpcksb\.h r4,r7:t
++ *[0-9a-f]*:  fc 00 24 a6     punpcksb\.h r6,lr:b
++ *[0-9a-f]*:  f8 00 24 bc     punpcksb\.h r12,r12:t
++
++[0-9a-f]* <packsh_ub>:
++ *[0-9a-f]*:  fe 0f 24 cf     packsh\.ub pc,pc,pc
++ *[0-9a-f]*:  f8 0c 24 cc     packsh\.ub r12,r12,r12
++ *[0-9a-f]*:  ea 05 24 c5     packsh\.ub r5,r5,r5
++ *[0-9a-f]*:  e8 04 24 c4     packsh\.ub r4,r4,r4
++ *[0-9a-f]*:  fc 0e 24 ce     packsh\.ub lr,lr,lr
++ *[0-9a-f]*:  ec 03 24 c3     packsh\.ub r3,r6,r3
++ *[0-9a-f]*:  e0 03 24 c8     packsh\.ub r8,r0,r3
++ *[0-9a-f]*:  e6 0e 24 c9     packsh\.ub r9,r3,lr
++
++[0-9a-f]* <packsh_sb>:
++ *[0-9a-f]*:  fe 0f 24 df     packsh\.sb pc,pc,pc
++ *[0-9a-f]*:  f8 0c 24 dc     packsh\.sb r12,r12,r12
++ *[0-9a-f]*:  ea 05 24 d5     packsh\.sb r5,r5,r5
++ *[0-9a-f]*:  e8 04 24 d4     packsh\.sb r4,r4,r4
++ *[0-9a-f]*:  fc 0e 24 de     packsh\.sb lr,lr,lr
++ *[0-9a-f]*:  f0 01 24 d6     packsh\.sb r6,r8,r1
++ *[0-9a-f]*:  f2 08 24 de     packsh\.sb lr,r9,r8
++ *[0-9a-f]*:  ec 06 24 dd     packsh\.sb sp,r6,r6
++
++[0-9a-f]* <andl>:
++ *[0-9a-f]*:  e0 1f 00 00     andl pc,0x0
++ *[0-9a-f]*:  e0 1c ff ff     andl r12,0xffff
++ *[0-9a-f]*:  e0 15 80 00     andl r5,0x8000
++ *[0-9a-f]*:  e0 14 7f ff     andl r4,0x7fff
++ *[0-9a-f]*:  e0 1e 00 01     andl lr,0x1
++ *[0-9a-f]*:  e0 1f 5a 58     andl pc,0x5a58
++ *[0-9a-f]*:  e0 18 b8 9e     andl r8,0xb89e
++ *[0-9a-f]*:  e0 17 35 97     andl r7,0x3597
++
++[0-9a-f]* <andl_coh>:
++ *[0-9a-f]*:  e2 1f 00 00     andl pc,0x0,COH
++ *[0-9a-f]*:  e2 1c ff ff     andl r12,0xffff,COH
++ *[0-9a-f]*:  e2 15 80 00     andl r5,0x8000,COH
++ *[0-9a-f]*:  e2 14 7f ff     andl r4,0x7fff,COH
++ *[0-9a-f]*:  e2 1e 00 01     andl lr,0x1,COH
++ *[0-9a-f]*:  e2 16 58 e1     andl r6,0x58e1,COH
++ *[0-9a-f]*:  e2 10 9e cd     andl r0,0x9ecd,COH
++ *[0-9a-f]*:  e2 14 bd c4     andl r4,0xbdc4,COH
++
++[0-9a-f]* <andh>:
++ *[0-9a-f]*:  e4 1f 00 00     andh pc,0x0
++ *[0-9a-f]*:  e4 1c ff ff     andh r12,0xffff
++ *[0-9a-f]*:  e4 15 80 00     andh r5,0x8000
++ *[0-9a-f]*:  e4 14 7f ff     andh r4,0x7fff
++ *[0-9a-f]*:  e4 1e 00 01     andh lr,0x1
++ *[0-9a-f]*:  e4 1c cc 58     andh r12,0xcc58
++ *[0-9a-f]*:  e4 13 21 e3     andh r3,0x21e3
++ *[0-9a-f]*:  e4 12 a7 eb     andh r2,0xa7eb
++
++[0-9a-f]* <andh_coh>:
++ *[0-9a-f]*:  e6 1f 00 00     andh pc,0x0,COH
++ *[0-9a-f]*:  e6 1c ff ff     andh r12,0xffff,COH
++ *[0-9a-f]*:  e6 15 80 00     andh r5,0x8000,COH
++ *[0-9a-f]*:  e6 14 7f ff     andh r4,0x7fff,COH
++ *[0-9a-f]*:  e6 1e 00 01     andh lr,0x1,COH
++ *[0-9a-f]*:  e6 1b 86 0d     andh r11,0x860d,COH
++ *[0-9a-f]*:  e6 18 ce f6     andh r8,0xcef6,COH
++ *[0-9a-f]*:  e6 1a 5c 83     andh r10,0x5c83,COH
++
++[0-9a-f]* <orl>:
++ *[0-9a-f]*:  e8 1f 00 00     orl pc,0x0
++ *[0-9a-f]*:  e8 1c ff ff     orl r12,0xffff
++ *[0-9a-f]*:  e8 15 80 00     orl r5,0x8000
++ *[0-9a-f]*:  e8 14 7f ff     orl r4,0x7fff
++ *[0-9a-f]*:  e8 1e 00 01     orl lr,0x1
++ *[0-9a-f]*:  e8 1d 41 7e     orl sp,0x417e
++ *[0-9a-f]*:  e8 10 52 bd     orl r0,0x52bd
++ *[0-9a-f]*:  e8 1f ac 47     orl pc,0xac47
++
++[0-9a-f]* <orh>:
++ *[0-9a-f]*:  ea 1f 00 00     orh pc,0x0
++ *[0-9a-f]*:  ea 1c ff ff     orh r12,0xffff
++ *[0-9a-f]*:  ea 15 80 00     orh r5,0x8000
++ *[0-9a-f]*:  ea 14 7f ff     orh r4,0x7fff
++ *[0-9a-f]*:  ea 1e 00 01     orh lr,0x1
++ *[0-9a-f]*:  ea 18 6e 7d     orh r8,0x6e7d
++ *[0-9a-f]*:  ea 1c 77 1c     orh r12,0x771c
++ *[0-9a-f]*:  ea 11 ea 1a     orh r1,0xea1a
++
++[0-9a-f]* <eorl>:
++ *[0-9a-f]*:  ec 1f 00 00     eorl pc,0x0
++ *[0-9a-f]*:  ec 1c ff ff     eorl r12,0xffff
++ *[0-9a-f]*:  ec 15 80 00     eorl r5,0x8000
++ *[0-9a-f]*:  ec 14 7f ff     eorl r4,0x7fff
++ *[0-9a-f]*:  ec 1e 00 01     eorl lr,0x1
++ *[0-9a-f]*:  ec 14 c7 b9     eorl r4,0xc7b9
++ *[0-9a-f]*:  ec 16 fb dd     eorl r6,0xfbdd
++ *[0-9a-f]*:  ec 11 51 b1     eorl r1,0x51b1
++
++[0-9a-f]* <eorh>:
++ *[0-9a-f]*:  ee 1f 00 00     eorh pc,0x0
++ *[0-9a-f]*:  ee 1c ff ff     eorh r12,0xffff
++ *[0-9a-f]*:  ee 15 80 00     eorh r5,0x8000
++ *[0-9a-f]*:  ee 14 7f ff     eorh r4,0x7fff
++ *[0-9a-f]*:  ee 1e 00 01     eorh lr,0x1
++ *[0-9a-f]*:  ee 10 2d d4     eorh r0,0x2dd4
++ *[0-9a-f]*:  ee 1a 94 b5     eorh r10,0x94b5
++ *[0-9a-f]*:  ee 19 df 2a     eorh r9,0xdf2a
++
++[0-9a-f]* <mcall>:
++ *[0-9a-f]*:  f0 1f 00 00     mcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  f0 1c ff ff     mcall r12\[-4\]
++ *[0-9a-f]*:  f0 15 80 00     mcall r5\[-131072\]
++ *[0-9a-f]*:  f0 14 7f ff     mcall r4\[131068\]
++ *[0-9a-f]*:  f0 1e 00 01     mcall lr\[4\]
++ *[0-9a-f]*:  f0 1d 3b bf     mcall sp\[61180\]
++ *[0-9a-f]*:  f0 14 dd d2     mcall r4\[-35000\]
++ *[0-9a-f]*:  f0 10 09 b1     mcall r0\[9924\]
++
++[0-9a-f]* <pref>:
++ *[0-9a-f]*:  f2 1f 00 00     pref pc\[0\]
++ *[0-9a-f]*:  f2 1c ff ff     pref r12\[-1\]
++ *[0-9a-f]*:  f2 15 80 00     pref r5\[-32768\]
++ *[0-9a-f]*:  f2 14 7f ff     pref r4\[32767\]
++ *[0-9a-f]*:  f2 1e 00 01     pref lr\[1\]
++ *[0-9a-f]*:  f2 17 1e 44     pref r7\[7748\]
++ *[0-9a-f]*:  f2 17 e1 ed     pref r7\[-7699\]
++ *[0-9a-f]*:  f2 12 9a dc     pref r2\[-25892\]
++
++[0-9a-f]* <cache>:
++ *[0-9a-f]*:  f4 1f 00 00     cache pc\[0\],0x0
++ *[0-9a-f]*:  f4 1c ff ff     cache r12\[-1\],0x1f
++ *[0-9a-f]*:  f4 15 84 00     cache r5\[-1024\],0x10
++ *[0-9a-f]*:  f4 14 7b ff     cache r4\[1023\],0xf
++ *[0-9a-f]*:  f4 1e 08 01     cache lr\[1\],0x1
++ *[0-9a-f]*:  f4 13 8c 3c     cache r3\[-964\],0x11
++ *[0-9a-f]*:  f4 14 b6 89     cache r4\[-375\],0x16
++ *[0-9a-f]*:  f4 13 8c 88     cache r3\[-888\],0x11
++
++[0-9a-f]* <sub4>:
++ *[0-9a-f]*:  20 0f           sub pc,0
++ *[0-9a-f]*:  2f fc           sub r12,-1
++ *[0-9a-f]*:  f0 25 00 00     sub r5,-1048576
++ *[0-9a-f]*:  ee 34 ff ff     sub r4,1048575
++ *[0-9a-f]*:  20 1e           sub lr,1
++ *[0-9a-f]*:  f6 22 8d 6c     sub r2,-619156
++ *[0-9a-f]*:  e6 3e 0a cd     sub lr,461517
++ *[0-9a-f]*:  fc 38 2d 25     sub r8,-185051
++
++[0-9a-f]* <cp3>:
++ *[0-9a-f]*:  58 0f           cp.w pc,0
++ *[0-9a-f]*:  5b fc           cp.w r12,-1
++ *[0-9a-f]*:  f0 45 00 00     cp.w r5,-1048576
++ *[0-9a-f]*:  ee 54 ff ff     cp.w r4,1048575
++ *[0-9a-f]*:  58 1e           cp.w lr,1
++ *[0-9a-f]*:  e0 51 e4 ae     cp.w r1,124078
++ *[0-9a-f]*:  fa 40 37 e3     cp.w r0,-378909
++ *[0-9a-f]*:  fc 44 4a 14     cp.w r4,-243180
++
++[0-9a-f]* <mov2>:
++ *[0-9a-f]*:  30 0f           mov pc,0
++ *[0-9a-f]*:  3f fc           mov r12,-1
++ *[0-9a-f]*:  f0 65 00 00     mov r5,-1048576
++ *[0-9a-f]*:  ee 74 ff ff     mov r4,1048575
++ *[0-9a-f]*:  30 1e           mov lr,1
++ *[0-9a-f]*:  fa 75 29 a3     mov r5,-317021
++ *[0-9a-f]*:  f4 6d 91 94     mov sp,-749164
++ *[0-9a-f]*:  ee 65 58 93     mov r5,940179
++
++[0-9a-f]* <brc2>:
++ *[0-9a-f]*:  c0 00           breq [0-9a-f]* <.*>
++ *[0-9a-f]*:  fe 9f ff ff     bral [0-9a-f]* <.*>
++ *[0-9a-f]*:  f0 88 00 00     brls [0-9a-f]* <.*>
++ *[0-9a-f]*:  ee 97 ff ff     brpl [0-9a-f]* <.*>
++ *[0-9a-f]*:  c0 11           brne [0-9a-f]* <.*>
++ *[0-9a-f]*:  f2 8b 4a 4d     brhi [0-9a-f]* <.*>
++ *[0-9a-f]*:  ea 8e 14 cc     brqs [0-9a-f]* <.*>
++ *[0-9a-f]*:  fa 98 98 33     brls [0-9a-f]* <.*>
++
++[0-9a-f]* <rcall2>:
++ *[0-9a-f]*:  c0 0c           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  cf ff           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  f0 a0 00 00     rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  ee b0 ff ff     rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  c0 1c           rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  e2 b0 ca 5a     rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  e8 a0 47 52     rcall [0-9a-f]* <.*>
++ *[0-9a-f]*:  fe b0 fd ef     rcall [0-9a-f]* <.*>
++
++[0-9a-f]* <sub5>:
++ *[0-9a-f]*:  fe cf 00 00     sub pc,pc,0
++ *[0-9a-f]*:  f8 cc ff ff     sub r12,r12,-1
++ *[0-9a-f]*:  ea c5 80 00     sub r5,r5,-32768
++ *[0-9a-f]*:  e8 c4 7f ff     sub r4,r4,32767
++ *[0-9a-f]*:  fc ce 00 01     sub lr,lr,1
++ *[0-9a-f]*:  fe cf ce 38     sub pc,pc,-12744
++ *[0-9a-f]*:  ee c7 95 1b     sub r7,r7,-27365
++ *[0-9a-f]*:  f2 c2 bc 32     sub r2,r9,-17358
++
++[0-9a-f]* <satsub_w2>:
++ *[0-9a-f]*:  fe df 00 00     satsub\.w pc,pc,0
++ *[0-9a-f]*:  f8 dc ff ff     satsub\.w r12,r12,-1
++ *[0-9a-f]*:  ea d5 80 00     satsub\.w r5,r5,-32768
++ *[0-9a-f]*:  e8 d4 7f ff     satsub\.w r4,r4,32767
++ *[0-9a-f]*:  fc de 00 01     satsub\.w lr,lr,1
++ *[0-9a-f]*:  fc d2 f8 29     satsub\.w r2,lr,-2007
++ *[0-9a-f]*:  f8 d7 fc f0     satsub\.w r7,r12,-784
++ *[0-9a-f]*:  ee d4 5a 8c     satsub\.w r4,r7,23180
++
++[0-9a-f]* <ld_d4>:
++ *[0-9a-f]*:  fe e0 00 00     ld\.d r0,pc\[0\]
++ *[0-9a-f]*:  f8 ee ff ff     ld\.d lr,r12\[-1\]
++ *[0-9a-f]*:  ea e8 80 00     ld\.d r8,r5\[-32768\]
++ *[0-9a-f]*:  e8 e6 7f ff     ld\.d r6,r4\[32767\]
++ *[0-9a-f]*:  fc e2 00 01     ld\.d r2,lr\[1\]
++ *[0-9a-f]*:  f6 ee 39 c0     ld\.d lr,r11\[14784\]
++ *[0-9a-f]*:  f2 e6 b6 27     ld\.d r6,r9\[-18905\]
++ *[0-9a-f]*:  e6 e2 e7 2d     ld\.d r2,r3\[-6355\]
++
++[0-9a-f]* <ld_w4>:
++ *[0-9a-f]*:  7e 0f           ld\.w pc,pc\[0x0\]
++ *[0-9a-f]*:  f8 fc ff ff     ld\.w r12,r12\[-1\]
++ *[0-9a-f]*:  ea f5 80 00     ld\.w r5,r5\[-32768\]
++ *[0-9a-f]*:  e8 f4 7f ff     ld\.w r4,r4\[32767\]
++ *[0-9a-f]*:  fc fe 00 01     ld\.w lr,lr\[1\]
++ *[0-9a-f]*:  f8 f0 a9 8b     ld\.w r0,r12\[-22133\]
++ *[0-9a-f]*:  fe fd af d7     ld\.w sp,pc\[-20521\]
++ *[0-9a-f]*:  d7 03           nop
++
++[0-9a-f]* <ld_sh4>:
++ *[0-9a-f]*:  9e 0f           ld\.sh pc,pc\[0x0\]
++ *[0-9a-f]*:  f9 0c ff ff     ld\.sh r12,r12\[-1\]
++ *[0-9a-f]*:  eb 05 80 00     ld\.sh r5,r5\[-32768\]
++ *[0-9a-f]*:  e9 04 7f ff     ld\.sh r4,r4\[32767\]
++ *[0-9a-f]*:  fd 0e 00 01     ld\.sh lr,lr\[1\]
++ *[0-9a-f]*:  f5 06 78 d2     ld\.sh r6,r10\[30930\]
++ *[0-9a-f]*:  f5 06 55 d5     ld\.sh r6,r10\[21973\]
++ *[0-9a-f]*:  d7 03           nop
++
++[0-9a-f]* <ld_uh4>:
++ *[0-9a-f]*:  9e 8f           ld\.uh pc,pc\[0x0\]
++ *[0-9a-f]*:  f9 1c ff ff     ld\.uh r12,r12\[-1\]
++ *[0-9a-f]*:  eb 15 80 00     ld\.uh r5,r5\[-32768\]
++ *[0-9a-f]*:  e9 14 7f ff     ld\.uh r4,r4\[32767\]
++ *[0-9a-f]*:  fd 1e 00 01     ld\.uh lr,lr\[1\]
++ *[0-9a-f]*:  f3 11 cb d6     ld\.uh r1,r9\[-13354\]
++ *[0-9a-f]*:  f7 1e 53 59     ld\.uh lr,r11\[21337\]
++ *[0-9a-f]*:  d7 03           nop
++
++[0-9a-f]* <ld_sb1>:
++ *[0-9a-f]*:  ff 2f 00 00     ld\.sb pc,pc\[0\]
++ *[0-9a-f]*:  f9 2c ff ff     ld\.sb r12,r12\[-1\]
++ *[0-9a-f]*:  eb 25 80 00     ld\.sb r5,r5\[-32768\]
++ *[0-9a-f]*:  e9 24 7f ff     ld\.sb r4,r4\[32767\]
++ *[0-9a-f]*:  fd 2e 00 01     ld\.sb lr,lr\[1\]
++ *[0-9a-f]*:  fb 27 90 09     ld\.sb r7,sp\[-28663\]
++ *[0-9a-f]*:  e3 22 e9 09     ld\.sb r2,r1\[-5879\]
++ *[0-9a-f]*:  e7 2c 49 2e     ld\.sb r12,r3\[18734\]
++
++[0-9a-f]* <ld_ub4>:
++ *[0-9a-f]*:  1f 8f           ld\.ub pc,pc\[0x0\]
++ *[0-9a-f]*:  f9 3c ff ff     ld\.ub r12,r12\[-1\]
++ *[0-9a-f]*:  eb 35 80 00     ld\.ub r5,r5\[-32768\]
++ *[0-9a-f]*:  e9 34 7f ff     ld\.ub r4,r4\[32767\]
++ *[0-9a-f]*:  1d 9e           ld\.ub lr,lr\[0x1\]
++ *[0-9a-f]*:  e9 3f 20 55     ld\.ub pc,r4\[8277\]
++ *[0-9a-f]*:  f9 35 4a e4     ld\.ub r5,r12\[19172\]
++ *[0-9a-f]*:  fd 3a 66 eb     ld\.ub r10,lr\[26347\]
++
++[0-9a-f]* <st_d4>:
++ *[0-9a-f]*:  fe e1 00 00     st\.d pc\[0\],r0
++ *[0-9a-f]*:  f8 ef ff ff     st\.d r12\[-1\],lr
++ *[0-9a-f]*:  ea e9 80 00     st\.d r5\[-32768\],r8
++ *[0-9a-f]*:  e8 e7 7f ff     st\.d r4\[32767\],r6
++ *[0-9a-f]*:  fc e3 00 01     st\.d lr\[1\],r2
++ *[0-9a-f]*:  ea eb 33 90     st\.d r5\[13200\],r10
++ *[0-9a-f]*:  ea eb 24 88     st\.d r5\[9352\],r10
++ *[0-9a-f]*:  ea e5 7e 75     st\.d r5\[32373\],r4
++
++[0-9a-f]* <st_w4>:
++ *[0-9a-f]*:  9f 0f           st\.w pc\[0x0\],pc
++ *[0-9a-f]*:  f9 4c ff ff     st\.w r12\[-1\],r12
++ *[0-9a-f]*:  eb 45 80 00     st\.w r5\[-32768\],r5
++ *[0-9a-f]*:  e9 44 7f ff     st\.w r4\[32767\],r4
++ *[0-9a-f]*:  fd 4e 00 01     st\.w lr\[1\],lr
++ *[0-9a-f]*:  fb 47 17 f8     st\.w sp\[6136\],r7
++ *[0-9a-f]*:  ed 4c 69 cf     st\.w r6\[27087\],r12
++ *[0-9a-f]*:  d7 03           nop
++
++[0-9a-f]* <st_h4>:
++ *[0-9a-f]*:  be 0f           st\.h pc\[0x0\],pc
++ *[0-9a-f]*:  f9 5c ff ff     st\.h r12\[-1\],r12
++ *[0-9a-f]*:  eb 55 80 00     st\.h r5\[-32768\],r5
++ *[0-9a-f]*:  e9 54 7f ff     st\.h r4\[32767\],r4
++ *[0-9a-f]*:  fd 5e 00 01     st\.h lr\[1\],lr
++ *[0-9a-f]*:  e9 57 d9 16     st\.h r4\[-9962\],r7
++ *[0-9a-f]*:  f3 53 c0 86     st\.h r9\[-16250\],r3
++ *[0-9a-f]*:  d7 03           nop
++
++[0-9a-f]* <st_b4>:
++ *[0-9a-f]*:  be 8f           st\.b pc\[0x0\],pc
++ *[0-9a-f]*:  f9 6c ff ff     st\.b r12\[-1\],r12
++ *[0-9a-f]*:  eb 65 80 00     st\.b r5\[-32768\],r5
++ *[0-9a-f]*:  e9 64 7f ff     st\.b r4\[32767\],r4
++ *[0-9a-f]*:  bc 9e           st\.b lr\[0x1\],lr
++ *[0-9a-f]*:  f9 66 75 96     st\.b r12\[30102\],r6
++ *[0-9a-f]*:  eb 61 71 31     st\.b r5\[28977\],r1
++ *[0-9a-f]*:  e1 61 15 5e     st\.b r0\[5470\],r1
++
++[0-9a-f]* <mfsr>:
++ *[0-9a-f]*:  e1 bf 00 00     mfsr pc,0x0
++ *[0-9a-f]*:  e1 bc 00 ff     mfsr r12,0x3fc
++ *[0-9a-f]*:  e1 b5 00 80     mfsr r5,0x200
++ *[0-9a-f]*:  e1 b4 00 7f     mfsr r4,0x1fc
++ *[0-9a-f]*:  e1 be 00 01     mfsr lr,0x4
++ *[0-9a-f]*:  e1 b2 00 ae     mfsr r2,0x2b8
++ *[0-9a-f]*:  e1 b4 00 41     mfsr r4,0x104
++ *[0-9a-f]*:  e1 ba 00 fe     mfsr r10,0x3f8
++
++[0-9a-f]* <mtsr>:
++ *[0-9a-f]*:  e3 bf 00 00     mtsr 0x0,pc
++ *[0-9a-f]*:  e3 bc 00 ff     mtsr 0x3fc,r12
++ *[0-9a-f]*:  e3 b5 00 80     mtsr 0x200,r5
++ *[0-9a-f]*:  e3 b4 00 7f     mtsr 0x1fc,r4
++ *[0-9a-f]*:  e3 be 00 01     mtsr 0x4,lr
++ *[0-9a-f]*:  e3 ba 00 38     mtsr 0xe0,r10
++ *[0-9a-f]*:  e3 bc 00 d1     mtsr 0x344,r12
++ *[0-9a-f]*:  e3 b9 00 4c     mtsr 0x130,r9
++
++[0-9a-f]* <mfdr>:
++ *[0-9a-f]*:  e5 bf 00 00     mfdr pc,0x0
++ *[0-9a-f]*:  e5 bc 00 ff     mfdr r12,0x3fc
++ *[0-9a-f]*:  e5 b5 00 80     mfdr r5,0x200
++ *[0-9a-f]*:  e5 b4 00 7f     mfdr r4,0x1fc
++ *[0-9a-f]*:  e5 be 00 01     mfdr lr,0x4
++ *[0-9a-f]*:  e5 b6 00 e9     mfdr r6,0x3a4
++ *[0-9a-f]*:  e5 b5 00 09     mfdr r5,0x24
++ *[0-9a-f]*:  e5 b9 00 4b     mfdr r9,0x12c
++
++[0-9a-f]* <mtdr>:
++ *[0-9a-f]*:  e7 bf 00 00     mtdr 0x0,pc
++ *[0-9a-f]*:  e7 bc 00 ff     mtdr 0x3fc,r12
++ *[0-9a-f]*:  e7 b5 00 80     mtdr 0x200,r5
++ *[0-9a-f]*:  e7 b4 00 7f     mtdr 0x1fc,r4
++ *[0-9a-f]*:  e7 be 00 01     mtdr 0x4,lr
++ *[0-9a-f]*:  e7 b8 00 2d     mtdr 0xb4,r8
++ *[0-9a-f]*:  e7 ba 00 b4     mtdr 0x2d0,r10
++ *[0-9a-f]*:  e7 be 00 66     mtdr 0x198,lr
++
++[0-9a-f]* <sleep>:
++ *[0-9a-f]*:  e9 b0 00 00     sleep 0x0
++ *[0-9a-f]*:  e9 b0 00 ff     sleep 0xff
++ *[0-9a-f]*:  e9 b0 00 80     sleep 0x80
++ *[0-9a-f]*:  e9 b0 00 7f     sleep 0x7f
++ *[0-9a-f]*:  e9 b0 00 01     sleep 0x1
++ *[0-9a-f]*:  e9 b0 00 fe     sleep 0xfe
++ *[0-9a-f]*:  e9 b0 00 0f     sleep 0xf
++ *[0-9a-f]*:  e9 b0 00 2b     sleep 0x2b
++
++[0-9a-f]* <sync>:
++ *[0-9a-f]*:  eb b0 00 00     sync 0x0
++ *[0-9a-f]*:  eb b0 00 ff     sync 0xff
++ *[0-9a-f]*:  eb b0 00 80     sync 0x80
++ *[0-9a-f]*:  eb b0 00 7f     sync 0x7f
++ *[0-9a-f]*:  eb b0 00 01     sync 0x1
++ *[0-9a-f]*:  eb b0 00 a6     sync 0xa6
++ *[0-9a-f]*:  eb b0 00 e6     sync 0xe6
++ *[0-9a-f]*:  eb b0 00 b4     sync 0xb4
++
++[0-9a-f]* <bld>:
++ *[0-9a-f]*:  ed bf 00 00     bld pc,0x0
++ *[0-9a-f]*:  ed bc 00 1f     bld r12,0x1f
++ *[0-9a-f]*:  ed b5 00 10     bld r5,0x10
++ *[0-9a-f]*:  ed b4 00 0f     bld r4,0xf
++ *[0-9a-f]*:  ed be 00 01     bld lr,0x1
++ *[0-9a-f]*:  ed b9 00 0f     bld r9,0xf
++ *[0-9a-f]*:  ed b0 00 04     bld r0,0x4
++ *[0-9a-f]*:  ed be 00 1a     bld lr,0x1a
++
++[0-9a-f]* <bst>:
++ *[0-9a-f]*:  ef bf 00 00     bst pc,0x0
++ *[0-9a-f]*:  ef bc 00 1f     bst r12,0x1f
++ *[0-9a-f]*:  ef b5 00 10     bst r5,0x10
++ *[0-9a-f]*:  ef b4 00 0f     bst r4,0xf
++ *[0-9a-f]*:  ef be 00 01     bst lr,0x1
++ *[0-9a-f]*:  ef ba 00 1c     bst r10,0x1c
++ *[0-9a-f]*:  ef b0 00 03     bst r0,0x3
++ *[0-9a-f]*:  ef bd 00 02     bst sp,0x2
++
++[0-9a-f]* <sats>:
++ *[0-9a-f]*:  f1 bf 00 00     sats pc,0x0
++ *[0-9a-f]*:  f1 bc 03 ff     sats r12>>0x1f,0x1f
++ *[0-9a-f]*:  f1 b5 02 10     sats r5>>0x10,0x10
++ *[0-9a-f]*:  f1 b4 01 ef     sats r4>>0xf,0xf
++ *[0-9a-f]*:  f1 be 00 21     sats lr>>0x1,0x1
++ *[0-9a-f]*:  f1 ba 02 63     sats r10>>0x3,0x13
++ *[0-9a-f]*:  f1 ba 03 42     sats r10>>0x2,0x1a
++ *[0-9a-f]*:  f1 b1 00 34     sats r1>>0x14,0x1
++
++[0-9a-f]* <satu>:
++ *[0-9a-f]*:  f1 bf 04 00     satu pc,0x0
++ *[0-9a-f]*:  f1 bc 07 ff     satu r12>>0x1f,0x1f
++ *[0-9a-f]*:  f1 b5 06 10     satu r5>>0x10,0x10
++ *[0-9a-f]*:  f1 b4 05 ef     satu r4>>0xf,0xf
++ *[0-9a-f]*:  f1 be 04 21     satu lr>>0x1,0x1
++ *[0-9a-f]*:  f1 bf 04 e5     satu pc>>0x5,0x7
++ *[0-9a-f]*:  f1 b7 04 a5     satu r7>>0x5,0x5
++ *[0-9a-f]*:  f1 b2 06 7a     satu r2>>0x1a,0x13
++
++[0-9a-f]* <satrnds>:
++ *[0-9a-f]*:  f3 bf 00 00     satrnds pc,0x0
++ *[0-9a-f]*:  f3 bc 03 ff     satrnds r12>>0x1f,0x1f
++ *[0-9a-f]*:  f3 b5 02 10     satrnds r5>>0x10,0x10
++ *[0-9a-f]*:  f3 b4 01 ef     satrnds r4>>0xf,0xf
++ *[0-9a-f]*:  f3 be 00 21     satrnds lr>>0x1,0x1
++ *[0-9a-f]*:  f3 b0 02 75     satrnds r0>>0x15,0x13
++ *[0-9a-f]*:  f3 bd 00 40     satrnds sp,0x2
++ *[0-9a-f]*:  f3 b7 03 a6     satrnds r7>>0x6,0x1d
++
++[0-9a-f]* <satrndu>:
++ *[0-9a-f]*:  f3 bf 04 00     satrndu pc,0x0
++ *[0-9a-f]*:  f3 bc 07 ff     satrndu r12>>0x1f,0x1f
++ *[0-9a-f]*:  f3 b5 06 10     satrndu r5>>0x10,0x10
++ *[0-9a-f]*:  f3 b4 05 ef     satrndu r4>>0xf,0xf
++ *[0-9a-f]*:  f3 be 04 21     satrndu lr>>0x1,0x1
++ *[0-9a-f]*:  f3 bc 07 40     satrndu r12,0x1a
++ *[0-9a-f]*:  f3 b4 04 75     satrndu r4>>0x15,0x3
++ *[0-9a-f]*:  f3 ba 06 03     satrndu r10>>0x3,0x10
++
++[0-9a-f]* <subfc>:
++ *[0-9a-f]*:  f5 bf 00 00     subfeq pc,0
++ *[0-9a-f]*:  f5 bc 0f ff     subfal r12,-1
++ *[0-9a-f]*:  f5 b5 08 80     subfls r5,-128
++ *[0-9a-f]*:  f5 b4 07 7f     subfpl r4,127
++ *[0-9a-f]*:  f5 be 01 01     subfne lr,1
++ *[0-9a-f]*:  f5 ba 08 08     subfls r10,8
++ *[0-9a-f]*:  f5 bb 0d 63     subfvc r11,99
++ *[0-9a-f]*:  f5 b2 0c 49     subfvs r2,73
++
++[0-9a-f]* <subc>:
++ *[0-9a-f]*:  f7 bf 00 00     subeq pc,0
++ *[0-9a-f]*:  f7 bc 0f ff     subal r12,-1
++ *[0-9a-f]*:  f7 b5 08 80     subls r5,-128
++ *[0-9a-f]*:  f7 b4 07 7f     subpl r4,127
++ *[0-9a-f]*:  f7 be 01 01     subne lr,1
++ *[0-9a-f]*:  f7 bc 08 76     subls r12,118
++ *[0-9a-f]*:  f7 be 0d f4     subvc lr,-12
++ *[0-9a-f]*:  f7 b4 06 f3     submi r4,-13
++
++[0-9a-f]* <movc2>:
++ *[0-9a-f]*:  f9 bf 00 00     moveq pc,0
++ *[0-9a-f]*:  f9 bc 0f ff     moval r12,-1
++ *[0-9a-f]*:  f9 b5 08 80     movls r5,-128
++ *[0-9a-f]*:  f9 b4 07 7f     movpl r4,127
++ *[0-9a-f]*:  f9 be 01 01     movne lr,1
++ *[0-9a-f]*:  f9 b3 05 86     movlt r3,-122
++ *[0-9a-f]*:  f9 b8 0d 02     movvc r8,2
++ *[0-9a-f]*:  f9 b7 01 91     movne r7,-111
++
++[0-9a-f]* <cp_b>:
++ *[0-9a-f]*:  e0 0f 18 00     cp\.b pc,r0
++ *[0-9a-f]*:  fe 00 18 00     cp\.b r0,pc
++ *[0-9a-f]*:  f0 07 18 00     cp\.b r7,r8
++ *[0-9a-f]*:  ee 08 18 00     cp\.b r8,r7
++
++[0-9a-f]* <cp_h>:
++ *[0-9a-f]*:  e0 0f 19 00     cp\.h pc,r0
++ *[0-9a-f]*:  fe 00 19 00     cp\.h r0,pc
++ *[0-9a-f]*:  f0 07 19 00     cp\.h r7,r8
++ *[0-9a-f]*:  ee 08 19 00     cp\.h r8,r7
++
++[0-9a-f]* <ldm>:
++ *[0-9a-f]*:  e1 cf 00 7e     ldm pc,r1-r6
++ *[0-9a-f]*:  e1 cc ff ff     ldm r12,r0-pc
++ *[0-9a-f]*:  e1 c5 80 00     ldm r5,pc
++ *[0-9a-f]*:  e1 c4 7f ff     ldm r4,r0-lr
++ *[0-9a-f]*:  e1 ce 00 01     ldm lr,r0
++ *[0-9a-f]*:  e1 c9 40 22     ldm r9,r1,r5,lr
++ *[0-9a-f]*:  e1 cb 81 ec     ldm r11,r2-r3,r5-r8,pc
++ *[0-9a-f]*:  e1 c6 a2 09     ldm r6,r0,r3,r9,sp,pc
++
++[0-9a-f]* <ldm_pu>:
++ *[0-9a-f]*:  e3 cf 03 c0     ldm pc\+\+,r6-r9
++ *[0-9a-f]*:  e3 cc ff ff     ldm r12\+\+,r0-pc
++ *[0-9a-f]*:  e3 c5 80 00     ldm r5\+\+,pc
++ *[0-9a-f]*:  e3 c4 7f ff     ldm r4\+\+,r0-lr
++ *[0-9a-f]*:  e3 ce 00 01     ldm lr\+\+,r0
++ *[0-9a-f]*:  e3 cc d5 38     ldm r12\+\+,r3-r5,r8,r10,r12,lr-pc
++ *[0-9a-f]*:  e3 ca c0 74     ldm r10\+\+,r2,r4-r6,lr-pc
++ *[0-9a-f]*:  e3 c6 7e 1a     ldm r6\+\+,r1,r3-r4,r9-lr
++
++[0-9a-f]* <ldmts>:
++ *[0-9a-f]*:  e5 cf 01 80     ldmts pc,r7-r8
++ *[0-9a-f]*:  e5 cc ff ff     ldmts r12,r0-pc
++ *[0-9a-f]*:  e5 c5 80 00     ldmts r5,pc
++ *[0-9a-f]*:  e5 c4 7f ff     ldmts r4,r0-lr
++ *[0-9a-f]*:  e5 ce 00 01     ldmts lr,r0
++ *[0-9a-f]*:  e5 c0 18 06     ldmts r0,r1-r2,r11-r12
++ *[0-9a-f]*:  e5 ce 61 97     ldmts lr,r0-r2,r4,r7-r8,sp-lr
++ *[0-9a-f]*:  e5 cc c2 3b     ldmts r12,r0-r1,r3-r5,r9,lr-pc
++
++[0-9a-f]* <ldmts_pu>:
++ *[0-9a-f]*:  e7 cf 02 00     ldmts pc\+\+,r9
++ *[0-9a-f]*:  e7 cc ff ff     ldmts r12\+\+,r0-pc
++ *[0-9a-f]*:  e7 c5 80 00     ldmts r5\+\+,pc
++ *[0-9a-f]*:  e7 c4 7f ff     ldmts r4\+\+,r0-lr
++ *[0-9a-f]*:  e7 ce 00 01     ldmts lr\+\+,r0
++ *[0-9a-f]*:  e7 cd 0a bd     ldmts sp\+\+,r0,r2-r5,r7,r9,r11
++ *[0-9a-f]*:  e7 c5 0c 8e     ldmts r5\+\+,r1-r3,r7,r10-r11
++ *[0-9a-f]*:  e7 c8 a1 9c     ldmts r8\+\+,r2-r4,r7-r8,sp,pc
++
++[0-9a-f]* <stm>:
++ *[0-9a-f]*:  e9 cf 00 80     stm pc,r7
++ *[0-9a-f]*:  e9 cc ff ff     stm r12,r0-pc
++ *[0-9a-f]*:  e9 c5 80 00     stm r5,pc
++ *[0-9a-f]*:  e9 c4 7f ff     stm r4,r0-lr
++ *[0-9a-f]*:  e9 ce 00 01     stm lr,r0
++ *[0-9a-f]*:  e9 cd 49 2c     stm sp,r2-r3,r5,r8,r11,lr
++ *[0-9a-f]*:  e9 c4 4c 5f     stm r4,r0-r4,r6,r10-r11,lr
++ *[0-9a-f]*:  e9 c9 f2 22     stm r9,r1,r5,r9,r12-pc
++
++[0-9a-f]* <stm_pu>:
++ *[0-9a-f]*:  eb cf 00 70     stm --pc,r4-r6
++ *[0-9a-f]*:  eb cc ff ff     stm --r12,r0-pc
++ *[0-9a-f]*:  eb c5 80 00     stm --r5,pc
++ *[0-9a-f]*:  eb c4 7f ff     stm --r4,r0-lr
++ *[0-9a-f]*:  eb ce 00 01     stm --lr,r0
++ *[0-9a-f]*:  eb cb fb f1     stm --r11,r0,r4-r9,r11-pc
++ *[0-9a-f]*:  eb cb 56 09     stm --r11,r0,r3,r9-r10,r12,lr
++ *[0-9a-f]*:  eb c6 63 04     stm --r6,r2,r8-r9,sp-lr
++
++[0-9a-f]* <stmts>:
++ *[0-9a-f]*:  ed cf 01 00     stmts pc,r8
++ *[0-9a-f]*:  ed cc ff ff     stmts r12,r0-pc
++ *[0-9a-f]*:  ed c5 80 00     stmts r5,pc
++ *[0-9a-f]*:  ed c4 7f ff     stmts r4,r0-lr
++ *[0-9a-f]*:  ed ce 00 01     stmts lr,r0
++ *[0-9a-f]*:  ed c1 c6 5b     stmts r1,r0-r1,r3-r4,r6,r9-r10,lr-pc
++ *[0-9a-f]*:  ed c3 1d c1     stmts r3,r0,r6-r8,r10-r12
++ *[0-9a-f]*:  ed cb d6 d1     stmts r11,r0,r4,r6-r7,r9-r10,r12,lr-pc
++
++[0-9a-f]* <stmts_pu>:
++ *[0-9a-f]*:  ef cf 01 c0     stmts --pc,r6-r8
++ *[0-9a-f]*:  ef cc ff ff     stmts --r12,r0-pc
++ *[0-9a-f]*:  ef c5 80 00     stmts --r5,pc
++ *[0-9a-f]*:  ef c4 7f ff     stmts --r4,r0-lr
++ *[0-9a-f]*:  ef ce 00 01     stmts --lr,r0
++ *[0-9a-f]*:  ef c2 36 19     stmts --r2,r0,r3-r4,r9-r10,r12-sp
++ *[0-9a-f]*:  ef c3 c0 03     stmts --r3,r0-r1,lr-pc
++ *[0-9a-f]*:  ef c0 44 7d     stmts --r0,r0,r2-r6,r10,lr
++
++[0-9a-f]* <ldins_h>:
++ *[0-9a-f]*:  ff df 00 00     ldins\.h pc:b,pc\[0\]
++ *[0-9a-f]*:  f9 dc 1f ff     ldins\.h r12:t,r12\[-2\]
++ *[0-9a-f]*:  eb d5 18 00     ldins\.h r5:t,r5\[-4096\]
++ *[0-9a-f]*:  e9 d4 07 ff     ldins\.h r4:b,r4\[4094\]
++ *[0-9a-f]*:  fd de 10 01     ldins\.h lr:t,lr\[2\]
++ *[0-9a-f]*:  fd d0 13 c5     ldins\.h r0:t,lr\[1930\]
++ *[0-9a-f]*:  ef d3 0e f5     ldins\.h r3:b,r7\[-534\]
++ *[0-9a-f]*:  f9 d2 0b 9a     ldins\.h r2:b,r12\[-2252\]
++
++[0-9a-f]* <ldins_b>:
++ *[0-9a-f]*:  ff df 40 00     ldins\.b pc:b,pc\[0\]
++ *[0-9a-f]*:  f9 dc 7f ff     ldins\.b r12:t,r12\[-1\]
++ *[0-9a-f]*:  eb d5 68 00     ldins\.b r5:u,r5\[-2048\]
++ *[0-9a-f]*:  e9 d4 57 ff     ldins\.b r4:l,r4\[2047\]
++ *[0-9a-f]*:  fd de 50 01     ldins\.b lr:l,lr\[1\]
++ *[0-9a-f]*:  e9 d6 7d 6a     ldins\.b r6:t,r4\[-662\]
++ *[0-9a-f]*:  e3 d5 4f 69     ldins\.b r5:b,r1\[-151\]
++ *[0-9a-f]*:  f7 da 78 7d     ldins\.b r10:t,r11\[-1923\]
++
++[0-9a-f]* <ldswp_sh>:
++ *[0-9a-f]*:  ff df 20 00     ldswp\.sh pc,pc\[0\]
++ *[0-9a-f]*:  f9 dc 2f ff     ldswp\.sh r12,r12\[-2\]
++ *[0-9a-f]*:  eb d5 28 00     ldswp\.sh r5,r5\[-4096\]
++ *[0-9a-f]*:  e9 d4 27 ff     ldswp\.sh r4,r4\[4094\]
++ *[0-9a-f]*:  fd de 20 01     ldswp\.sh lr,lr\[2\]
++ *[0-9a-f]*:  f5 d9 27 84     ldswp\.sh r9,r10\[3848\]
++ *[0-9a-f]*:  f9 d4 2c 04     ldswp\.sh r4,r12\[-2040\]
++ *[0-9a-f]*:  e5 da 26 08     ldswp\.sh r10,r2\[3088\]
++
++[0-9a-f]* <ldswp_uh>:
++ *[0-9a-f]*:  ff df 30 00     ldswp\.uh pc,pc\[0\]
++ *[0-9a-f]*:  f9 dc 3f ff     ldswp\.uh r12,r12\[-2\]
++ *[0-9a-f]*:  eb d5 38 00     ldswp\.uh r5,r5\[-4096\]
++ *[0-9a-f]*:  e9 d4 37 ff     ldswp\.uh r4,r4\[4094\]
++ *[0-9a-f]*:  fd de 30 01     ldswp\.uh lr,lr\[2\]
++ *[0-9a-f]*:  f3 d4 37 46     ldswp\.uh r4,r9\[3724\]
++ *[0-9a-f]*:  fb de 3c bc     ldswp\.uh lr,sp\[-1672\]
++ *[0-9a-f]*:  f9 d8 38 7d     ldswp\.uh r8,r12\[-3846\]
++
++[0-9a-f]* <ldswp_w>:
++ *[0-9a-f]*:  ff df 80 00     ldswp\.w pc,pc\[0\]
++ *[0-9a-f]*:  f9 dc 8f ff     ldswp\.w r12,r12\[-4\]
++ *[0-9a-f]*:  eb d5 88 00     ldswp\.w r5,r5\[-8192\]
++ *[0-9a-f]*:  e9 d4 87 ff     ldswp\.w r4,r4\[8188\]
++ *[0-9a-f]*:  fd de 80 01     ldswp\.w lr,lr\[4\]
++ *[0-9a-f]*:  ef dd 81 d1     ldswp\.w sp,r7\[1860\]
++ *[0-9a-f]*:  eb df 8c c1     ldswp\.w pc,r5\[-3324\]
++ *[0-9a-f]*:  f5 dc 8c c8     ldswp\.w r12,r10\[-3296\]
++
++[0-9a-f]* <stswp_h>:
++ *[0-9a-f]*:  ff df 90 00     stswp\.h pc\[0\],pc
++ *[0-9a-f]*:  f9 dc 9f ff     stswp\.h r12\[-2\],r12
++ *[0-9a-f]*:  eb d5 98 00     stswp\.h r5\[-4096\],r5
++ *[0-9a-f]*:  e9 d4 97 ff     stswp\.h r4\[4094\],r4
++ *[0-9a-f]*:  fd de 90 01     stswp\.h lr\[2\],lr
++ *[0-9a-f]*:  ef da 90 20     stswp\.h r7\[64\],r10
++ *[0-9a-f]*:  f5 d2 95 e8     stswp\.h r10\[3024\],r2
++ *[0-9a-f]*:  e1 da 9b 74     stswp\.h r0\[-2328\],r10
++
++[0-9a-f]* <stswp_w>:
++ *[0-9a-f]*:  ff df a0 00     stswp\.w pc\[0\],pc
++ *[0-9a-f]*:  f9 dc af ff     stswp\.w r12\[-4\],r12
++ *[0-9a-f]*:  eb d5 a8 00     stswp\.w r5\[-8192\],r5
++ *[0-9a-f]*:  e9 d4 a7 ff     stswp\.w r4\[8188\],r4
++ *[0-9a-f]*:  fd de a0 01     stswp\.w lr\[4\],lr
++ *[0-9a-f]*:  ff d8 a1 21     stswp\.w pc\[1156\],r8
++ *[0-9a-f]*:  fb da a7 ce     stswp\.w sp\[7992\],r10
++ *[0-9a-f]*:  f1 d5 ae db     stswp\.w r8\[-1172\],r5
++
++[0-9a-f]* <and2>:
++ *[0-9a-f]*:  ff ef 00 0f     and pc,pc,pc
++ *[0-9a-f]*:  f9 ec 01 fc     and r12,r12,r12<<0x1f
++ *[0-9a-f]*:  eb e5 01 05     and r5,r5,r5<<0x10
++ *[0-9a-f]*:  e9 e4 00 f4     and r4,r4,r4<<0xf
++ *[0-9a-f]*:  fd ee 00 1e     and lr,lr,lr<<0x1
++ *[0-9a-f]*:  e5 e1 00 1a     and r10,r2,r1<<0x1
++ *[0-9a-f]*:  f1 eb 01 bc     and r12,r8,r11<<0x1b
++ *[0-9a-f]*:  ef e0 00 3a     and r10,r7,r0<<0x3
++
++[0-9a-f]* <and3>:
++ *[0-9a-f]*:  ff ef 02 0f     and pc,pc,pc
++ *[0-9a-f]*:  f9 ec 03 fc     and r12,r12,r12>>0x1f
++ *[0-9a-f]*:  eb e5 03 05     and r5,r5,r5>>0x10
++ *[0-9a-f]*:  e9 e4 02 f4     and r4,r4,r4>>0xf
++ *[0-9a-f]*:  fd ee 02 1e     and lr,lr,lr>>0x1
++ *[0-9a-f]*:  f1 e7 03 1c     and r12,r8,r7>>0x11
++ *[0-9a-f]*:  e9 e9 03 4f     and pc,r4,r9>>0x14
++ *[0-9a-f]*:  f3 ea 02 ca     and r10,r9,r10>>0xc
++
++[0-9a-f]* <or2>:
++ *[0-9a-f]*:  ff ef 10 0f     or pc,pc,pc
++ *[0-9a-f]*:  f9 ec 11 fc     or r12,r12,r12<<0x1f
++ *[0-9a-f]*:  eb e5 11 05     or r5,r5,r5<<0x10
++ *[0-9a-f]*:  e9 e4 10 f4     or r4,r4,r4<<0xf
++ *[0-9a-f]*:  fd ee 10 1e     or lr,lr,lr<<0x1
++ *[0-9a-f]*:  fb eb 11 d8     or r8,sp,r11<<0x1d
++ *[0-9a-f]*:  f3 e2 11 cf     or pc,r9,r2<<0x1c
++ *[0-9a-f]*:  e3 e2 10 35     or r5,r1,r2<<0x3
++
++[0-9a-f]* <or3>:
++ *[0-9a-f]*:  ff ef 12 0f     or pc,pc,pc
++ *[0-9a-f]*:  f9 ec 13 fc     or r12,r12,r12>>0x1f
++ *[0-9a-f]*:  eb e5 13 05     or r5,r5,r5>>0x10
++ *[0-9a-f]*:  e9 e4 12 f4     or r4,r4,r4>>0xf
++ *[0-9a-f]*:  fd ee 12 1e     or lr,lr,lr>>0x1
++ *[0-9a-f]*:  fb ed 12 21     or r1,sp,sp>>0x2
++ *[0-9a-f]*:  e3 e1 13 d0     or r0,r1,r1>>0x1d
++ *[0-9a-f]*:  f9 e8 12 84     or r4,r12,r8>>0x8
++
++[0-9a-f]* <eor2>:
++ *[0-9a-f]*:  ff ef 20 0f     eor pc,pc,pc
++ *[0-9a-f]*:  f9 ec 21 fc     eor r12,r12,r12<<0x1f
++ *[0-9a-f]*:  eb e5 21 05     eor r5,r5,r5<<0x10
++ *[0-9a-f]*:  e9 e4 20 f4     eor r4,r4,r4<<0xf
++ *[0-9a-f]*:  fd ee 20 1e     eor lr,lr,lr<<0x1
++ *[0-9a-f]*:  f3 e4 20 ba     eor r10,r9,r4<<0xb
++ *[0-9a-f]*:  e1 e1 21 f4     eor r4,r0,r1<<0x1f
++ *[0-9a-f]*:  e5 ec 20 d6     eor r6,r2,r12<<0xd
++
++[0-9a-f]* <eor3>:
++ *[0-9a-f]*:  ff ef 22 0f     eor pc,pc,pc
++ *[0-9a-f]*:  f9 ec 23 fc     eor r12,r12,r12>>0x1f
++ *[0-9a-f]*:  eb e5 23 05     eor r5,r5,r5>>0x10
++ *[0-9a-f]*:  e9 e4 22 f4     eor r4,r4,r4>>0xf
++ *[0-9a-f]*:  fd ee 22 1e     eor lr,lr,lr>>0x1
++ *[0-9a-f]*:  eb e5 23 65     eor r5,r5,r5>>0x16
++ *[0-9a-f]*:  e3 ee 22 3a     eor r10,r1,lr>>0x3
++ *[0-9a-f]*:  fd ed 23 a7     eor r7,lr,sp>>0x1a
++
++[0-9a-f]* <sthh_w2>:
++ *[0-9a-f]*:  ff ef 8f 0f     sthh\.w pc\[pc\],pc:b,pc:b
++ *[0-9a-f]*:  f9 ec bc 3c     sthh\.w r12\[r12<<0x3\],r12:t,r12:t
++ *[0-9a-f]*:  eb e5 b5 25     sthh\.w r5\[r5<<0x2\],r5:t,r5:t
++ *[0-9a-f]*:  e9 e4 84 14     sthh\.w r4\[r4<<0x1\],r4:b,r4:b
++ *[0-9a-f]*:  fd ee be 1e     sthh\.w lr\[lr<<0x1\],lr:t,lr:t
++ *[0-9a-f]*:  e3 ec b6 3d     sthh\.w sp\[r6<<0x3\],r1:t,r12:t
++ *[0-9a-f]*:  f3 e9 b6 06     sthh\.w r6\[r6\],r9:t,r9:t
++ *[0-9a-f]*:  e1 eb 93 0a     sthh\.w r10\[r3\],r0:b,r11:t
++
++[0-9a-f]* <sthh_w1>:
++ *[0-9a-f]*:  ff ef c0 0f     sthh\.w pc\[0x0\],pc:b,pc:b
++ *[0-9a-f]*:  f9 ec ff fc     sthh\.w r12\[0x3fc\],r12:t,r12:t
++ *[0-9a-f]*:  eb e5 f8 05     sthh\.w r5\[0x200\],r5:t,r5:t
++ *[0-9a-f]*:  e9 e4 c7 f4     sthh\.w r4\[0x1fc\],r4:b,r4:b
++ *[0-9a-f]*:  fd ee f0 1e     sthh\.w lr\[0x4\],lr:t,lr:t
++ *[0-9a-f]*:  f3 e0 e6 54     sthh\.w r4\[0x194\],r9:t,r0:b
++ *[0-9a-f]*:  e5 ea e5 78     sthh\.w r8\[0x15c\],r2:t,r10:b
++ *[0-9a-f]*:  f3 e2 c2 bd     sthh\.w sp\[0xac\],r9:b,r2:b
++
++[0-9a-f]* <cop>:
++ *[0-9a-f]*:  e1 a0 00 00     cop cp0,cr0,cr0,cr0,0x0
++ *[0-9a-f]*:  e7 af ff ff     cop cp7,cr15,cr15,cr15,0x7f
++ *[0-9a-f]*:  e3 a8 75 55     cop cp3,cr5,cr5,cr5,0x31
++ *[0-9a-f]*:  e3 a8 44 44     cop cp2,cr4,cr4,cr4,0x30
++ *[0-9a-f]*:  e5 ad a8 37     cop cp5,cr8,cr3,cr7,0x5a
++
++[0-9a-f]* <ldc_w1>:
++ *[0-9a-f]*:  e9 a0 00 00     ldc\.w cp0,cr0,r0\[0x0\]
++ *[0-9a-f]*:  e9 af ef ff     ldc\.w cp7,cr15,pc\[0x3fc\]
++ *[0-9a-f]*:  e9 a5 65 80     ldc\.w cp3,cr5,r5\[0x200\]
++ *[0-9a-f]*:  e9 a4 44 7f     ldc\.w cp2,cr4,r4\[0x1fc\]
++ *[0-9a-f]*:  e9 ad 89 24     ldc\.w cp4,cr9,sp\[0x90\]
++
++[0-9a-f]* <ldc_w2>:
++ *[0-9a-f]*:  ef a0 00 40     ldc\.w cp0,cr0,--r0
++ *[0-9a-f]*:  ef af ef 40     ldc\.w cp7,cr15,--pc
++ *[0-9a-f]*:  ef a5 65 40     ldc\.w cp3,cr5,--r5
++ *[0-9a-f]*:  ef a4 44 40     ldc\.w cp2,cr4,--r4
++ *[0-9a-f]*:  ef ad 89 40     ldc\.w cp4,cr9,--sp
++
++[0-9a-f]* <ldc_w3>:
++ *[0-9a-f]*:  ef a0 10 00     ldc\.w cp0,cr0,r0\[r0\]
++ *[0-9a-f]*:  ef af ff 3f     ldc\.w cp7,cr15,pc\[pc<<0x3\]
++ *[0-9a-f]*:  ef a5 75 24     ldc\.w cp3,cr5,r5\[r4<<0x2\]
++ *[0-9a-f]*:  ef a4 54 13     ldc\.w cp2,cr4,r4\[r3<<0x1\]
++ *[0-9a-f]*:  ef ad 99 0c     ldc\.w cp4,cr9,sp\[r12\]
++
++[0-9a-f]* <ldc_d1>:
++ *[0-9a-f]*:  e9 a0 10 00     ldc\.d cp0,cr0,r0\[0x0\]
++ *[0-9a-f]*:  e9 af fe ff     ldc\.d cp7,cr14,pc\[0x3fc\]
++ *[0-9a-f]*:  e9 a5 76 80     ldc\.d cp3,cr6,r5\[0x200\]
++ *[0-9a-f]*:  e9 a4 54 7f     ldc\.d cp2,cr4,r4\[0x1fc\]
++ *[0-9a-f]*:  e9 ad 98 24     ldc\.d cp4,cr8,sp\[0x90\]
++
++[0-9a-f]* <ldc_d2>:
++ *[0-9a-f]*:  ef a0 00 50     ldc\.d cp0,cr0,--r0
++ *[0-9a-f]*:  ef af ee 50     ldc\.d cp7,cr14,--pc
++ *[0-9a-f]*:  ef a5 66 50     ldc\.d cp3,cr6,--r5
++ *[0-9a-f]*:  ef a4 44 50     ldc\.d cp2,cr4,--r4
++ *[0-9a-f]*:  ef ad 88 50     ldc\.d cp4,cr8,--sp
++
++[0-9a-f]* <ldc_d3>:
++ *[0-9a-f]*:  ef a0 10 40     ldc\.d cp0,cr0,r0\[r0\]
++ *[0-9a-f]*:  ef af fe 7f     ldc\.d cp7,cr14,pc\[pc<<0x3\]
++ *[0-9a-f]*:  ef a5 76 64     ldc\.d cp3,cr6,r5\[r4<<0x2\]
++ *[0-9a-f]*:  ef a4 54 53     ldc\.d cp2,cr4,r4\[r3<<0x1\]
++ *[0-9a-f]*:  ef ad 98 4c     ldc\.d cp4,cr8,sp\[r12\]
++
++[0-9a-f]* <stc_w1>:
++ *[0-9a-f]*:  eb a0 00 00     stc\.w cp0,r0\[0x0\],cr0
++ *[0-9a-f]*:  eb af ef ff     stc\.w cp7,pc\[0x3fc\],cr15
++ *[0-9a-f]*:  eb a5 65 80     stc\.w cp3,r5\[0x200\],cr5
++ *[0-9a-f]*:  eb a4 44 7f     stc\.w cp2,r4\[0x1fc\],cr4
++ *[0-9a-f]*:  eb ad 89 24     stc\.w cp4,sp\[0x90\],cr9
++
++[0-9a-f]* <stc_w2>:
++ *[0-9a-f]*:  ef a0 00 60     stc\.w cp0,r0\+\+,cr0
++ *[0-9a-f]*:  ef af ef 60     stc\.w cp7,pc\+\+,cr15
++ *[0-9a-f]*:  ef a5 65 60     stc\.w cp3,r5\+\+,cr5
++ *[0-9a-f]*:  ef a4 44 60     stc\.w cp2,r4\+\+,cr4
++ *[0-9a-f]*:  ef ad 89 60     stc\.w cp4,sp\+\+,cr9
++
++[0-9a-f]* <stc_w3>:
++ *[0-9a-f]*:  ef a0 10 80     stc\.w cp0,r0\[r0\],cr0
++ *[0-9a-f]*:  ef af ff bf     stc\.w cp7,pc\[pc<<0x3\],cr15
++ *[0-9a-f]*:  ef a5 75 a4     stc\.w cp3,r5\[r4<<0x2\],cr5
++ *[0-9a-f]*:  ef a4 54 93     stc\.w cp2,r4\[r3<<0x1\],cr4
++ *[0-9a-f]*:  ef ad 99 8c     stc\.w cp4,sp\[r12\],cr9
++
++[0-9a-f]* <stc_d1>:
++ *[0-9a-f]*:  eb a0 10 00     stc\.d cp0,r0\[0x0\],cr0
++ *[0-9a-f]*:  eb af fe ff     stc\.d cp7,pc\[0x3fc\],cr14
++ *[0-9a-f]*:  eb a5 76 80     stc\.d cp3,r5\[0x200\],cr6
++ *[0-9a-f]*:  eb a4 54 7f     stc\.d cp2,r4\[0x1fc\],cr4
++ *[0-9a-f]*:  eb ad 98 24     stc\.d cp4,sp\[0x90\],cr8
++
++[0-9a-f]* <stc_d2>:
++ *[0-9a-f]*:  ef a0 00 70     stc\.d cp0,r0\+\+,cr0
++ *[0-9a-f]*:  ef af ee 70     stc\.d cp7,pc\+\+,cr14
++ *[0-9a-f]*:  ef a5 66 70     stc\.d cp3,r5\+\+,cr6
++ *[0-9a-f]*:  ef a4 44 70     stc\.d cp2,r4\+\+,cr4
++ *[0-9a-f]*:  ef ad 88 70     stc\.d cp4,sp\+\+,cr8
++
++[0-9a-f]* <stc_d3>:
++ *[0-9a-f]*:  ef a0 10 c0     stc\.d cp0,r0\[r0\],cr0
++ *[0-9a-f]*:  ef af fe ff     stc\.d cp7,pc\[pc<<0x3\],cr14
++ *[0-9a-f]*:  ef a5 76 e4     stc\.d cp3,r5\[r4<<0x2\],cr6
++ *[0-9a-f]*:  ef a4 54 d3     stc\.d cp2,r4\[r3<<0x1\],cr4
++ *[0-9a-f]*:  ef ad 98 cc     stc\.d cp4,sp\[r12\],cr8
++
++[0-9a-f]* <ldc0_w>:
++ *[0-9a-f]*:  f1 a0 00 00     ldc0\.w cr0,r0\[0x0\]
++ *[0-9a-f]*:  f1 af ff ff     ldc0\.w cr15,pc\[0x3ffc\]
++ *[0-9a-f]*:  f1 a5 85 00     ldc0\.w cr5,r5\[0x2000\]
++ *[0-9a-f]*:  f1 a4 74 ff     ldc0\.w cr4,r4\[0x1ffc\]
++ *[0-9a-f]*:  f1 ad 09 93     ldc0\.w cr9,sp\[0x24c\]
++
++[0-9a-f]* <ldc0_d>:
++ *[0-9a-f]*:  f3 a0 00 00     ldc0\.d cr0,r0\[0x0\]
++ *[0-9a-f]*:  f3 af fe ff     ldc0\.d cr14,pc\[0x3ffc\]
++ *[0-9a-f]*:  f3 a5 86 00     ldc0\.d cr6,r5\[0x2000\]
++ *[0-9a-f]*:  f3 a4 74 ff     ldc0\.d cr4,r4\[0x1ffc\]
++ *[0-9a-f]*:  f3 ad 08 93     ldc0\.d cr8,sp\[0x24c\]
++
++[0-9a-f]* <stc0_w>:
++ *[0-9a-f]*:  f5 a0 00 00     stc0\.w r0\[0x0\],cr0
++ *[0-9a-f]*:  f5 af ff ff     stc0\.w pc\[0x3ffc\],cr15
++ *[0-9a-f]*:  f5 a5 85 00     stc0\.w r5\[0x2000\],cr5
++ *[0-9a-f]*:  f5 a4 74 ff     stc0\.w r4\[0x1ffc\],cr4
++ *[0-9a-f]*:  f5 ad 09 93     stc0\.w sp\[0x24c\],cr9
++
++[0-9a-f]* <stc0_d>:
++ *[0-9a-f]*:  f7 a0 00 00     stc0\.d r0\[0x0\],cr0
++ *[0-9a-f]*:  f7 af fe ff     stc0\.d pc\[0x3ffc\],cr14
++ *[0-9a-f]*:  f7 a5 86 00     stc0\.d r5\[0x2000\],cr6
++ *[0-9a-f]*:  f7 a4 74 ff     stc0\.d r4\[0x1ffc\],cr4
++ *[0-9a-f]*:  f7 ad 08 93     stc0\.d sp\[0x24c\],cr8
++
++[0-9a-f]* <memc>:
++ *[0-9a-f]*:  f6 10 00 00     memc 0,0x0
++ *[0-9a-f]*:  f6 1f ff ff     memc -4,0x1f
++ *[0-9a-f]*:  f6 18 40 00     memc -65536,0x10
++ *[0-9a-f]*:  f6 17 bf ff     memc 65532,0xf
++
++[0-9a-f]* <mems>:
++ *[0-9a-f]*:  f8 10 00 00     mems 0,0x0
++ *[0-9a-f]*:  f8 1f ff ff     mems -4,0x1f
++ *[0-9a-f]*:  f8 18 40 00     mems -65536,0x10
++ *[0-9a-f]*:  f8 17 bf ff     mems 65532,0xf
++
++[0-9a-f]* <memt>:
++ *[0-9a-f]*:  fa 10 00 00     memt 0,0x0
++ *[0-9a-f]*:  fa 1f ff ff     memt -4,0x1f
++ *[0-9a-f]*:  fa 18 40 00     memt -65536,0x10
++ *[0-9a-f]*:  fa 17 bf ff     memt 65532,0xf
++
++[0-9a-f]* <stcond>:
++ *[0-9a-f]*:  e1 70 00 00     stcond r0\[0\],r0
++ *[0-9a-f]*:  ff 7f ff ff     stcond pc\[-1\],pc
++ *[0-9a-f]*:  f1 77 80 00     stcond r8\[-32768\],r7
++ *[0-9a-f]*:  ef 78 7f ff     stcond r7\[32767\],r8
++ *[0-9a-f]*:  eb 7a 12 34     stcond r5\[4660\],r10
++
++[0-9a-f]* <ldcm_w>:
++ *[0-9a-f]*:  ed af 00 ff     ldcm\.w cp0,pc,cr0-cr7
++ *[0-9a-f]*:  ed a0 e0 01     ldcm\.w cp7,r0,cr0
++ *[0-9a-f]*:  ed a4 90 7f     ldcm\.w cp4,r4\+\+,cr0-cr6
++ *[0-9a-f]*:  ed a7 60 80     ldcm\.w cp3,r7,cr7
++ *[0-9a-f]*:  ed ac 30 72     ldcm\.w cp1,r12\+\+,cr1,cr4-cr6
++ *[0-9a-f]*:  ed af 01 ff     ldcm\.w cp0,pc,cr8-cr15
++ *[0-9a-f]*:  ed a0 e1 01     ldcm\.w cp7,r0,cr8
++ *[0-9a-f]*:  ed a4 91 7f     ldcm\.w cp4,r4\+\+,cr8-cr14
++ *[0-9a-f]*:  ed a7 61 80     ldcm\.w cp3,r7,cr15
++ *[0-9a-f]*:  ed ac 31 72     ldcm\.w cp1,r12\+\+,cr9,cr12-cr14
++
++[0-9a-f]* <ldcm_d>:
++ *[0-9a-f]*:  ed af 04 ff     ldcm\.d cp0,pc,cr0-cr15
++ *[0-9a-f]*:  ed a0 e4 01     ldcm\.d cp7,r0,cr0-cr1
++ *[0-9a-f]*:  ed a4 94 7f     ldcm\.d cp4,r4\+\+,cr0-cr13
++ *[0-9a-f]*:  ed a7 64 80     ldcm\.d cp3,r7,cr14-cr15
++ *[0-9a-f]*:  ed ac 54 93     ldcm\.d cp2,r12\+\+,cr0-cr3,cr8-cr9,cr14-cr15
++
++[0-9a-f]* <stcm_w>:
++ *[0-9a-f]*:  ed af 02 ff     stcm\.w cp0,pc,cr0-cr7
++ *[0-9a-f]*:  ed a0 e2 01     stcm\.w cp7,r0,cr0
++ *[0-9a-f]*:  ed a4 92 7f     stcm\.w cp4,--r4,cr0-cr6
++ *[0-9a-f]*:  ed a7 62 80     stcm\.w cp3,r7,cr7
++ *[0-9a-f]*:  ed ac 32 72     stcm\.w cp1,--r12,cr1,cr4-cr6
++ *[0-9a-f]*:  ed af 03 ff     stcm\.w cp0,pc,cr8-cr15
++ *[0-9a-f]*:  ed a0 e3 01     stcm\.w cp7,r0,cr8
++ *[0-9a-f]*:  ed a4 93 7f     stcm\.w cp4,--r4,cr8-cr14
++ *[0-9a-f]*:  ed a7 63 80     stcm\.w cp3,r7,cr15
++ *[0-9a-f]*:  ed ac 33 72     stcm\.w cp1,--r12,cr9,cr12-cr14
++
++[0-9a-f]* <stcm_d>:
++ *[0-9a-f]*:  ed af 05 ff     stcm\.d cp0,pc,cr0-cr15
++ *[0-9a-f]*:  ed a0 e5 01     stcm\.d cp7,r0,cr0-cr1
++ *[0-9a-f]*:  ed a4 95 7f     stcm\.d cp4,--r4,cr0-cr13
++ *[0-9a-f]*:  ed a7 65 80     stcm\.d cp3,r7,cr14-cr15
++ *[0-9a-f]*:  ed ac 55 93     stcm\.d cp2,--r12,cr0-cr3,cr8-cr9,cr14-cr15
++
++[0-9a-f]* <mvcr_w>:
++ *[0-9a-f]*:  ef af ef 00     mvcr\.w cp7,pc,cr15
++ *[0-9a-f]*:  ef a0 00 00     mvcr\.w cp0,r0,cr0
++ *[0-9a-f]*:  ef af 0f 00     mvcr\.w cp0,pc,cr15
++ *[0-9a-f]*:  ef a0 ef 00     mvcr\.w cp7,r0,cr15
++ *[0-9a-f]*:  ef af e0 00     mvcr\.w cp7,pc,cr0
++ *[0-9a-f]*:  ef a7 88 00     mvcr\.w cp4,r7,cr8
++ *[0-9a-f]*:  ef a8 67 00     mvcr\.w cp3,r8,cr7
++
++[0-9a-f]* <mvcr_d>:
++ *[0-9a-f]*:  ef ae ee 10     mvcr\.d cp7,lr,cr14
++ *[0-9a-f]*:  ef a0 00 10     mvcr\.d cp0,r0,cr0
++ *[0-9a-f]*:  ef ae 0e 10     mvcr\.d cp0,lr,cr14
++ *[0-9a-f]*:  ef a0 ee 10     mvcr\.d cp7,r0,cr14
++ *[0-9a-f]*:  ef ae e0 10     mvcr\.d cp7,lr,cr0
++ *[0-9a-f]*:  ef a6 88 10     mvcr\.d cp4,r6,cr8
++ *[0-9a-f]*:  ef a8 66 10     mvcr\.d cp3,r8,cr6
++
++[0-9a-f]* <mvrc_w>:
++ *[0-9a-f]*:  ef af ef 20     mvrc\.w cp7,cr15,pc
++ *[0-9a-f]*:  ef a0 00 20     mvrc\.w cp0,cr0,r0
++ *[0-9a-f]*:  ef af 0f 20     mvrc\.w cp0,cr15,pc
++ *[0-9a-f]*:  ef a0 ef 20     mvrc\.w cp7,cr15,r0
++ *[0-9a-f]*:  ef af e0 20     mvrc\.w cp7,cr0,pc
++ *[0-9a-f]*:  ef a7 88 20     mvrc\.w cp4,cr8,r7
++ *[0-9a-f]*:  ef a8 67 20     mvrc\.w cp3,cr7,r8
++
++[0-9a-f]* <mvrc_d>:
++ *[0-9a-f]*:  ef ae ee 30     mvrc\.d cp7,cr14,lr
++ *[0-9a-f]*:  ef a0 00 30     mvrc\.d cp0,cr0,r0
++ *[0-9a-f]*:  ef ae 0e 30     mvrc\.d cp0,cr14,lr
++ *[0-9a-f]*:  ef a0 ee 30     mvrc\.d cp7,cr14,r0
++ *[0-9a-f]*:  ef ae e0 30     mvrc\.d cp7,cr0,lr
++ *[0-9a-f]*:  ef a6 88 30     mvrc\.d cp4,cr8,r6
++ *[0-9a-f]*:  ef a8 66 30     mvrc\.d cp3,cr6,r8
++
++[0-9a-f]* <bfexts>:
++ *[0-9a-f]*:  ff df b3 ff     bfexts pc,pc,0x1f,0x1f
++ *[0-9a-f]*:  e1 d0 b0 00     bfexts r0,r0,0x0,0x0
++ *[0-9a-f]*:  e1 df b3 ff     bfexts r0,pc,0x1f,0x1f
++ *[0-9a-f]*:  ff d0 b3 ff     bfexts pc,r0,0x1f,0x1f
++ *[0-9a-f]*:  ff df b0 1f     bfexts pc,pc,0x0,0x1f
++ *[0-9a-f]*:  ff df b3 e0     bfexts pc,pc,0x1f,0x0
++ *[0-9a-f]*:  ef d8 b1 f0     bfexts r7,r8,0xf,0x10
++ *[0-9a-f]*:  f1 d7 b2 0f     bfexts r8,r7,0x10,0xf
++
++[0-9a-f]* <bfextu>:
++ *[0-9a-f]*:  ff df c3 ff     bfextu pc,pc,0x1f,0x1f
++ *[0-9a-f]*:  e1 d0 c0 00     bfextu r0,r0,0x0,0x0
++ *[0-9a-f]*:  e1 df c3 ff     bfextu r0,pc,0x1f,0x1f
++ *[0-9a-f]*:  ff d0 c3 ff     bfextu pc,r0,0x1f,0x1f
++ *[0-9a-f]*:  ff df c0 1f     bfextu pc,pc,0x0,0x1f
++ *[0-9a-f]*:  ff df c3 e0     bfextu pc,pc,0x1f,0x0
++ *[0-9a-f]*:  ef d8 c1 f0     bfextu r7,r8,0xf,0x10
++ *[0-9a-f]*:  f1 d7 c2 0f     bfextu r8,r7,0x10,0xf
++
++[0-9a-f]* <bfins>:
++ *[0-9a-f]*:  ff df d3 ff     bfins pc,pc,0x1f,0x1f
++ *[0-9a-f]*:  e1 d0 d0 00     bfins r0,r0,0x0,0x0
++ *[0-9a-f]*:  e1 df d3 ff     bfins r0,pc,0x1f,0x1f
++ *[0-9a-f]*:  ff d0 d3 ff     bfins pc,r0,0x1f,0x1f
++ *[0-9a-f]*:  ff df d0 1f     bfins pc,pc,0x0,0x1f
++ *[0-9a-f]*:  ff df d3 e0     bfins pc,pc,0x1f,0x0
++ *[0-9a-f]*:  ef d8 d1 f0     bfins r7,r8,0xf,0x10
++ *[0-9a-f]*:  f1 d7 d2 0f     bfins r8,r7,0x10,0xf
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/allinsn.exp binutils-2.17-atmel/gas/testsuite/gas/avr32/allinsn.exp
+--- binutils-2.17/gas/testsuite/gas/avr32/allinsn.exp  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/allinsn.exp    2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,5 @@
++# AVR32 assembler testsuite. -*- Tcl -*-
++
++if [istarget avr32-*-*] {
++    run_dump_test "allinsn"
++}
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/allinsn.s binutils-2.17-atmel/gas/testsuite/gas/avr32/allinsn.s
+--- binutils-2.17/gas/testsuite/gas/avr32/allinsn.s    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/allinsn.s      2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,3242 @@
++ .data
++foodata: .word 42
++ .text
++footext:
++      .text
++      .global ld_d5
++ld_d5:
++      ld.d lr,pc[pc<<3]
++      ld.d r0,r0[r0<<0]
++      ld.d r6,r5[r5<<2]
++      ld.d r4,r4[r4<<1]
++      ld.d lr,lr[lr<<1]
++      ld.d r10,r3[sp<<2]
++      ld.d r8,r10[r6<<2]
++      ld.d r2,r7[r9<<0]
++      .text
++      .global ld_w5
++ld_w5:
++      ld.w pc,pc[pc<<0]
++      ld.w r12,r12[r12<<3]
++      ld.w r5,r5[r5<<2]
++      ld.w r4,r4[r4<<1]
++      ld.w lr,lr[lr<<1]
++      ld.w r2,r9[r9<<0]
++      ld.w r11,r2[r6<<0]
++      ld.w r0,r2[sp<<3]
++      .text
++      .global ld_sh5
++ld_sh5:
++      ld.sh pc,pc[pc<<0]
++      ld.sh r12,r12[r12<<3]
++      ld.sh r5,r5[r5<<2]
++      ld.sh r4,r4[r4<<1]
++      ld.sh lr,lr[lr<<1]
++      ld.sh r11,r0[pc<<2]
++      ld.sh r10,sp[r6<<2]
++      ld.sh r12,r2[r2<<0]
++      .text
++      .global ld_uh5
++ld_uh5:
++      ld.uh pc,pc[pc<<0]
++      ld.uh r12,r12[r12<<3]
++      ld.uh r5,r5[r5<<2]
++      ld.uh r4,r4[r4<<1]
++      ld.uh lr,lr[lr<<1]
++      ld.uh r8,pc[lr<<3]
++      ld.uh r6,r1[pc<<1]
++      ld.uh r6,lr[sp<<1]
++      .text
++      .global ld_sb2
++ld_sb2:
++      ld.sb pc,pc[pc<<0]
++      ld.sb r12,r12[r12<<3]
++      ld.sb r5,r5[r5<<2]
++      ld.sb r4,r4[r4<<1]
++      ld.sb lr,lr[lr<<1]
++      ld.sb r9,r1[pc<<3]
++      ld.sb r0,r3[r11<<1]
++      ld.sb r10,r5[r5<<1]
++      .text
++      .global ld_ub5
++ld_ub5:
++      ld.ub pc,pc[pc<<0]
++      ld.ub r12,r12[r12<<3]
++      ld.ub r5,r5[r5<<2]
++      ld.ub r4,r4[r4<<1]
++      ld.ub lr,lr[lr<<1]
++      ld.ub r6,r12[r7<<3]
++      ld.ub r2,r6[r12<<0]
++      ld.ub r0,r7[r11<<1]
++      .text
++      .global st_d5
++st_d5:
++      st.d pc[pc<<0],r14
++      st.d r12[r12<<3],r12
++      st.d r5[r5<<2],r6
++      st.d r4[r4<<1],r4
++      st.d lr[lr<<1],lr
++      st.d r1[r9<<1],r4
++      st.d r10[r2<<1],r4
++      st.d r12[r6<<0],lr
++      .text
++      .global st_w5
++st_w5:
++      st.w pc[pc<<0],pc
++      st.w r12[r12<<3],r12
++      st.w r5[r5<<2],r5
++      st.w r4[r4<<1],r4
++      st.w lr[lr<<1],lr
++      st.w r1[r10<<0],r3
++      st.w r0[r10<<1],r9
++      st.w r4[r5<<3],pc
++      .text
++      .global st_h5
++st_h5:
++      st.h pc[pc<<0],pc
++      st.h r12[r12<<3],r12
++      st.h r5[r5<<2],r5
++      st.h r4[r4<<1],r4
++      st.h lr[lr<<1],lr
++      st.h r2[r9<<0],r11
++      st.h r5[r1<<2],r12
++      st.h pc[r8<<2],r3
++      .text
++      .global st_b5
++st_b5:
++      st.b pc[pc<<0],pc
++      st.b r12[r12<<3],r12
++      st.b r5[r5<<2],r5
++      st.b r4[r4<<1],r4
++      st.b lr[lr<<1],lr
++      st.b r1[r8<<1],r6
++      st.b lr[lr<<3],r1
++      st.b r5[r0<<2],pc
++      .text
++      .global divs
++divs:
++      divs pc,pc,pc
++      divs r12,r12,r12
++      divs r5,r5,r5
++      divs r4,r4,r4
++      divs lr,lr,lr
++      divs r3,pc,pc
++      divs r9,r12,r2
++      divs r7,r4,r1
++      .text
++      .global add1
++add1:
++      add pc,pc
++      add r12,r12
++      add r5,r5
++      add r4,r4
++      add lr,lr
++      add r12,r9
++      add r6,r3
++      add r10,r12
++      .text
++      .global sub1
++sub1:
++      sub pc,pc
++      sub r12,r12
++      sub r5,r5
++      sub r4,r4
++      sub lr,lr
++      sub lr,r6
++      sub r0,sp
++      sub r6,r12
++      .text
++      .global rsub1
++rsub1:
++      rsub pc,pc
++      rsub r12,r12
++      rsub r5,r5
++      rsub r4,r4
++      rsub lr,lr
++      rsub r11,sp
++      rsub r7,r4
++      rsub r9,r1
++      .text
++      .global cp1
++cp1:
++      cp pc,pc
++      cp r12,r12
++      cp r5,r5
++      cp r4,r4
++      cp lr,lr
++      cp r6,r2
++      cp r0,r9
++      cp r3,sp
++      .text
++      .global or1
++or1:
++      or pc,pc
++      or r12,r12
++      or r5,r5
++      or r4,r4
++      or lr,lr
++      or r4,r9
++      or r11,r4
++      or r4,r0
++      .text
++      .global eor1
++eor1:
++      eor pc,pc
++      eor r12,r12
++      eor r5,r5
++      eor r4,r4
++      eor lr,lr
++      eor r12,r11
++      eor r0,r1
++      eor r5,pc
++      .text
++      .global and1
++and1:
++      and pc,pc
++      and r12,r12
++      and r5,r5
++      and r4,r4
++      and lr,lr
++      and r8,r1
++      and r0,sp
++      and r10,r5
++      .text
++      .global tst
++tst:
++      tst pc,pc
++      tst r12,r12
++      tst r5,r5
++      tst r4,r4
++      tst lr,lr
++      tst r0,r12
++      tst r10,r6
++      tst sp,r4
++      .text
++      .global andn
++andn:
++      andn pc,pc
++      andn r12,r12
++      andn r5,r5
++      andn r4,r4
++      andn lr,lr
++      andn r9,r12
++      andn r11,sp
++      andn r12,r5
++      .text
++      .global mov3
++mov3:
++      mov pc,pc
++      mov r12,r12
++      mov r5,r5
++      mov r4,r4
++      mov lr,lr
++      mov r5,r9
++      mov r11,r11
++      mov r2,lr
++      .text
++      .global st_w1
++st_w1:
++      st.w pc++,pc
++      st.w r12++,r12
++      st.w r5++,r5
++      st.w r4++,r4
++      st.w lr++,lr
++      st.w r1++,r11
++      st.w sp++,r0
++      st.w sp++,r1
++      .text
++      .global st_h1
++st_h1:
++      st.h pc++,pc
++      st.h r12++,r12
++      st.h r5++,r5
++      st.h r4++,r4
++      st.h lr++,lr
++      st.h r12++,sp
++      st.h r7++,lr
++      st.h r7++,r4
++      .text
++      .global st_b1
++st_b1:
++      st.b pc++,pc
++      st.b r12++,r12
++      st.b r5++,r5
++      st.b r4++,r4
++      st.b lr++,lr
++      st.b r9++,sp
++      st.b r1++,sp
++      st.b r0++,r4
++      .text
++      .global st_w2
++st_w2:
++      st.w --pc,pc
++      st.w --r12,r12
++      st.w --r5,r5
++      st.w --r4,r4
++      st.w --lr,lr
++      st.w --r1,r7
++      st.w --r3,r9
++      st.w --r5,r5
++      .text
++      .global st_h2
++st_h2:
++      st.h --pc,pc
++      st.h --r12,r12
++      st.h --r5,r5
++      st.h --r4,r4
++      st.h --lr,lr
++      st.h --r5,r7
++      st.h --r8,r8
++      st.h --r7,r2
++      .text
++      .global st_b2
++st_b2:
++      st.b --pc,pc
++      st.b --r12,r12
++      st.b --r5,r5
++      st.b --r4,r4
++      st.b --lr,lr
++      st.b --sp,sp
++      st.b --sp,r11
++      st.b --r4,r5
++      .text
++      .global ld_w1
++ld_w1:
++      ld.w pc,pc++
++      ld.w r12,r12++
++      ld.w r5,r5++
++      ld.w r4,r4++
++      ld.w lr,lr++
++      ld.w r3,r7++
++      ld.w r3,lr++
++      ld.w r12,r5++
++      .text
++      .global ld_sh1
++ld_sh1:
++      ld.sh pc,pc++
++      ld.sh r12,r12++
++      ld.sh r5,r5++
++      ld.sh r4,r4++
++      ld.sh lr,lr++
++      ld.sh r11,r2++
++      ld.sh r2,r8++
++      ld.sh r7,r6++
++      .text
++      .global ld_uh1
++ld_uh1:
++      ld.uh pc,pc++
++      ld.uh r12,r12++
++      ld.uh r5,r5++
++      ld.uh r4,r4++
++      ld.uh lr,lr++
++      ld.uh r6,r7++
++      ld.uh r10,r11++
++      ld.uh lr,r4++
++      .text
++      .global ld_ub1
++ld_ub1:
++      ld.ub pc,pc++
++      ld.ub r12,r12++
++      ld.ub r5,r5++
++      ld.ub r4,r4++
++      ld.ub lr,lr++
++      ld.ub r8,lr++
++      ld.ub r12,r12++
++      ld.ub r11,r10++
++      .text
++      .global ld_w2
++ld_w2:
++      ld.w pc,--pc
++      ld.w r12,--r12
++      ld.w r5,--r5
++      ld.w r4,--r4
++      ld.w lr,--lr
++      ld.w r10,--lr
++      ld.w r12,--r9
++      ld.w r6,--r5
++      .text
++      .global ld_sh2
++ld_sh2:
++      ld.sh pc,--pc
++      ld.sh r12,--r12
++      ld.sh r5,--r5
++      ld.sh r4,--r4
++      ld.sh lr,--lr
++      ld.sh pc,--r10
++      ld.sh r6,--r3
++      ld.sh r4,--r6
++      .text
++      .global ld_uh2
++ld_uh2:
++      ld.uh pc,--pc
++      ld.uh r12,--r12
++      ld.uh r5,--r5
++      ld.uh r4,--r4
++      ld.uh lr,--lr
++      ld.uh r3,--r2
++      ld.uh r1,--r0
++      ld.uh r2,--r9
++      .text
++      .global ld_ub2
++ld_ub2:
++      ld.ub pc,--pc
++      ld.ub r12,--r12
++      ld.ub r5,--r5
++      ld.ub r4,--r4
++      ld.ub lr,--lr
++      ld.ub r1,--r1
++      ld.ub r0,--r6
++      ld.ub r2,--r7
++      .text
++      .global ld_ub3
++ld_ub3:
++      ld.ub pc,pc[0]
++      ld.ub r12,r12[7]
++      ld.ub r5,r5[4]
++      ld.ub r4,r4[3]
++      ld.ub lr,lr[1]
++      ld.ub r6,r9[6]
++      ld.ub r2,lr[4]
++      ld.ub r1,r8[0]
++      .text
++      .global sub3_sp
++sub3_sp:
++      sub sp,0
++      sub sp,-4
++      sub sp,-512
++      sub sp,508
++      sub sp,4
++      sub sp,44
++      sub sp,8
++      sub sp,348
++      .text
++      .global sub3
++sub3:
++      sub pc,0
++      sub r12,-1
++      sub r5,-128
++      sub r4,127
++      sub lr,1
++      sub r6,-41
++      sub r4,37
++      sub r12,56
++      .text
++      .global mov1
++mov1:
++      mov pc,0
++      mov r12,-1
++      mov r5,-128
++      mov r4,127
++      mov lr,1
++      mov pc,14
++      mov r6,-100
++      mov lr,-122
++      .text
++      .global lddsp
++lddsp:
++      lddsp pc,sp[0]
++      lddsp r12,sp[508]
++      lddsp r5,sp[256]
++      lddsp r4,sp[252]
++      lddsp lr,sp[4]
++      lddsp lr,sp[256]
++      lddsp r12,sp[20]
++      lddsp r9,sp[472]
++      .text
++      .global lddpc
++lddpc:
++      lddpc pc,pc[0]
++      lddpc r0,pc[508]
++      lddpc r8,pc[256]
++      lddpc r7,pc[252]
++      lddpc lr,pc[4]
++      lddpc sp,pc[472]
++      lddpc r6,pc[120]
++      lddpc r11,pc[28]
++      .text
++      .global stdsp
++stdsp:
++      stdsp sp[0],pc
++      stdsp sp[508],r12
++      stdsp sp[256],r5
++      stdsp sp[252],r4
++      stdsp sp[4],lr
++      stdsp sp[304],pc
++      stdsp sp[256],r0
++      stdsp sp[336],r5
++      .text
++      .global cp2
++cp2:
++      cp pc,0
++      cp r12,-1
++      cp r5,-32
++      cp r4,31
++      cp lr,1
++      cp r8,3
++      cp lr,16
++      cp r7,-26
++      .text
++      .global acr
++acr:
++      acr pc
++      acr r12
++      acr r5
++      acr r4
++      acr lr
++      acr r2
++      acr r12
++      acr pc
++      .text
++      .global scr
++scr:
++      scr pc
++      scr r12
++      scr r5
++      scr r4
++      scr lr
++      scr pc
++      scr r6
++      scr r1
++      .text
++      .global cpc0
++cpc0:
++      cpc pc
++      cpc r12
++      cpc r5
++      cpc r4
++      cpc lr
++      cpc pc
++      cpc r4
++      cpc r9
++      .text
++      .global neg
++neg:
++      neg pc
++      neg r12
++      neg r5
++      neg r4
++      neg lr
++      neg r7
++      neg r1
++      neg r9
++      .text
++      .global abs
++abs:
++      abs pc
++      abs r12
++      abs r5
++      abs r4
++      abs lr
++      abs r6
++      abs r6
++      abs r4
++      .text
++      .global castu_b
++castu_b:
++      castu.b pc
++      castu.b r12
++      castu.b r5
++      castu.b r4
++      castu.b lr
++      castu.b r7
++      castu.b sp
++      castu.b r9
++      .text
++      .global casts_b
++casts_b:
++      casts.b pc
++      casts.b r12
++      casts.b r5
++      casts.b r4
++      casts.b lr
++      casts.b r11
++      casts.b r1
++      casts.b r10
++      .text
++      .global castu_h
++castu_h:
++      castu.h pc
++      castu.h r12
++      castu.h r5
++      castu.h r4
++      castu.h lr
++      castu.h r10
++      castu.h r11
++      castu.h r1
++      .text
++      .global casts_h
++casts_h:
++      casts.h pc
++      casts.h r12
++      casts.h r5
++      casts.h r4
++      casts.h lr
++      casts.h r0
++      casts.h r5
++      casts.h r9
++      .text
++      .global brev
++brev:
++      brev pc
++      brev r12
++      brev r5
++      brev r4
++      brev lr
++      brev r5
++      brev r10
++      brev r8
++      .text
++      .global swap_h
++swap_h:
++      swap.h pc
++      swap.h r12
++      swap.h r5
++      swap.h r4
++      swap.h lr
++      swap.h r7
++      swap.h r0
++      swap.h r8
++      .text
++      .global swap_b
++swap_b:
++      swap.b pc
++      swap.b r12
++      swap.b r5
++      swap.b r4
++      swap.b lr
++      swap.b r10
++      swap.b r12
++      swap.b r1
++      .text
++      .global swap_bh
++swap_bh:
++      swap.bh pc
++      swap.bh r12
++      swap.bh r5
++      swap.bh r4
++      swap.bh lr
++      swap.bh r9
++      swap.bh r4
++      swap.bh r1
++      .text
++      .global One_s_compliment
++One_s_compliment:
++      com pc
++      com r12
++      com r5
++      com r4
++      com lr
++      com r2
++      com r2
++      com r7
++      .text
++      .global tnbz
++tnbz:
++      tnbz pc
++      tnbz r12
++      tnbz r5
++      tnbz r4
++      tnbz lr
++      tnbz r8
++      tnbz r12
++      tnbz pc
++      .text
++      .global rol
++rol:
++      rol pc
++      rol r12
++      rol r5
++      rol r4
++      rol lr
++      rol r10
++      rol r9
++      rol r5
++      .text
++      .global ror
++ror:
++      ror pc
++      ror r12
++      ror r5
++      ror r4
++      ror lr
++      ror r8
++      ror r4
++      ror r7
++      .text
++      .global icall
++icall:
++      icall pc
++      icall r12
++      icall r5
++      icall r4
++      icall lr
++      icall r3
++      icall r1
++      icall r3
++      .text
++      .global mustr
++mustr:
++      mustr pc
++      mustr r12
++      mustr r5
++      mustr r4
++      mustr lr
++      mustr r1
++      mustr r4
++      mustr r12
++      .text
++      .global musfr
++musfr:
++      musfr pc
++      musfr r12
++      musfr r5
++      musfr r4
++      musfr lr
++      musfr r11
++      musfr r12
++      musfr r2
++      .text
++      .global ret_cond
++ret_cond:
++      reteq pc
++      retal r12
++      retls r5
++      retpl r4
++      retne lr
++      retgt r0
++      retgt r12
++      retge r10
++      .text
++      .global sr_cond
++sr_cond:
++      sreq pc
++      sral r12
++      srls r5
++      srpl r4
++      srne lr
++      srlt r0
++      sral sp
++      srge r9
++      .text
++      .global ld_w3
++ld_w3:
++      ld.w pc,pc[0]
++      ld.w r12,r12[124]
++      ld.w r5,r5[64]
++      ld.w r4,r4[60]
++      ld.w lr,lr[4]
++      ld.w sp,r2[52]
++      ld.w r9,r1[8]
++      ld.w r5,sp[60]
++      .text
++      .global ld_sh3
++ld_sh3:
++      ld.sh pc,pc[0]
++      ld.sh r12,r12[14]
++      ld.sh r5,r5[8]
++      ld.sh r4,r4[6]
++      ld.sh lr,lr[2]
++      ld.sh r4,r2[8]
++      ld.sh sp,lr[10]
++      ld.sh r2,r11[2]
++      .text
++      .global ld_uh3
++ld_uh3:
++      ld.uh pc,pc[0]
++      ld.uh r12,r12[14]
++      ld.uh r5,r5[8]
++      ld.uh r4,r4[6]
++      ld.uh lr,lr[2]
++      ld.uh r10,r0[10]
++      ld.uh r8,r11[8]
++      ld.uh r10,r2[12]
++      .text
++      .global st_w3
++st_w3:
++      st.w pc[0],pc
++      st.w r12[60],r12
++      st.w r5[32],r5
++      st.w r4[28],r4
++      st.w lr[4],lr
++      st.w r7[44],r11
++      st.w r2[24],r6
++      st.w r4[12],r9
++      .text
++      .global st_h3
++st_h3:
++      st.h pc[0],pc
++      st.h r12[14],r12
++      st.h r5[8],r5
++      st.h r4[6],r4
++      st.h lr[2],lr
++      st.h lr[10],r12
++      st.h r6[4],r0
++      st.h r5[12],sp
++      .text
++      .global st_b3
++st_b3:
++      st.b pc[0],pc
++      st.b r12[7],r12
++      st.b r5[4],r5
++      st.b r4[3],r4
++      st.b lr[1],lr
++      st.b r12[6],r9
++      st.b r2[3],lr
++      st.b r1[3],r11
++      .text
++      .global ldd
++ldd:
++      ld.d r0,pc
++      ld.d r14,r12
++      ld.d r8,r5
++      ld.d r6,r4
++      ld.d r2,lr
++      ld.d r14,r7
++      ld.d r4,r4
++      ld.d r14,pc
++      .text
++      .global ldd_postinc
++ldd_postinc:
++      ld.d r0,pc++
++      ld.d r14,r12++
++      ld.d r8,r5++
++      ld.d r6,r4++
++      ld.d r2,lr++
++      ld.d r14,r5++
++      ld.d r12,r11++
++      ld.d r2,r12++
++      .text
++      .global ldd_predec
++ldd_predec:
++      ld.d r0,--pc
++      ld.d r14,--r12
++      ld.d r8,--r5
++      ld.d r6,--r4
++      ld.d r2,--lr
++      ld.d r8,--r0
++      ld.d r10,--pc
++      ld.d r2,--r4
++      .text
++      .global std
++std:
++      st.d pc,r0
++      st.d r12,r14
++      st.d r5,r8
++      st.d r4,r6
++      st.d lr,r2
++      st.d r0,r12
++      st.d sp,r4
++      st.d r12,r12
++      .text
++      .global std_postinc
++std_postinc:
++      st.d pc++,r0
++      st.d r12++,r14
++      st.d r5++,r8
++      st.d r4++,r6
++      st.d lr++,r2
++      st.d sp++,r6
++      st.d r10++,r6
++      st.d r7++,r2
++      .text
++      .global std_predec
++std_predec:
++      st.d --pc,r0
++      st.d --r12,r14
++      st.d --r5,r8
++      st.d --r4,r6
++      st.d --lr,r2
++      st.d --r3,r6
++      st.d --lr,r2
++      st.d --r0,r4
++      .text
++      .global mul
++mul:
++      mul pc,pc
++      mul r12,r12
++      mul r5,r5
++      mul r4,r4
++      mul lr,lr
++      mul r10,lr
++      mul r0,r8
++      mul r8,r5
++      .text
++      .global asr_imm5
++asr_imm5:
++      asr pc,0
++      asr r12,31
++      asr r5,16
++      asr r4,15
++      asr lr,1
++      asr r6,23
++      asr r6,18
++      asr r5,8
++      .text
++      .global lsl_imm5
++lsl_imm5:
++      lsl pc,0
++      lsl r12,31
++      lsl r5,16
++      lsl r4,15
++      lsl lr,1
++      lsl r12,13
++      lsl r6,16
++      lsl r1,25
++      .text
++      .global lsr_imm5
++lsr_imm5:
++      lsr pc,0
++      lsr r12,31
++      lsr r5,16
++      lsr r4,15
++      lsr lr,1
++      lsr r0,1
++      lsr r8,10
++      lsr r7,26
++      .text
++      .global sbr
++sbr:
++      sbr pc,0
++      sbr r12,31
++      sbr r5,16
++      sbr r4,15
++      sbr lr,1
++      sbr r8,31
++      sbr r6,22
++      sbr r1,23
++      .text
++      .global cbr
++cbr:
++      cbr pc,0
++      cbr r12,31
++      cbr r5,16
++      cbr r4,15
++      cbr lr,1
++      cbr r12,10
++      cbr r7,22
++      cbr r8,9
++      .text
++      .global brc1
++brc1:
++      breq 0
++      brpl -2
++      brge -256
++      brcs 254
++      brne 2
++      brcs 230
++      breq -18
++      breq 12
++      .text
++      .global rjmp
++rjmp:
++      rjmp 0
++      rjmp -2
++      rjmp -1024
++      rjmp 1022
++      rjmp 2
++      rjmp -962
++      rjmp 14
++      rjmp -516
++      .text
++      .global rcall1
++rcall1:
++      rcall 0
++      rcall -2
++      rcall -1024
++      rcall 1022
++      rcall 2
++      rcall 216
++      rcall -530
++      rcall -972
++      .text
++      .global acall
++acall:
++      acall 0
++      acall 1020
++      acall 512
++      acall 508
++      acall 4
++      acall 356
++      acall 304
++      acall 172
++      .text
++      .global scall
++scall:
++      scall
++      scall
++      scall
++      scall
++      scall
++      scall
++      scall
++      scall
++      .text
++      .global popm
++popm:
++      /* popm with no argument fails currently */
++      popm pc
++      popm r0-r11,pc,r12=-1
++      popm lr
++      popm r0-r11,pc,r12=1
++      popm r0-r3
++      popm r4-r10,pc
++      popm r0-r3,r11,pc,r12=0
++      popm r0-r7,r10-r12,lr
++      .text
++      .global pushm
++pushm:
++      pushm pc
++      pushm r0-r12,lr,pc
++      pushm pc
++      pushm r0-r12,lr
++      pushm r0-r3
++      pushm r8-r10,lr,pc
++      pushm r0-r3,r10
++      pushm r8-r9,r12
++      .text
++      .global popm_n
++popm_n:
++      popm pc
++      popm r0-r11,pc,r12=-1
++      popm lr
++      popm r0-r11,pc,r12=1
++      popm r0-r3
++      popm r4-r10,pc
++      popm r0-r3,r11,pc,r12=0
++      popm r0-r7,r10-r12,lr
++      .text
++      .global pushm_n
++pushm_n:
++      pushm pc
++      pushm r0-r12,lr,pc
++      pushm pc
++      pushm r0-r12,lr
++      pushm r0-r3
++      pushm r8-r10,lr,pc
++      pushm r0-r3,r10
++      pushm r8-r9,r12
++      .text
++      .global csrfcz
++csrfcz:
++      csrfcz 0
++      csrfcz 31
++      csrfcz 16
++      csrfcz 15
++      csrfcz 1
++      csrfcz 5
++      csrfcz 13
++      csrfcz 23
++      .text
++      .global ssrf
++ssrf:
++      ssrf 0
++      ssrf 31
++      ssrf 16
++      ssrf 15
++      ssrf 1
++      ssrf 29
++      ssrf 13
++      ssrf 13
++      .text
++      .global csrf
++csrf:
++      csrf 0
++      csrf 31
++      csrf 16
++      csrf 15
++      csrf 1
++      csrf 10
++      csrf 15
++      csrf 11
++      .text
++      .global rete
++rete:
++      rete
++      .text
++      .global rets
++rets:
++      rets
++      .text
++      .global retd
++retd:
++      retd
++      .text
++      .global retj
++retj:
++      retj
++      .text
++      .global tlbr
++tlbr:
++      tlbr
++      .text
++      .global tlbs
++tlbs:
++      tlbs
++      .text
++      .global tlbw
++tlbw:
++      tlbw
++      .text
++      .global breakpoint
++breakpoint:
++      breakpoint
++      .text
++      .global incjosp
++incjosp:
++      incjosp 1
++      incjosp 2
++      incjosp 3
++      incjosp 4
++      incjosp -4
++      incjosp -3
++      incjosp -2
++      incjosp -1
++      .text
++      .global nop
++nop:
++      nop
++      .text
++      .global popjc
++popjc:
++      popjc
++      .text
++      .global pushjc
++pushjc:
++      pushjc
++      .text
++      .global add2
++add2:
++      add pc,pc,pc<<0
++      add r12,r12,r12<<3
++      add r5,r5,r5<<2
++      add r4,r4,r4<<1
++      add lr,lr,lr<<1
++      add r0,r12,r0<<1
++      add r9,r12,r4<<0
++      add r12,r12,r7<<2
++      .text
++      .global sub2
++sub2:
++      sub pc,pc,pc<<0
++      sub r12,r12,r12<<3
++      sub r5,r5,r5<<2
++      sub r4,r4,r4<<1
++      sub lr,lr,lr<<1
++      sub sp,r3,r4<<0
++      sub r3,r7,r3<<0
++      sub sp,r10,sp<<1
++      .text
++      .global divu
++divu:
++      divu pc,pc,pc
++      divu r12,r12,r12
++      divu r5,r5,r5
++      divu r4,r4,r4
++      divu lr,lr,lr
++      divu sp,r4,pc
++      divu r5,r5,sp
++      divu r10,sp,r0
++      .text
++      .global addhh_w
++addhh_w:
++      addhh.w pc,pc:b,pc:b
++      addhh.w r12,r12:t,r12:t
++      addhh.w r5,r5:t,r5:t
++      addhh.w r4,r4:b,r4:b
++      addhh.w lr,lr:t,lr:t
++      addhh.w r0,r0:b,r3:b
++      addhh.w lr,r12:t,r7:b
++      addhh.w r3,r10:t,r2:b
++      .text
++      .global subhh_w
++subhh_w:
++      subhh.w pc,pc:b,pc:b
++      subhh.w r12,r12:t,r12:t
++      subhh.w r5,r5:t,r5:t
++      subhh.w r4,r4:b,r4:b
++      subhh.w lr,lr:t,lr:t
++      subhh.w r10,r1:t,r7:b
++      subhh.w pc,r10:t,lr:t
++      subhh.w r3,r0:t,r12:b
++      .text
++      .global adc
++adc:
++      adc pc,pc,pc
++      adc r12,r12,r12
++      adc r5,r5,r5
++      adc r4,r4,r4
++      adc lr,lr,lr
++      adc r4,r0,r7
++      adc sp,r4,r3
++      adc r2,r12,r0
++      .text
++      .global sbc
++sbc:
++      sbc pc,pc,pc
++      sbc r12,r12,r12
++      sbc r5,r5,r5
++      sbc r4,r4,r4
++      sbc lr,lr,lr
++      sbc r6,r7,r9
++      sbc r0,r8,r5
++      sbc r1,r0,r4
++      .text
++      .global mul_2
++mul_2:
++      mul pc,pc,pc
++      mul r12,r12,r12
++      mul r5,r5,r5
++      mul r4,r4,r4
++      mul lr,lr,lr
++      mul pc,r0,r0
++      mul r8,pc,lr
++      mul r4,r12,pc
++      .text
++      .global mac
++mac:
++      mac pc,pc,pc
++      mac r12,r12,r12
++      mac r5,r5,r5
++      mac r4,r4,r4
++      mac lr,lr,lr
++      mac r10,r4,r0
++      mac r7,lr,r0
++      mac r2,r9,r12
++      .text
++      .global mulsd
++mulsd:
++      muls.d pc,pc,pc
++      muls.d r12,r12,r12
++      muls.d r5,r5,r5
++      muls.d r4,r4,r4
++      muls.d lr,lr,lr
++      muls.d r2,r8,lr
++      muls.d r4,r0,r11
++      muls.d r5,lr,r6
++      .text
++      .global macsd
++macsd:
++      macs.d r0,pc,pc
++      macs.d r14,r12,r12
++      macs.d r8,r5,r5
++      macs.d r6,r4,r4
++      macs.d r2,lr,lr
++      macs.d r8,r1,r9
++      macs.d r14,r8,r8
++      macs.d r4,r3,r12
++      .text
++      .global mulud
++mulud:
++      mulu.d r0,pc,pc
++      mulu.d r14,r12,r12
++      mulu.d r8,r5,r5
++      mulu.d r6,r4,r4
++      mulu.d r2,lr,lr
++      mulu.d r6,r5,r0
++      mulu.d r4,r6,r1
++      mulu.d r8,r8,r2
++      .text
++      .global macud
++macud:
++      macu.d r0,pc,pc
++      macu.d r14,r12,r12
++      macu.d r8,r5,r5
++      macu.d r6,r4,r4
++      macu.d r2,lr,lr
++      macu.d r6,sp,r11
++      macu.d r2,r4,r8
++      macu.d r6,r10,r9
++      .text
++      .global asr_1
++asr_1:
++      asr pc,pc,pc
++      asr r12,r12,r12
++      asr r5,r5,r5
++      asr r4,r4,r4
++      asr lr,lr,lr
++      asr pc,r6,pc
++      asr r0,r6,r12
++      asr r4,sp,r0
++      .text
++      .global lsl_1
++lsl_1:
++      lsl pc,pc,pc
++      lsl r12,r12,r12
++      lsl r5,r5,r5
++      lsl r4,r4,r4
++      lsl lr,lr,lr
++      lsl lr,r5,lr
++      lsl r5,pc,r3
++      lsl r1,pc,r9
++      .text
++      .global lsr_1
++lsr_1:
++      lsr pc,pc,pc
++      lsr r12,r12,r12
++      lsr r5,r5,r5
++      lsr r4,r4,r4
++      lsr lr,lr,lr
++      lsr r2,r4,r1
++      lsr r5,r1,r6
++      lsr sp,r6,r7
++      .text
++      .global xchg
++xchg:
++      xchg pc,pc,pc
++      xchg r12,r12,r12
++      xchg r5,r5,r5
++      xchg r4,r4,r4
++      xchg lr,lr,lr
++      xchg lr,r4,sp
++      xchg r1,r5,r12
++      xchg lr,r12,r0
++      .text
++      .global max
++max:
++      max pc,pc,pc
++      max r12,r12,r12
++      max r5,r5,r5
++      max r4,r4,r4
++      max lr,lr,lr
++      max lr,r2,sp
++      max r4,r10,r9
++      max lr,r9,lr
++      .text
++      .global min
++min:
++      min pc,pc,pc
++      min r12,r12,r12
++      min r5,r5,r5
++      min r4,r4,r4
++      min lr,lr,lr
++      min r9,r7,r8
++      min sp,r5,r5
++      min r4,r1,r4
++      .text
++      .global addabs
++addabs:
++      addabs pc,pc,pc
++      addabs r12,r12,r12
++      addabs r5,r5,r5
++      addabs r4,r4,r4
++      addabs lr,lr,lr
++      addabs r7,r10,r0
++      addabs r9,r9,r7
++      addabs r2,r8,r12
++      .text
++      .global mulnhh_w
++mulnhh_w:
++      mulnhh.w pc,pc:b,pc:b
++      mulnhh.w r12,r12:t,r12:t
++      mulnhh.w r5,r5:t,r5:t
++      mulnhh.w r4,r4:b,r4:b
++      mulnhh.w lr,lr:t,lr:t
++      mulnhh.w r11,sp:t,r9:b
++      mulnhh.w sp,r4:b,lr:t
++      mulnhh.w r12,r2:t,r11:b
++      .text
++      .global mulnwh_d
++mulnwh_d:
++      mulnwh.d r0,pc,pc:b
++      mulnwh.d r14,r12,r12:t
++      mulnwh.d r8,r5,r5:t
++      mulnwh.d r6,r4,r4:b
++      mulnwh.d r2,lr,lr:t
++      mulnwh.d r14,r3,r2:t
++      mulnwh.d r4,r5,r9:b
++      mulnwh.d r12,r4,r4:t
++      .text
++      .global machh_w
++machh_w:
++      machh.w pc,pc:b,pc:b
++      machh.w r12,r12:t,r12:t
++      machh.w r5,r5:t,r5:t
++      machh.w r4,r4:b,r4:b
++      machh.w lr,lr:t,lr:t
++      machh.w lr,r5:b,r1:t
++      machh.w r9,r6:b,r7:b
++      machh.w r5,lr:t,r12:b
++      .text
++      .global machh_d
++machh_d:
++      machh.d r0,pc:b,pc:b
++      machh.d r14,r12:t,r12:t
++      machh.d r8,r5:t,r5:t
++      machh.d r6,r4:b,r4:b
++      machh.d r2,lr:t,lr:t
++      machh.d r10,r0:b,r8:b
++      machh.d r14,r4:b,r5:t
++      machh.d r8,r0:b,r4:t
++      .text
++      .global macsathh_w
++macsathh_w:
++      macsathh.w pc,pc:b,pc:b
++      macsathh.w r12,r12:t,r12:t
++      macsathh.w r5,r5:t,r5:t
++      macsathh.w r4,r4:b,r4:b
++      macsathh.w lr,lr:t,lr:t
++      macsathh.w r7,r7:t,pc:t
++      macsathh.w r4,r2:t,r4:b
++      macsathh.w r4,r8:t,r3:t
++      .text
++      .global mulhh_w
++mulhh_w:
++      mulhh.w pc,pc:b,pc:b
++      mulhh.w r12,r12:t,r12:t
++      mulhh.w r5,r5:t,r5:t
++      mulhh.w r4,r4:b,r4:b
++      mulhh.w lr,lr:t,lr:t
++      mulhh.w r7,r4:t,r9:b
++      mulhh.w pc,r3:t,r7:t
++      mulhh.w pc,r4:b,r9:t
++      .text
++      .global mulsathh_h
++mulsathh_h:
++      mulsathh.h pc,pc:b,pc:b
++      mulsathh.h r12,r12:t,r12:t
++      mulsathh.h r5,r5:t,r5:t
++      mulsathh.h r4,r4:b,r4:b
++      mulsathh.h lr,lr:t,lr:t
++      mulsathh.h r3,r1:b,sp:b
++      mulsathh.h r11,lr:t,r11:b
++      mulsathh.h r8,r8:b,r11:t
++      .text
++      .global mulsathh_w
++mulsathh_w:
++      mulsathh.w pc,pc:b,pc:b
++      mulsathh.w r12,r12:t,r12:t
++      mulsathh.w r5,r5:t,r5:t
++      mulsathh.w r4,r4:b,r4:b
++      mulsathh.w lr,lr:t,lr:t
++      mulsathh.w lr,r11:t,r6:b
++      mulsathh.w r6,r6:b,r7:t
++      mulsathh.w r10,r2:b,r3:b
++      .text
++      .global mulsatrndhh_h
++mulsatrndhh_h:
++      mulsatrndhh.h pc,pc:b,pc:b
++      mulsatrndhh.h r12,r12:t,r12:t
++      mulsatrndhh.h r5,r5:t,r5:t
++      mulsatrndhh.h r4,r4:b,r4:b
++      mulsatrndhh.h lr,lr:t,lr:t
++      mulsatrndhh.h r11,r6:b,r9:b
++      mulsatrndhh.h r11,r3:b,r8:t
++      mulsatrndhh.h r5,sp:t,r7:t
++      .text
++      .global mulsatrndwh_w
++mulsatrndwh_w:
++      mulsatrndwh.w pc,pc,pc:b
++      mulsatrndwh.w r12,r12,r12:t
++      mulsatrndwh.w r5,r5,r5:t
++      mulsatrndwh.w r4,r4,r4:b
++      mulsatrndwh.w lr,lr,lr:t
++      mulsatrndwh.w r5,r12,r0:b
++      mulsatrndwh.w r7,r10,pc:b
++      mulsatrndwh.w r10,r8,r5:t
++      .text
++      .global macwh_d
++macwh_d:
++      macwh.d r0,pc,pc:b
++      macwh.d r14,r12,r12:t
++      macwh.d r8,r5,r5:t
++      macwh.d r6,r4,r4:b
++      macwh.d r2,lr,lr:t
++      macwh.d r4,r10,r12:t
++      macwh.d r4,r7,sp:b
++      macwh.d r14,r9,r11:b
++      .text
++      .global mulwh_d
++mulwh_d:
++      mulwh.d r0,pc,pc:b
++      mulwh.d r14,r12,r12:t
++      mulwh.d r8,r5,r5:t
++      mulwh.d r6,r4,r4:b
++      mulwh.d r2,lr,lr:t
++      mulwh.d r12,r5,r1:b
++      mulwh.d r0,r1,r3:t
++      mulwh.d r0,r9,r2:b
++      .text
++      .global mulsatwh_w
++mulsatwh_w:
++      mulsatwh.w pc,pc,pc:b
++      mulsatwh.w r12,r12,r12:t
++      mulsatwh.w r5,r5,r5:t
++      mulsatwh.w r4,r4,r4:b
++      mulsatwh.w lr,lr,lr:t
++      mulsatwh.w r11,pc,r10:t
++      mulsatwh.w sp,r12,r9:t
++      mulsatwh.w r0,r3,r2:t
++      .text
++      .global ldw7
++ldw7:
++      ld.w pc,pc[pc:b<<2]
++      ld.w r12,r12[r12:t<<2]
++      ld.w r5,r5[r5:u<<2]
++      ld.w r4,r4[r4:l<<2]
++      ld.w lr,lr[lr:l<<2]
++      ld.w r9,r10[r6:l<<2]
++      ld.w r2,r10[r10:b<<2]
++      ld.w r11,r5[pc:b<<2]
++      .text
++      .global satadd_w
++satadd_w:
++      satadd.w pc,pc,pc
++      satadd.w r12,r12,r12
++      satadd.w r5,r5,r5
++      satadd.w r4,r4,r4
++      satadd.w lr,lr,lr
++      satadd.w r4,r8,r11
++      satadd.w r3,r12,r6
++      satadd.w r3,lr,r9
++      .text
++      .global satsub_w1
++satsub_w1:
++      satsub.w pc,pc,pc
++      satsub.w r12,r12,r12
++      satsub.w r5,r5,r5
++      satsub.w r4,r4,r4
++      satsub.w lr,lr,lr
++      satsub.w r8,sp,r0
++      satsub.w r9,r8,r4
++      satsub.w pc,lr,r2
++      .text
++      .global satadd_h
++satadd_h:
++      satadd.h pc,pc,pc
++      satadd.h r12,r12,r12
++      satadd.h r5,r5,r5
++      satadd.h r4,r4,r4
++      satadd.h lr,lr,lr
++      satadd.h r7,r3,r9
++      satadd.h r1,r0,r2
++      satadd.h r1,r4,lr
++      .text
++      .global satsub_h
++satsub_h:
++      satsub.h pc,pc,pc
++      satsub.h r12,r12,r12
++      satsub.h r5,r5,r5
++      satsub.h r4,r4,r4
++      satsub.h lr,lr,lr
++      satsub.h lr,lr,r3
++      satsub.h r11,r6,r5
++      satsub.h r3,sp,r0
++      .text
++      .global mul3
++mul3:
++      mul pc,pc,0
++      mul r12,r12,-1
++      mul r5,r5,-128
++      mul r4,r4,127
++      mul lr,lr,1
++      mul r12,r2,-7
++      mul r1,pc,95
++      mul r4,r6,19
++      .text
++      .global rsub2
++rsub2:
++      rsub pc,pc,0
++      rsub r12,r12,-1
++      rsub r5,r5,-128
++      rsub r4,r4,127
++      rsub lr,lr,1
++      rsub r9,lr,96
++      rsub r11,r1,56
++      rsub r0,r7,-87
++      .text
++      .global clz
++clz:
++      clz pc,pc
++      clz r12,r12
++      clz r5,r5
++      clz r4,r4
++      clz lr,lr
++      clz r2,r3
++      clz r5,r11
++      clz pc,r3
++      .text
++      .global cpc1
++cpc1:
++      cpc pc,pc
++      cpc r12,r12
++      cpc r5,r5
++      cpc r4,r4
++      cpc lr,lr
++      cpc pc,r4
++      cpc r5,r9
++      cpc r6,r7
++      .text
++      .global asr3
++asr3:
++      asr pc,pc,0
++      asr r12,r12,31
++      asr r5,r5,16
++      asr r4,r4,15
++      asr lr,lr,1
++      asr r4,r11,19
++      asr sp,pc,26
++      asr r11,sp,8
++      .text
++      .global lsl3
++lsl3:
++      lsl pc,pc,0
++      lsl r12,r12,31
++      lsl r5,r5,16
++      lsl r4,r4,15
++      lsl lr,lr,1
++      lsl r8,r10,17
++      lsl r2,lr,3
++      lsl lr,r11,14
++      .text
++      .global lsr3
++lsr3:
++      lsr pc,pc,0
++      lsr r12,r12,31
++      lsr r5,r5,16
++      lsr r4,r4,15
++      lsr lr,lr,1
++      lsr r4,r3,31
++      lsr pc,r9,14
++      lsr r3,r0,6
++/*    .text
++      .global extract_b
++extract_b:
++      extract.b pc,pc:b
++      extract.b r12,r12:t
++      extract.b r5,r5:u
++      extract.b r4,r4:l
++      extract.b lr,lr:l
++      extract.b r2,r5:l
++      extract.b r12,r3:l
++      extract.b sp,r3:l
++      .text
++      .global insert_b
++insert_b:
++      insert.b pc:b,pc
++      insert.b r12:t,r12
++      insert.b r5:u,r5
++      insert.b r4:l,r4
++      insert.b lr:l,lr
++      insert.b r12:u,r3
++      insert.b r10:l,lr
++      insert.b r11:l,r12
++      .text
++      .global extract_h
++extract_h:
++      extract.h pc,pc:b
++      extract.h r12,r12:t
++      extract.h r5,r5:t
++      extract.h r4,r4:b
++      extract.h lr,lr:t
++      extract.h r11,lr:b
++      extract.h r10,r0:b
++      extract.h r11,r12:b
++      .text
++      .global insert_h
++insert_h:
++      insert.h pc:b,pc
++      insert.h r12:t,r12
++      insert.h r5:t,r5
++      insert.h r4:b,r4
++      insert.h lr:t,lr
++      insert.h r12:t,r11
++      insert.h r7:b,r6
++      insert.h r1:t,r11 */
++      .text
++      .global movc1
++movc1:
++      moveq pc,pc
++      moval r12,r12
++      movls r5,r5
++      movpl r4,r4
++      movne lr,lr
++      movne pc,r11
++      movmi r10,r2
++      movls r8,r12
++      .text
++      .global padd_h
++padd_h:
++      padd.h pc,pc,pc
++      padd.h r12,r12,r12
++      padd.h r5,r5,r5
++      padd.h r4,r4,r4
++      padd.h lr,lr,lr
++      padd.h r8,r2,r7
++      padd.h r0,r0,r3
++      padd.h sp,r11,r6
++      .text
++      .global psub_h
++psub_h:
++      psub.h pc,pc,pc
++      psub.h r12,r12,r12
++      psub.h r5,r5,r5
++      psub.h r4,r4,r4
++      psub.h lr,lr,lr
++      psub.h lr,r6,r8
++      psub.h r0,r1,sp
++      psub.h pc,pc,sp
++      .text
++      .global paddx_h
++paddx_h:
++      paddx.h pc,pc,pc
++      paddx.h r12,r12,r12
++      paddx.h r5,r5,r5
++      paddx.h r4,r4,r4
++      paddx.h lr,lr,lr
++      paddx.h pc,pc,r1
++      paddx.h r10,r4,r5
++      paddx.h r5,pc,r2
++      .text
++      .global psubx_h
++psubx_h:
++      psubx.h pc,pc,pc
++      psubx.h r12,r12,r12
++      psubx.h r5,r5,r5
++      psubx.h r4,r4,r4
++      psubx.h lr,lr,lr
++      psubx.h r5,r12,r5
++      psubx.h r3,r8,r3
++      psubx.h r5,r2,r3
++      .text
++      .global padds_sh
++padds_sh:
++      padds.sh pc,pc,pc
++      padds.sh r12,r12,r12
++      padds.sh r5,r5,r5
++      padds.sh r4,r4,r4
++      padds.sh lr,lr,lr
++      padds.sh r9,lr,r2
++      padds.sh r6,r8,r1
++      padds.sh r6,r4,r10
++      .text
++      .global psubs_sh
++psubs_sh:
++      psubs.sh pc,pc,pc
++      psubs.sh r12,r12,r12
++      psubs.sh r5,r5,r5
++      psubs.sh r4,r4,r4
++      psubs.sh lr,lr,lr
++      psubs.sh r6,lr,r11
++      psubs.sh r2,r12,r4
++      psubs.sh r0,r9,r0
++      .text
++      .global paddxs_sh
++paddxs_sh:
++      paddxs.sh pc,pc,pc
++      paddxs.sh r12,r12,r12
++      paddxs.sh r5,r5,r5
++      paddxs.sh r4,r4,r4
++      paddxs.sh lr,lr,lr
++      paddxs.sh r0,r3,r9
++      paddxs.sh pc,r10,r11
++      paddxs.sh pc,r10,pc
++      .text
++      .global psubxs_sh
++psubxs_sh:
++      psubxs.sh pc,pc,pc
++      psubxs.sh r12,r12,r12
++      psubxs.sh r5,r5,r5
++      psubxs.sh r4,r4,r4
++      psubxs.sh lr,lr,lr
++      psubxs.sh r7,r4,r4
++      psubxs.sh r7,r8,r3
++      psubxs.sh pc,r6,r5
++      .text
++      .global padds_uh
++padds_uh:
++      padds.uh pc,pc,pc
++      padds.uh r12,r12,r12
++      padds.uh r5,r5,r5
++      padds.uh r4,r4,r4
++      padds.uh lr,lr,lr
++      padds.uh r12,r11,r7
++      padds.uh r7,r8,lr
++      padds.uh r6,r9,r7
++      .text
++      .global psubs_uh
++psubs_uh:
++      psubs.uh pc,pc,pc
++      psubs.uh r12,r12,r12
++      psubs.uh r5,r5,r5
++      psubs.uh r4,r4,r4
++      psubs.uh lr,lr,lr
++      psubs.uh lr,r10,r6
++      psubs.uh sp,r2,pc
++      psubs.uh r2,r9,r2
++      .text
++      .global paddxs_uh
++paddxs_uh:
++      paddxs.uh pc,pc,pc
++      paddxs.uh r12,r12,r12
++      paddxs.uh r5,r5,r5
++      paddxs.uh r4,r4,r4
++      paddxs.uh lr,lr,lr
++      paddxs.uh r7,r9,r5
++      paddxs.uh r9,r1,r4
++      paddxs.uh r5,r2,r3
++      .text
++      .global psubxs_uh
++psubxs_uh:
++      psubxs.uh pc,pc,pc
++      psubxs.uh r12,r12,r12
++      psubxs.uh r5,r5,r5
++      psubxs.uh r4,r4,r4
++      psubxs.uh lr,lr,lr
++      psubxs.uh sp,r5,sp
++      psubxs.uh sp,r6,r6
++      psubxs.uh r3,r11,r8
++      .text
++      .global paddh_sh
++paddh_sh:
++      paddh.sh pc,pc,pc
++      paddh.sh r12,r12,r12
++      paddh.sh r5,r5,r5
++      paddh.sh r4,r4,r4
++      paddh.sh lr,lr,lr
++      paddh.sh r12,sp,r3
++      paddh.sh pc,r5,r3
++      paddh.sh r8,r8,sp
++      .text
++      .global psubh_sh
++psubh_sh:
++      psubh.sh pc,pc,pc
++      psubh.sh r12,r12,r12
++      psubh.sh r5,r5,r5
++      psubh.sh r4,r4,r4
++      psubh.sh lr,lr,lr
++      psubh.sh r1,r5,r8
++      psubh.sh r7,r3,r6
++      psubh.sh r4,r3,r3
++      .text
++      .global paddxh_sh
++paddxh_sh:
++      paddxh.sh pc,pc,pc
++      paddxh.sh r12,r12,r12
++      paddxh.sh r5,r5,r5
++      paddxh.sh r4,r4,r4
++      paddxh.sh lr,lr,lr
++      paddxh.sh r6,r0,r4
++      paddxh.sh r9,r8,r9
++      paddxh.sh r3,r0,sp
++      .text
++      .global psubxh_sh
++psubxh_sh:
++      psubxh.sh pc,pc,pc
++      psubxh.sh r12,r12,r12
++      psubxh.sh r5,r5,r5
++      psubxh.sh r4,r4,r4
++      psubxh.sh lr,lr,lr
++      psubxh.sh r4,pc,r12
++      psubxh.sh r8,r4,r6
++      psubxh.sh r12,r9,r4
++      .text
++      .global paddsub_h
++paddsub_h:
++      paddsub.h pc,pc:b,pc:b
++      paddsub.h r12,r12:t,r12:t
++      paddsub.h r5,r5:t,r5:t
++      paddsub.h r4,r4:b,r4:b
++      paddsub.h lr,lr:t,lr:t
++      paddsub.h r5,r2:t,lr:b
++      paddsub.h r7,r1:b,r8:b
++      paddsub.h r6,r10:t,r5:t
++      .text
++      .global psubadd_h
++psubadd_h:
++      psubadd.h pc,pc:b,pc:b
++      psubadd.h r12,r12:t,r12:t
++      psubadd.h r5,r5:t,r5:t
++      psubadd.h r4,r4:b,r4:b
++      psubadd.h lr,lr:t,lr:t
++      psubadd.h r9,r11:t,r8:t
++      psubadd.h r10,r7:t,lr:t
++      psubadd.h r6,pc:t,pc:b
++      .text
++      .global paddsubs_sh
++paddsubs_sh:
++      paddsubs.sh pc,pc:b,pc:b
++      paddsubs.sh r12,r12:t,r12:t
++      paddsubs.sh r5,r5:t,r5:t
++      paddsubs.sh r4,r4:b,r4:b
++      paddsubs.sh lr,lr:t,lr:t
++      paddsubs.sh r0,lr:t,r0:b
++      paddsubs.sh r9,r2:t,r4:t
++      paddsubs.sh r12,r9:t,sp:t
++      .text
++      .global psubadds_sh
++psubadds_sh:
++      psubadds.sh pc,pc:b,pc:b
++      psubadds.sh r12,r12:t,r12:t
++      psubadds.sh r5,r5:t,r5:t
++      psubadds.sh r4,r4:b,r4:b
++      psubadds.sh lr,lr:t,lr:t
++      psubadds.sh pc,lr:b,r1:t
++      psubadds.sh r11,r3:b,r12:b
++      psubadds.sh r10,r2:t,r8:t
++      .text
++      .global paddsubs_uh
++paddsubs_uh:
++      paddsubs.uh pc,pc:b,pc:b
++      paddsubs.uh r12,r12:t,r12:t
++      paddsubs.uh r5,r5:t,r5:t
++      paddsubs.uh r4,r4:b,r4:b
++      paddsubs.uh lr,lr:t,lr:t
++      paddsubs.uh r9,r2:b,r3:b
++      paddsubs.uh sp,sp:b,r7:t
++      paddsubs.uh lr,r0:b,r10:t
++      .text
++      .global psubadds_uh
++psubadds_uh:
++      psubadds.uh pc,pc:b,pc:b
++      psubadds.uh r12,r12:t,r12:t
++      psubadds.uh r5,r5:t,r5:t
++      psubadds.uh r4,r4:b,r4:b
++      psubadds.uh lr,lr:t,lr:t
++      psubadds.uh r12,r9:t,pc:t
++      psubadds.uh r8,r6:b,r8:b
++      psubadds.uh r8,r8:b,r4:b
++      .text
++      .global paddsubh_sh
++paddsubh_sh:
++      paddsubh.sh pc,pc:b,pc:b
++      paddsubh.sh r12,r12:t,r12:t
++      paddsubh.sh r5,r5:t,r5:t
++      paddsubh.sh r4,r4:b,r4:b
++      paddsubh.sh lr,lr:t,lr:t
++      paddsubh.sh r8,r9:t,r9:b
++      paddsubh.sh r0,sp:t,r1:t
++      paddsubh.sh r3,r1:b,r0:t
++      .text
++      .global psubaddh_sh
++psubaddh_sh:
++      psubaddh.sh pc,pc:b,pc:b
++      psubaddh.sh r12,r12:t,r12:t
++      psubaddh.sh r5,r5:t,r5:t
++      psubaddh.sh r4,r4:b,r4:b
++      psubaddh.sh lr,lr:t,lr:t
++      psubaddh.sh r7,r3:t,r10:b
++      psubaddh.sh r7,r2:t,r1:t
++      psubaddh.sh r11,r3:b,r6:b
++      .text
++      .global padd_b
++padd_b:
++      padd.b pc,pc,pc
++      padd.b r12,r12,r12
++      padd.b r5,r5,r5
++      padd.b r4,r4,r4
++      padd.b lr,lr,lr
++      padd.b r2,r6,pc
++      padd.b r8,r9,r12
++      padd.b r5,r12,r3
++      .text
++      .global psub_b
++psub_b:
++      psub.b pc,pc,pc
++      psub.b r12,r12,r12
++      psub.b r5,r5,r5
++      psub.b r4,r4,r4
++      psub.b lr,lr,lr
++      psub.b r0,r12,pc
++      psub.b r7,sp,r10
++      psub.b r5,sp,r12
++      .text
++      .global padds_sb
++padds_sb:
++      padds.sb pc,pc,pc
++      padds.sb r12,r12,r12
++      padds.sb r5,r5,r5
++      padds.sb r4,r4,r4
++      padds.sb lr,lr,lr
++      padds.sb sp,r11,r4
++      padds.sb r11,r10,r11
++      padds.sb r5,r12,r6
++      .text
++      .global psubs_sb
++psubs_sb:
++      psubs.sb pc,pc,pc
++      psubs.sb r12,r12,r12
++      psubs.sb r5,r5,r5
++      psubs.sb r4,r4,r4
++      psubs.sb lr,lr,lr
++      psubs.sb r7,r6,r8
++      psubs.sb r12,r10,r9
++      psubs.sb pc,r11,r0
++      .text
++      .global padds_ub
++padds_ub:
++      padds.ub pc,pc,pc
++      padds.ub r12,r12,r12
++      padds.ub r5,r5,r5
++      padds.ub r4,r4,r4
++      padds.ub lr,lr,lr
++      padds.ub r3,r2,r11
++      padds.ub r10,r8,r1
++      padds.ub r11,r8,r10
++      .text
++      .global psubs_ub
++psubs_ub:
++      psubs.ub pc,pc,pc
++      psubs.ub r12,r12,r12
++      psubs.ub r5,r5,r5
++      psubs.ub r4,r4,r4
++      psubs.ub lr,lr,lr
++      psubs.ub r0,r2,r7
++      psubs.ub lr,r5,r3
++      psubs.ub r6,r7,r9
++      .text
++      .global paddh_ub
++paddh_ub:
++      paddh.ub pc,pc,pc
++      paddh.ub r12,r12,r12
++      paddh.ub r5,r5,r5
++      paddh.ub r4,r4,r4
++      paddh.ub lr,lr,lr
++      paddh.ub lr,r1,r0
++      paddh.ub r2,r7,r7
++      paddh.ub r2,r1,r2
++      .text
++      .global psubh_ub
++psubh_ub:
++      psubh.ub pc,pc,pc
++      psubh.ub r12,r12,r12
++      psubh.ub r5,r5,r5
++      psubh.ub r4,r4,r4
++      psubh.ub lr,lr,lr
++      psubh.ub r0,r1,r6
++      psubh.ub r4,lr,r10
++      psubh.ub r9,r8,r1
++      .text
++      .global pmax_ub
++pmax_ub:
++      pmax.ub pc,pc,pc
++      pmax.ub r12,r12,r12
++      pmax.ub r5,r5,r5
++      pmax.ub r4,r4,r4
++      pmax.ub lr,lr,lr
++      pmax.ub pc,r2,r11
++      pmax.ub r12,r1,r1
++      pmax.ub r5,r2,r0
++      .text
++      .global pmax_sh
++pmax_sh:
++      pmax.sh pc,pc,pc
++      pmax.sh r12,r12,r12
++      pmax.sh r5,r5,r5
++      pmax.sh r4,r4,r4
++      pmax.sh lr,lr,lr
++      pmax.sh lr,r6,r12
++      pmax.sh r2,pc,r5
++      pmax.sh pc,r2,r7
++      .text
++      .global pmin_ub
++pmin_ub:
++      pmin.ub pc,pc,pc
++      pmin.ub r12,r12,r12
++      pmin.ub r5,r5,r5
++      pmin.ub r4,r4,r4
++      pmin.ub lr,lr,lr
++      pmin.ub r8,r1,r5
++      pmin.ub r1,r8,r3
++      pmin.ub r0,r2,r7
++      .text
++      .global pmin_sh
++pmin_sh:
++      pmin.sh pc,pc,pc
++      pmin.sh r12,r12,r12
++      pmin.sh r5,r5,r5
++      pmin.sh r4,r4,r4
++      pmin.sh lr,lr,lr
++      pmin.sh r8,r4,r10
++      pmin.sh lr,r10,r12
++      pmin.sh r2,r6,r2
++      .text
++      .global pavg_ub
++pavg_ub:
++      pavg.ub pc,pc,pc
++      pavg.ub r12,r12,r12
++      pavg.ub r5,r5,r5
++      pavg.ub r4,r4,r4
++      pavg.ub lr,lr,lr
++      pavg.ub r0,r1,r6
++      pavg.ub r8,r3,r6
++      pavg.ub pc,r12,r10
++      .text
++      .global pavg_sh
++pavg_sh:
++      pavg.sh pc,pc,pc
++      pavg.sh r12,r12,r12
++      pavg.sh r5,r5,r5
++      pavg.sh r4,r4,r4
++      pavg.sh lr,lr,lr
++      pavg.sh r9,pc,sp
++      pavg.sh pc,sp,r3
++      pavg.sh r6,r1,r9
++      .text
++      .global pabs_sb
++pabs_sb:
++      pabs.sb pc,pc
++      pabs.sb r12,r12
++      pabs.sb r5,r5
++      pabs.sb r4,r4
++      pabs.sb lr,lr
++      pabs.sb r11,r6
++      pabs.sb lr,r9
++      pabs.sb sp,r7
++      .text
++      .global pabs_sh
++pabs_sh:
++      pabs.sh pc,pc
++      pabs.sh r12,r12
++      pabs.sh r5,r5
++      pabs.sh r4,r4
++      pabs.sh lr,lr
++      pabs.sh pc,r3
++      pabs.sh r5,r7
++      pabs.sh r4,r0
++      .text
++      .global psad
++psad:
++      psad pc,pc,pc
++      psad r12,r12,r12
++      psad r5,r5,r5
++      psad r4,r4,r4
++      psad lr,lr,lr
++      psad r9,r11,r11
++      psad lr,r4,sp
++      psad lr,r4,r5
++      .text
++      .global pasr_b
++pasr_b:
++      pasr.b pc,pc,0
++      pasr.b r12,r12,7
++      pasr.b r5,r5,4
++      pasr.b r4,r4,3
++      pasr.b lr,lr,1
++      pasr.b pc,r7,1
++      pasr.b sp,lr,6
++      pasr.b sp,r3,2
++      .text
++      .global plsl_b
++plsl_b:
++      plsl.b pc,pc,0
++      plsl.b r12,r12,7
++      plsl.b r5,r5,4
++      plsl.b r4,r4,3
++      plsl.b lr,lr,1
++      plsl.b r2,r11,4
++      plsl.b r8,r5,7
++      plsl.b pc,r0,2
++      .text
++      .global plsr_b
++plsr_b:
++      plsr.b pc,pc,0
++      plsr.b r12,r12,7
++      plsr.b r5,r5,4
++      plsr.b r4,r4,3
++      plsr.b lr,lr,1
++      plsr.b r12,r1,2
++      plsr.b r6,pc,7
++      plsr.b r12,r11,2
++      .text
++      .global pasr_h
++pasr_h:
++      pasr.h pc,pc,0
++      pasr.h r12,r12,15
++      pasr.h r5,r5,8
++      pasr.h r4,r4,7
++      pasr.h lr,lr,1
++      pasr.h r0,r11,10
++      pasr.h r4,r6,8
++      pasr.h r6,r2,4
++      .text
++      .global plsl_h
++plsl_h:
++      plsl.h pc,pc,0
++      plsl.h r12,r12,15
++      plsl.h r5,r5,8
++      plsl.h r4,r4,7
++      plsl.h lr,lr,1
++      plsl.h r5,r10,9
++      plsl.h sp,lr,8
++      plsl.h r0,lr,7
++      .text
++      .global plsr_h
++plsr_h:
++      plsr.h pc,pc,0
++      plsr.h r12,r12,15
++      plsr.h r5,r5,8
++      plsr.h r4,r4,7
++      plsr.h lr,lr,1
++      plsr.h r11,r0,15
++      plsr.h lr,r3,3
++      plsr.h r8,lr,10
++      .text
++      .global packw_sh
++packw_sh:
++      packw.sh pc,pc,pc
++      packw.sh r12,r12,r12
++      packw.sh r5,r5,r5
++      packw.sh r4,r4,r4
++      packw.sh lr,lr,lr
++      packw.sh sp,r11,r10
++      packw.sh r8,r2,r12
++      packw.sh r8,r1,r5
++      .text
++      .global punpckub_h
++punpckub_h:
++      punpckub.h pc,pc:b
++      punpckub.h r12,r12:t
++      punpckub.h r5,r5:t
++      punpckub.h r4,r4:b
++      punpckub.h lr,lr:t
++      punpckub.h r6,r1:t
++      punpckub.h lr,r5:b
++      punpckub.h lr,r2:t
++      .text
++      .global punpcksb_h
++punpcksb_h:
++      punpcksb.h pc,pc:b
++      punpcksb.h r12,r12:t
++      punpcksb.h r5,r5:t
++      punpcksb.h r4,r4:b
++      punpcksb.h lr,lr:t
++      punpcksb.h r4,r7:t
++      punpcksb.h r6,lr:b
++      punpcksb.h r12,r12:t
++      .text
++      .global packsh_ub
++packsh_ub:
++      packsh.ub pc,pc,pc
++      packsh.ub r12,r12,r12
++      packsh.ub r5,r5,r5
++      packsh.ub r4,r4,r4
++      packsh.ub lr,lr,lr
++      packsh.ub r3,r6,r3
++      packsh.ub r8,r0,r3
++      packsh.ub r9,r3,lr
++      .text
++      .global packsh_sb
++packsh_sb:
++      packsh.sb pc,pc,pc
++      packsh.sb r12,r12,r12
++      packsh.sb r5,r5,r5
++      packsh.sb r4,r4,r4
++      packsh.sb lr,lr,lr
++      packsh.sb r6,r8,r1
++      packsh.sb lr,r9,r8
++      packsh.sb sp,r6,r6
++      .text
++      .global andl
++andl:
++      andl pc,0
++      andl r12,65535
++      andl r5,32768
++      andl r4,32767
++      andl lr,1
++      andl pc,23128
++      andl r8,47262
++      andl r7,13719
++      .text
++      .global andl_coh
++andl_coh:
++      andl pc,0,COH
++      andl r12,65535,COH
++      andl r5,32768,COH
++      andl r4,32767,COH
++      andl lr,1,COH
++      andl r6,22753,COH
++      andl r0,40653,COH
++      andl r4,48580,COH
++      .text
++      .global andh
++andh:
++      andh pc,0
++      andh r12,65535
++      andh r5,32768
++      andh r4,32767
++      andh lr,1
++      andh r12,52312
++      andh r3,8675
++      andh r2,42987
++      .text
++      .global andh_coh
++andh_coh:
++      andh pc,0,COH
++      andh r12,65535,COH
++      andh r5,32768,COH
++      andh r4,32767,COH
++      andh lr,1,COH
++      andh r11,34317,COH
++      andh r8,52982,COH
++      andh r10,23683,COH
++      .text
++      .global orl
++orl:
++      orl pc,0
++      orl r12,65535
++      orl r5,32768
++      orl r4,32767
++      orl lr,1
++      orl sp,16766
++      orl r0,21181
++      orl pc,44103
++      .text
++      .global orh
++orh:
++      orh pc,0
++      orh r12,65535
++      orh r5,32768
++      orh r4,32767
++      orh lr,1
++      orh r8,28285
++      orh r12,30492
++      orh r1,59930
++      .text
++      .global eorl
++eorl:
++      eorl pc,0
++      eorl r12,65535
++      eorl r5,32768
++      eorl r4,32767
++      eorl lr,1
++      eorl r4,51129
++      eorl r6,64477
++      eorl r1,20913
++      .text
++      .global eorh
++eorh:
++      eorh pc,0
++      eorh r12,65535
++      eorh r5,32768
++      eorh r4,32767
++      eorh lr,1
++      eorh r0,11732
++      eorh r10,38069
++      eorh r9,57130
++      .text
++      .global mcall
++mcall:
++      mcall pc[0]
++      mcall r12[-4]
++      mcall r5[-131072]
++      mcall r4[131068]
++      mcall lr[4]
++      mcall sp[61180]
++      mcall r4[-35000]
++      mcall r0[9924]
++      .text
++      .global pref
++pref:
++      pref pc[0]
++      pref r12[-1]
++      pref r5[-32768]
++      pref r4[32767]
++      pref lr[1]
++      pref r7[7748]
++      pref r7[-7699]
++      pref r2[-25892]
++      .text
++      .global cache
++cache:
++      cache pc[0],0
++      cache r12[-1],31
++      cache r5[-1024],16
++      cache r4[1023],15
++      cache lr[1],1
++      cache r3[-964],17
++      cache r4[-375],22
++      cache r3[-888],17
++      .text
++      .global sub4
++sub4:
++      sub pc,0
++      sub r12,-1
++      sub r5,-1048576
++      sub r4,1048575
++      sub lr,1
++      sub r2,-619156
++      sub lr,461517
++      sub r8,-185051
++      .text
++      .global cp3
++cp3:
++      cp pc,0
++      cp r12,-1
++      cp r5,-1048576
++      cp r4,1048575
++      cp lr,1
++      cp r1,124078
++      cp r0,-378909
++      cp r4,-243180
++      .text
++      .global mov2
++mov2:
++      mov pc,0
++      mov r12,-1
++      mov r5,-1048576
++      mov r4,1048575
++      mov lr,1
++      mov r5,-317021
++      mov sp,-749164
++      mov r5,940179
++      .text
++      .global brc2
++brc2:
++      breq 0
++      bral -2
++      brls -2097152
++      brpl 2097150
++      brne 2
++      brhi -1796966
++      brqs 1321368
++      brls -577434
++      .text
++      .global rcall2
++rcall2:
++      rcall 0
++      rcall -2
++      rcall -2097152
++      rcall 2097150
++      rcall 2
++      rcall 496820
++      rcall 1085092
++      rcall -1058
++      .text
++      .global sub5
++sub5:
++      sub pc,pc,0
++      sub r12,r12,-1
++      sub r5,r5,-32768
++      sub r4,r4,32767
++      sub lr,lr,1
++      sub pc,pc,-12744
++      sub r7,r7,-27365
++      sub r2,r9,-17358
++      .text
++      .global satsub_w2
++satsub_w2:
++      satsub.w pc,pc,0
++      satsub.w r12,r12,-1
++      satsub.w r5,r5,-32768
++      satsub.w r4,r4,32767
++      satsub.w lr,lr,1
++      satsub.w r2,lr,-2007
++      satsub.w r7,r12,-784
++      satsub.w r4,r7,23180
++      .text
++      .global ld_d4
++ld_d4:
++      ld.d r0,pc[0]
++      ld.d r14,r12[-1]
++      ld.d r8,r5[-32768]
++      ld.d r6,r4[32767]
++      ld.d r2,lr[1]
++      ld.d r14,r11[14784]
++      ld.d r6,r9[-18905]
++      ld.d r2,r3[-6355]
++      .text
++      .global ld_w4
++ld_w4:
++      ld.w pc,pc[0]
++      ld.w r12,r12[-1]
++      ld.w r5,r5[-32768]
++      ld.w r4,r4[32767]
++      ld.w lr,lr[1]
++      ld.w r0,r12[-22133]
++      ld.w sp,pc[-20521]
++      /* ld.w r3,r5[29035] */
++      nop
++      .text
++      .global ld_sh4
++ld_sh4:
++      ld.sh pc,pc[0]
++      ld.sh r12,r12[-1]
++      ld.sh r5,r5[-32768]
++      ld.sh r4,r4[32767]
++      ld.sh lr,lr[1]
++      ld.sh r6,r10[30930]
++      ld.sh r6,r10[21973]
++      /* ld.sh r11,r10[-2058] */
++      nop
++      .text
++      .global ld_uh4
++ld_uh4:
++      ld.uh pc,pc[0]
++      ld.uh r12,r12[-1]
++      ld.uh r5,r5[-32768]
++      ld.uh r4,r4[32767]
++      ld.uh lr,lr[1]
++      ld.uh r1,r9[-13354]
++      ld.uh lr,r11[21337]
++      /* ld.uh r2,lr[-25370] */
++      nop
++      .text
++      .global ld_sb1
++ld_sb1:
++      ld.sb pc,pc[0]
++      ld.sb r12,r12[-1]
++      ld.sb r5,r5[-32768]
++      ld.sb r4,r4[32767]
++      ld.sb lr,lr[1]
++      ld.sb r7,sp[-28663]
++      ld.sb r2,r1[-5879]
++      ld.sb r12,r3[18734]
++      .text
++      .global ld_ub4
++ld_ub4:
++      ld.ub pc,pc[0]
++      ld.ub r12,r12[-1]
++      ld.ub r5,r5[-32768]
++      ld.ub r4,r4[32767]
++      ld.ub lr,lr[1]
++      ld.ub pc,r4[8277]
++      ld.ub r5,r12[19172]
++      ld.ub r10,lr[26347]
++      .text
++      .global st_d4
++st_d4:
++      st.d pc[0],r0
++      st.d r12[-1],r14
++      st.d r5[-32768],r8
++      st.d r4[32767],r6
++      st.d lr[1],r2
++      st.d r5[13200],r10
++      st.d r5[9352],r10
++      st.d r5[32373],r4
++      .text
++      .global st_w4
++st_w4:
++      st.w pc[0],pc
++      st.w r12[-1],r12
++      st.w r5[-32768],r5
++      st.w r4[32767],r4
++      st.w lr[1],lr
++      st.w sp[6136],r7
++      st.w r6[27087],r12
++      /* st.w r3[20143],r7 */
++      nop
++      .text
++      .global st_h4
++st_h4:
++      st.h pc[0],pc
++      st.h r12[-1],r12
++      st.h r5[-32768],r5
++      st.h r4[32767],r4
++      st.h lr[1],lr
++      st.h r4[-9962],r7
++      st.h r9[-16250],r3
++      /* st.h r8[-28810],r7 */
++      nop
++      .text
++      .global st_b4
++st_b4:
++      st.b pc[0],pc
++      st.b r12[-1],r12
++      st.b r5[-32768],r5
++      st.b r4[32767],r4
++      st.b lr[1],lr
++      st.b r12[30102],r6
++      st.b r5[28977],r1
++      st.b r0[5470],r1
++      .text
++      .global mfsr
++mfsr:
++      mfsr pc,0
++      mfsr r12,1020
++      mfsr r5,512
++      mfsr r4,508
++      mfsr lr,4
++      mfsr r2,696
++      mfsr r4,260
++      mfsr r10,1016
++      .text
++      .global mtsr
++mtsr:
++      mtsr 0,pc
++      mtsr 1020,r12
++      mtsr 512,r5
++      mtsr 508,r4
++      mtsr 4,lr
++      mtsr 224,r10
++      mtsr 836,r12
++      mtsr 304,r9
++      .text
++      .global mfdr
++mfdr:
++      mfdr pc,0
++      mfdr r12,1020
++      mfdr r5,512
++      mfdr r4,508
++      mfdr lr,4
++      mfdr r6,932
++      mfdr r5,36
++      mfdr r9,300
++      .text
++      .global mtdr
++mtdr:
++      mtdr 0,pc
++      mtdr 1020,r12
++      mtdr 512,r5
++      mtdr 508,r4
++      mtdr 4,lr
++      mtdr 180,r8
++      mtdr 720,r10
++      mtdr 408,lr
++      .text
++      .global sleep
++sleep:
++      sleep 0
++      sleep 255
++      sleep 128
++      sleep 127
++      sleep 1
++      sleep 254
++      sleep 15
++      sleep 43
++      .text
++      .global sync
++sync:
++      sync 0
++      sync 255
++      sync 128
++      sync 127
++      sync 1
++      sync 166
++      sync 230
++      sync 180
++      .text
++      .global bld
++bld:
++      bld pc,0
++      bld r12,31
++      bld r5,16
++      bld r4,15
++      bld lr,1
++      bld r9,15
++      bld r0,4
++      bld lr,26
++      .text
++      .global bst
++bst:
++      bst pc,0
++      bst r12,31
++      bst r5,16
++      bst r4,15
++      bst lr,1
++      bst r10,28
++      bst r0,3
++      bst sp,2
++      .text
++      .global sats
++sats:
++      sats pc>>0,0
++      sats r12>>31,31
++      sats r5>>16,16
++      sats r4>>15,15
++      sats lr>>1,1
++      sats r10>>3,19
++      sats r10>>2,26
++      sats r1>>20,1
++      .text
++      .global satu
++satu:
++      satu pc>>0,0
++      satu r12>>31,31
++      satu r5>>16,16
++      satu r4>>15,15
++      satu lr>>1,1
++      satu pc>>5,7
++      satu r7>>5,5
++      satu r2>>26,19
++      .text
++      .global satrnds
++satrnds:
++      satrnds pc>>0,0
++      satrnds r12>>31,31
++      satrnds r5>>16,16
++      satrnds r4>>15,15
++      satrnds lr>>1,1
++      satrnds r0>>21,19
++      satrnds sp>>0,2
++      satrnds r7>>6,29
++      .text
++      .global satrndu
++satrndu:
++      satrndu pc>>0,0
++      satrndu r12>>31,31
++      satrndu r5>>16,16
++      satrndu r4>>15,15
++      satrndu lr>>1,1
++      satrndu r12>>0,26
++      satrndu r4>>21,3
++      satrndu r10>>3,16
++      .text
++      .global subfc
++subfc:
++      subfeq pc,0
++      subfal r12,-1
++      subfls r5,-128
++      subfpl r4,127
++      subfne lr,1
++      subfls r10,8
++      subfvc r11,99
++      subfvs r2,73
++      .text
++      .global subc
++subc:
++      subeq pc,0
++      subal r12,-1
++      subls r5,-128
++      subpl r4,127
++      subne lr,1
++      subls r12,118
++      subvc lr,-12
++      submi r4,-13
++      .text
++      .global movc2
++movc2:
++      moveq pc,0
++      moval r12,-1
++      movls r5,-128
++      movpl r4,127
++      movne lr,1
++      movlt r3,-122
++      movvc r8,2
++      movne r7,-111
++      .text
++      .global cp_b
++cp_b:
++      cp.b pc,r0
++      cp.b r0,pc
++      cp.b r7,r8
++      cp.b r8,r7
++      .text
++      .global cp_h
++cp_h:
++      cp.h pc,r0
++      cp.h r0,pc
++      cp.h r7,r8
++      cp.h r8,r7
++      .text
++      .global ldm
++ldm:
++      ldm pc,r1-r6
++      ldm r12,r0-r15
++      ldm r5,r15
++      ldm r4,r0-r14
++      ldm lr,r0
++      ldm r9,r1,r5,r14
++      ldm r11,r2-r3,r5-r8,r15
++      ldm r6,r0,r3,r9,r13,r15
++      .text
++      .global ldm_pu
++ldm_pu:
++      ldm pc++,r6-r9
++      ldm r12++,r0-r15
++      ldm r5++,r15
++      ldm r4++,r0-r14
++      ldm lr++,r0
++      ldm r12++,r3-r5,r8,r10,r12,r14-r15
++      ldm r10++,r2,r4-r6,r14-r15
++      ldm r6++,r1,r3-r4,r9-r14
++      .text
++      .global ldmts
++ldmts:
++      ldmts pc,r7-r8
++      ldmts r12,r0-r15
++      ldmts r5,r15
++      ldmts r4,r0-r14
++      ldmts lr,r0
++      ldmts r0,r1-r2,r11-r12
++      ldmts lr,r0-r2,r4,r7-r8,r13-r14
++      ldmts r12,r0-r1,r3-r5,r9,r14-r15
++      .text
++      .global ldmts_pu
++ldmts_pu:
++      ldmts pc++,r9
++      ldmts r12++,r0-r15
++      ldmts r5++,r15
++      ldmts r4++,r0-r14
++      ldmts lr++,r0
++      ldmts sp++,r0,r2-r5,r7,r9,r11
++      ldmts r5++,r1-r3,r7,r10-r11
++      ldmts r8++,r2-r4,r7-r8,r13,r15
++      .text
++      .global stm
++stm:
++      stm pc,r7
++      stm r12,r0-r15
++      stm r5,r15
++      stm r4,r0-r14
++      stm lr,r0
++      stm sp,r2-r3,r5,r8,r11,r14
++      stm r4,r0-r4,r6,r10-r11,r14
++      stm r9,r1,r5,r9,r12-r15
++      .text
++      .global stm_pu
++stm_pu:
++      stm --pc,r4-r6
++      stm --r12,r0-r15
++      stm --r5,r15
++      stm --r4,r0-r14
++      stm --lr,r0
++      stm --r11,r0,r4-r9,r11-r15
++      stm --r11,r0,r3,r9-r10,r12,r14
++      stm --r6,r2,r8-r9,r13-r14
++      .text
++      .global stmts
++stmts:
++      stmts pc,r8
++      stmts r12,r0-r15
++      stmts r5,r15
++      stmts r4,r0-r14
++      stmts lr,r0
++      stmts r1,r0-r1,r3-r4,r6,r9-r10,r14-r15
++      stmts r3,r0,r6-r8,r10-r12
++      stmts r11,r0,r4,r6-r7,r9-r10,r12,r14-r15
++      .text
++      .global stmts_pu
++stmts_pu:
++      stmts --pc,r6-r8
++      stmts --r12,r0-r15
++      stmts --r5,r15
++      stmts --r4,r0-r14
++      stmts --lr,r0
++      stmts --r2,r0,r3-r4,r9-r10,r12-r13
++      stmts --r3,r0-r1,r14-r15
++      stmts --r0,r0,r2-r6,r10,r14
++      .text
++      .global ldins_h
++ldins_h:
++      ldins.h pc:b,pc[0]
++      ldins.h r12:t,r12[-2]
++      ldins.h r5:t,r5[-4096]
++      ldins.h r4:b,r4[4094]
++      ldins.h lr:t,lr[2]
++      ldins.h r0:t,lr[1930]
++      ldins.h r3:b,r7[-534]
++      ldins.h r2:b,r12[-2252]
++      .text
++      .global ldins_b
++ldins_b:
++      ldins.b pc:b,pc[0]
++      ldins.b r12:t,r12[-1]
++      ldins.b r5:u,r5[-2048]
++      ldins.b r4:l,r4[2047]
++      ldins.b lr:l,lr[1]
++      ldins.b r6:t,r4[-662]
++      ldins.b r5:b,r1[-151]
++      ldins.b r10:t,r11[-1923]
++      .text
++      .global ldswp_sh
++ldswp_sh:
++      ldswp.sh pc,pc[0]
++      ldswp.sh r12,r12[-2]
++      ldswp.sh r5,r5[-4096]
++      ldswp.sh r4,r4[4094]
++      ldswp.sh lr,lr[2]
++      ldswp.sh r9,r10[3848]
++      ldswp.sh r4,r12[-2040]
++      ldswp.sh r10,r2[3088]
++      .text
++      .global ldswp_uh
++ldswp_uh:
++      ldswp.uh pc,pc[0]
++      ldswp.uh r12,r12[-2]
++      ldswp.uh r5,r5[-4096]
++      ldswp.uh r4,r4[4094]
++      ldswp.uh lr,lr[2]
++      ldswp.uh r4,r9[3724]
++      ldswp.uh lr,sp[-1672]
++      ldswp.uh r8,r12[-3846]
++      .text
++      .global ldswp_w
++ldswp_w:
++      ldswp.w pc,pc[0]
++      ldswp.w r12,r12[-4]
++      ldswp.w r5,r5[-8192]
++      ldswp.w r4,r4[8188]
++      ldswp.w lr,lr[4]
++      ldswp.w sp,r7[1860]
++      ldswp.w pc,r5[-3324]
++      ldswp.w r12,r10[-3296]
++      .text
++      .global stswp_h
++stswp_h:
++      stswp.h pc[0],pc
++      stswp.h r12[-2],r12
++      stswp.h r5[-4096],r5
++      stswp.h r4[4094],r4
++      stswp.h lr[2],lr
++      stswp.h r7[64],r10
++      stswp.h r10[3024],r2
++      stswp.h r0[-2328],r10
++      .text
++      .global stswp_w
++stswp_w:
++      stswp.w pc[0],pc
++      stswp.w r12[-4],r12
++      stswp.w r5[-8192],r5
++      stswp.w r4[8188],r4
++      stswp.w lr[4],lr
++      stswp.w pc[1156],r8
++      stswp.w sp[7992],r10
++      stswp.w r8[-1172],r5
++      .text
++      .global and2
++and2:
++      and pc,pc,pc<<0
++      and r12,r12,r12<<31
++      and r5,r5,r5<<16
++      and r4,r4,r4<<15
++      and lr,lr,lr<<1
++      and r10,r2,r1<<1
++      and r12,r8,r11<<27
++      and r10,r7,r0<<3
++      .text
++      .global and3
++and3:
++      and pc,pc,pc>>0
++      and r12,r12,r12>>31
++      and r5,r5,r5>>16
++      and r4,r4,r4>>15
++      and lr,lr,lr>>1
++      and r12,r8,r7>>17
++      and pc,r4,r9>>20
++      and r10,r9,r10>>12
++      .text
++      .global or2
++or2:
++      or pc,pc,pc<<0
++      or r12,r12,r12<<31
++      or r5,r5,r5<<16
++      or r4,r4,r4<<15
++      or lr,lr,lr<<1
++      or r8,sp,r11<<29
++      or pc,r9,r2<<28
++      or r5,r1,r2<<3
++      .text
++      .global or3
++or3:
++      or pc,pc,pc>>0
++      or r12,r12,r12>>31
++      or r5,r5,r5>>16
++      or r4,r4,r4>>15
++      or lr,lr,lr>>1
++      or r1,sp,sp>>2
++      or r0,r1,r1>>29
++      or r4,r12,r8>>8
++      .text
++      .global eor2
++eor2:
++      eor pc,pc,pc<<0
++      eor r12,r12,r12<<31
++      eor r5,r5,r5<<16
++      eor r4,r4,r4<<15
++      eor lr,lr,lr<<1
++      eor r10,r9,r4<<11
++      eor r4,r0,r1<<31
++      eor r6,r2,r12<<13
++      .text
++      .global eor3
++eor3:
++      eor pc,pc,pc>>0
++      eor r12,r12,r12>>31
++      eor r5,r5,r5>>16
++      eor r4,r4,r4>>15
++      eor lr,lr,lr>>1
++      eor r5,r5,r5>>22
++      eor r10,r1,lr>>3
++      eor r7,lr,sp>>26
++      .text
++      .global sthh_w2
++sthh_w2:
++      sthh.w pc[pc<<0],pc:b,pc:b
++      sthh.w r12[r12<<3],r12:t,r12:t
++      sthh.w r5[r5<<2],r5:t,r5:t
++      sthh.w r4[r4<<1],r4:b,r4:b
++      sthh.w lr[lr<<1],lr:t,lr:t
++      sthh.w sp[r6<<3],r1:t,r12:t
++      sthh.w r6[r6<<0],r9:t,r9:t
++      sthh.w r10[r3<<0],r0:b,r11:t
++      .text
++      .global sthh_w1
++sthh_w1:
++      sthh.w pc[0],pc:b,pc:b
++      sthh.w r12[1020],r12:t,r12:t
++      sthh.w r5[512],r5:t,r5:t
++      sthh.w r4[508],r4:b,r4:b
++      sthh.w lr[4],lr:t,lr:t
++      sthh.w r4[404],r9:t,r0:b
++      sthh.w r8[348],r2:t,r10:b
++      sthh.w sp[172],r9:b,r2:b
++      .text
++      .global cop
++cop:
++      cop cp0,cr0,cr0,cr0,0
++      cop cp7,cr15,cr15,cr15,0x7f
++      cop cp3,cr5,cr5,cr5,0x31
++      cop cp2,cr4,cr4,cr4,0x30
++      cop cp5,cr8,cr3,cr7,0x5a
++      .text
++      .global ldc_w1
++ldc_w1:
++      ldc.w cp0,cr0,r0[0]
++      ldc.w cp7,cr15,pc[255<<2]
++      ldc.w cp3,cr5,r5[128<<2]
++      ldc.w cp2,cr4,r4[127<<2]
++      ldc.w cp4,cr9,r13[36<<2]
++      .text
++      .global ldc_w2
++ldc_w2:
++      ldc.w cp0,cr0,--r0
++      ldc.w cp7,cr15,--pc
++      ldc.w cp3,cr5,--r5
++      ldc.w cp2,cr4,--r4
++      ldc.w cp4,cr9,--r13
++      .text
++      .global ldc_w3
++ldc_w3:
++      ldc.w cp0,cr0,r0[r0]
++      ldc.w cp7,cr15,pc[pc<<3]
++      ldc.w cp3,cr5,r5[r4<<2]
++      ldc.w cp2,cr4,r4[r3<<1]
++      ldc.w cp4,cr9,r13[r12<<0]
++      .text
++      .global ldc_d1
++ldc_d1:
++      ldc.d cp0,cr0,r0[0]
++      ldc.d cp7,cr14,pc[255<<2]
++      ldc.d cp3,cr6,r5[128<<2]
++      ldc.d cp2,cr4,r4[127<<2]
++      ldc.d cp4,cr8,r13[36<<2]
++      .text
++      .global ldc_d2
++ldc_d2:
++      ldc.d cp0,cr0,--r0
++      ldc.d cp7,cr14,--pc
++      ldc.d cp3,cr6,--r5
++      ldc.d cp2,cr4,--r4
++      ldc.d cp4,cr8,--r13
++      .text
++      .global ldc_d3
++ldc_d3:
++      ldc.d cp0,cr0,r0[r0]
++      ldc.d cp7,cr14,pc[pc<<3]
++      ldc.d cp3,cr6,r5[r4<<2]
++      ldc.d cp2,cr4,r4[r3<<1]
++      ldc.d cp4,cr8,r13[r12<<0]
++      .text
++      .global stc_w1
++stc_w1:
++      stc.w cp0,r0[0],cr0
++      stc.w cp7,pc[255<<2],cr15
++      stc.w cp3,r5[128<<2],cr5
++      stc.w cp2,r4[127<<2],cr4
++      stc.w cp4,r13[36<<2],cr9
++      .text
++      .global stc_w2
++stc_w2:
++      stc.w cp0,r0++,cr0
++      stc.w cp7,pc++,cr15
++      stc.w cp3,r5++,cr5
++      stc.w cp2,r4++,cr4
++      stc.w cp4,r13++,cr9
++      .text
++      .global stc_w3
++stc_w3:
++      stc.w cp0,r0[r0],cr0
++      stc.w cp7,pc[pc<<3],cr15
++      stc.w cp3,r5[r4<<2],cr5
++      stc.w cp2,r4[r3<<1],cr4
++      stc.w cp4,r13[r12<<0],cr9
++      .text
++      .global stc_d1
++stc_d1:
++      stc.d cp0,r0[0],cr0
++      stc.d cp7,pc[255<<2],cr14
++      stc.d cp3,r5[128<<2],cr6
++      stc.d cp2,r4[127<<2],cr4
++      stc.d cp4,r13[36<<2],cr8
++      .text
++      .global stc_d2
++stc_d2:
++      stc.d cp0,r0++,cr0
++      stc.d cp7,pc++,cr14
++      stc.d cp3,r5++,cr6
++      stc.d cp2,r4++,cr4
++      stc.d cp4,r13++,cr8
++      .text
++      .global stc_d3
++stc_d3:
++      stc.d cp0,r0[r0],cr0
++      stc.d cp7,pc[pc<<3],cr14
++      stc.d cp3,r5[r4<<2],cr6
++      stc.d cp2,r4[r3<<1],cr4
++      stc.d cp4,r13[r12<<0],cr8
++      .text
++      .global ldc0_w
++ldc0_w:
++      ldc0.w cr0,r0[0]
++      ldc0.w cr15,pc[4095<<2]
++      ldc0.w cr5,r5[2048<<2]
++      ldc0.w cr4,r4[2047<<2]
++      ldc0.w cr9,r13[147<<2]
++      .text
++      .global ldc0_d
++ldc0_d:
++      ldc0.d cr0,r0[0]
++      ldc0.d cr14,pc[4095<<2]
++      ldc0.d cr6,r5[2048<<2]
++      ldc0.d cr4,r4[2047<<2]
++      ldc0.d cr8,r13[147<<2]
++      .text
++      .global stc0_w
++stc0_w:
++      stc0.w r0[0],cr0
++      stc0.w pc[4095<<2],cr15
++      stc0.w r5[2048<<2],cr5
++      stc0.w r4[2047<<2],cr4
++      stc0.w r13[147<<2],cr9
++      .text
++      .global stc0_d
++stc0_d:
++      stc0.d r0[0],cr0
++      stc0.d pc[4095<<2],cr14
++      stc0.d r5[2048<<2],cr6
++      stc0.d r4[2047<<2],cr4
++      stc0.d r13[147<<2],cr8
++      .text
++      .global memc
++memc:
++      memc 0, 0
++      memc -4, 31
++      memc -65536, 16
++      memc 65532, 15
++      .text
++      .global mems
++mems:
++      mems 0, 0
++      mems -4, 31
++      mems -65536, 16
++      mems 65532, 15
++      .text
++      .global memt
++memt:
++      memt 0, 0
++      memt -4, 31
++      memt -65536, 16
++      memt 65532, 15
++
++      .text
++      .global stcond
++stcond:
++      stcond r0[0], r0
++      stcond pc[-1], pc
++      stcond r8[-32768], r7
++      stcond r7[32767], r8
++      stcond r5[0x1234], r10
++
++ldcm_w:
++      ldcm.w cp0,pc,cr0-cr7
++      ldcm.w cp7,r0,cr0
++      ldcm.w cp4,r4++,cr0-cr6
++      ldcm.w cp3,r7,cr7
++      ldcm.w cp1,r12++,cr1,cr4-cr6
++      ldcm.w cp0,pc,cr8-cr15
++      ldcm.w cp7,r0,cr8
++      ldcm.w cp4,r4++,cr8-cr14
++      ldcm.w cp3,r7,cr15
++      ldcm.w cp1,r12++,cr9,cr12-cr14
++
++ldcm_d:
++      ldcm.d cp0,pc,cr0-cr15
++      ldcm.d cp7,r0,cr0,cr1
++      ldcm.d cp4,r4++,cr0-cr13
++      ldcm.d cp3,r7,cr14-cr15
++      ldcm.d cp2,r12++,cr0-cr3,cr8-cr9,cr14-cr15
++
++stcm_w:
++      stcm.w cp0,pc,cr0-cr7
++      stcm.w cp7,r0,cr0
++      stcm.w cp4,--r4,cr0-cr6
++      stcm.w cp3,r7,cr7
++      stcm.w cp1,--r12,cr1,cr4-cr6
++      stcm.w cp0,pc,cr8-cr15
++      stcm.w cp7,r0,cr8
++      stcm.w cp4,--r4,cr8-cr14
++      stcm.w cp3,r7,cr15
++      stcm.w cp1,--r12,cr9,cr12-cr14
++
++stcm_d:
++      stcm.d cp0,pc,cr0-cr15
++      stcm.d cp7,r0,cr0,cr1
++      stcm.d cp4,--r4,cr0-cr13
++      stcm.d cp3,r7,cr14-cr15
++      stcm.d cp2,--r12,cr0-cr3,cr8-cr9,cr14-cr15
++
++mvcr_w:
++      mvcr.w cp7,pc,cr15
++      mvcr.w cp0,r0,cr0
++      mvcr.w cp0,pc,cr15
++      mvcr.w cp7,r0,cr15
++      mvcr.w cp7,pc,cr0
++      mvcr.w cp4,r7,cr8
++      mvcr.w cp3,r8,cr7
++
++mvcr_d:
++      mvcr.d cp7,lr,cr14
++      mvcr.d cp0,r0,cr0
++      mvcr.d cp0,lr,cr14
++      mvcr.d cp7,r0,cr14
++      mvcr.d cp7,lr,cr0
++      mvcr.d cp4,r6,cr8
++      mvcr.d cp3,r8,cr6
++
++mvrc_w:
++      mvrc.w cp7,cr15,pc
++      mvrc.w cp0,cr0,r0
++      mvrc.w cp0,cr15,pc
++      mvrc.w cp7,cr15,r0
++      mvrc.w cp7,cr0,pc
++      mvrc.w cp4,cr8,r7
++      mvrc.w cp3,cr7,r8
++
++mvrc_d:
++      mvrc.d cp7,cr14,lr
++      mvrc.d cp0,cr0,r0
++      mvrc.d cp0,cr14,lr
++      mvrc.d cp7,cr14,r0
++      mvrc.d cp7,cr0,lr
++      mvrc.d cp4,cr8,r6
++      mvrc.d cp3,cr6,r8
++
++bfexts:
++      bfexts pc,pc,31,31
++      bfexts r0,r0,0,0
++      bfexts r0,pc,31,31
++      bfexts pc,r0,31,31
++      bfexts pc,pc,0,31
++      bfexts pc,pc,31,0
++      bfexts r7,r8,15,16
++      bfexts r8,r7,16,15
++
++bfextu:
++      bfextu pc,pc,31,31
++      bfextu r0,r0,0,0
++      bfextu r0,pc,31,31
++      bfextu pc,r0,31,31
++      bfextu pc,pc,0,31
++      bfextu pc,pc,31,0
++      bfextu r7,r8,15,16
++      bfextu r8,r7,16,15
++
++bfins:
++      bfins pc,pc,31,31
++      bfins r0,r0,0,0
++      bfins r0,pc,31,31
++      bfins pc,r0,31,31
++      bfins pc,pc,0,31
++      bfins pc,pc,31,0
++      bfins r7,r8,15,16
++      bfins r8,r7,16,15
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/avr32.exp binutils-2.17-atmel/gas/testsuite/gas/avr32/avr32.exp
+--- binutils-2.17/gas/testsuite/gas/avr32/avr32.exp    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/avr32.exp      2006-10-03 17:19:02.000000000 +0200
+@@ -0,0 +1,23 @@
++# AVR32 assembler testsuite. -*- Tcl -*-
++
++if [istarget avr32-*-*] {
++    run_dump_test "hwrd-lwrd"
++    run_dump_test "pcrel"
++    run_dump_test "aliases"
++    run_dump_test "dwarf2"
++    run_dump_test "pic_reloc"
++    run_dump_test "fpinsn"
++    run_dump_test "pico"
++    run_dump_test "lda_pic"
++    run_dump_test "lda_pic_linkrelax"
++    run_dump_test "lda_nopic"
++    run_dump_test "lda_nopic_linkrelax"
++    run_dump_test "call_pic"
++    run_dump_test "call_pic_linkrelax"
++    run_dump_test "call_nopic"
++    run_dump_test "call_nopic_linkrelax"
++    run_dump_test "jmptable"
++    run_dump_test "jmptable_linkrelax"
++    run_dump_test "symdiff"
++    run_dump_test "symdiff_linkrelax"
++}
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/call_nopic.d binutils-2.17-atmel/gas/testsuite/gas/avr32/call_nopic.d
+--- binutils-2.17/gas/testsuite/gas/avr32/call_nopic.d 1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/call_nopic.d   2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,36 @@
++#source: call.s
++#as:
++#objdump: -dr
++#name: call_nopic
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <call_test>:
++       0:     d7 03           nop
++
++00000002 <toofar_negative>:
++      \.\.\.
++  1ffffe:     00 00           add r0,r0
++  200000:     f0 a0 00 00     rcall 0 <call_test>
++  200004:     f0 1f 00 0c     mcall 200034 <toofar_negative\+0x200032>
++  200008:     f0 1f 00 0c     mcall 200038 <toofar_negative\+0x200036>
++  20000c:     f0 1f 00 0c     mcall 20003c <toofar_negative\+0x20003a>
++  200010:     f0 1f 00 0c     mcall 200040 <toofar_negative\+0x20003e>
++      \.\.\.
++  200030:     ee b0 ff ff     rcall 40002e <far_positive>
++      \.\.\.
++                      200034: R_AVR32_32_CPENT        \.text\+0x2
++                      200038: R_AVR32_32_CPENT        \.text\.init
++                      20003c: R_AVR32_32_CPENT        undefined
++                      200040: R_AVR32_32_CPENT        \.text\+0x40002c
++
++0040002c <toofar_positive>:
++  40002c:     d7 03           nop
++0040002e <far_positive>:
++  40002e:     d7 03           nop
++Disassembly of section \.text\.init:
++
++00000000 <different_section>:
++   0: e2 c0 00 00     sub r0,r1,0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/call_nopic_linkrelax.d binutils-2.17-atmel/gas/testsuite/gas/avr32/call_nopic_linkrelax.d
+--- binutils-2.17/gas/testsuite/gas/avr32/call_nopic_linkrelax.d       1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/call_nopic_linkrelax.d 2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,43 @@
++#source: call.s
++#as: --linkrelax
++#objdump: -dr
++#name: call_nopic_linkrelax
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <call_test>:
++       0:     d7 03           nop
++
++00000002 <toofar_negative>:
++      \.\.\.
++  1ffffe:     00 00           add r0,r0
++  200000:     e0 a0 00 00     rcall 200000 <toofar_negative\+0x1ffffe>
++                      200000: R_AVR32_22H_PCREL       \.text
++  200004:     f0 1f 00 00     mcall 200004 <toofar_negative\+0x200002>
++                      200004: R_AVR32_CPCALL  \.text\+0x200034
++  200008:     f0 1f 00 00     mcall 200008 <toofar_negative\+0x200006>
++                      200008: R_AVR32_CPCALL  \.text\+0x200038
++  20000c:     f0 1f 00 00     mcall 20000c <toofar_negative\+0x20000a>
++                      20000c: R_AVR32_CPCALL  \.text\+0x20003c
++  200010:     f0 1f 00 00     mcall 200010 <toofar_negative\+0x20000e>
++                      200010: R_AVR32_CPCALL  \.text\+0x200040
++      \.\.\.
++  200030:     e0 a0 00 00     rcall 200030 <toofar_negative\+0x20002e>
++                      200030: R_AVR32_22H_PCREL       \.text\+0x40002e
++      \.\.\.
++                      200034: R_AVR32_ALIGN   \*ABS\*\+0x2
++                      200034: R_AVR32_32_CPENT        \.text\+0x2
++                      200038: R_AVR32_32_CPENT        \.text\.init
++                      20003c: R_AVR32_32_CPENT        undefined
++                      200040: R_AVR32_32_CPENT        \.text\+0x40002c
++
++0040002c <toofar_positive>:
++  40002c:     d7 03           nop
++0040002e <far_positive>:
++  40002e:     d7 03           nop
++Disassembly of section \.text\.init:
++
++00000000 <different_section>:
++   0: e2 c0 00 00     sub r0,r1,0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/call_pic.d binutils-2.17-atmel/gas/testsuite/gas/avr32/call_pic.d
+--- binutils-2.17/gas/testsuite/gas/avr32/call_pic.d   1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/call_pic.d     2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,36 @@
++#source: call.s
++#as: --pic
++#objdump: -dr
++#name: call_pic
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <call_test>:
++       0:     d7 03           nop
++
++00000002 <toofar_negative>:
++      \.\.\.
++  1ffffe:     00 00           add r0,r0
++  200000:     f0 a0 00 00     rcall 0 <call_test>
++  200004:     f0 16 00 00     mcall r6\[0\]
++                      200004: R_AVR32_GOT18SW toofar_negative
++  200008:     f0 16 00 00     mcall r6\[0\]
++                      200008: R_AVR32_GOT18SW different_section
++  20000c:     f0 16 00 00     mcall r6\[0\]
++                      20000c: R_AVR32_GOT18SW undefined
++  200010:     f0 16 00 00     mcall r6\[0\]
++                      200010: R_AVR32_GOT18SW toofar_positive
++      \.\.\.
++  200030:     ee b0 ff ff     rcall 40002e <far_positive>
++      \.\.\.
++
++0040002c <toofar_positive>:
++  40002c:     d7 03           nop
++0040002e <far_positive>:
++  40002e:     d7 03           nop
++Disassembly of section \.text\.init:
++
++00000000 <different_section>:
++   0: e2 c0 00 00     sub r0,r1,0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/call_pic_linkrelax.d binutils-2.17-atmel/gas/testsuite/gas/avr32/call_pic_linkrelax.d
+--- binutils-2.17/gas/testsuite/gas/avr32/call_pic_linkrelax.d 1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/call_pic_linkrelax.d   2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,47 @@
++#source: call.s
++#as: --pic --linkrelax
++#objdump: -dr
++#name: call_pic_linkrelax
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <call_test>:
++       0:     d7 03           nop
++
++00000002 <toofar_negative>:
++      \.\.\.
++  1ffffe:     00 00           add r0,r0
++  200000:     e0 a0 00 00     rcall 200000 <toofar_negative\+0x1ffffe>
++                      200000: R_AVR32_22H_PCREL       \.text
++  200004:     e0 6e 00 00     mov lr,0
++                      200004: R_AVR32_GOTCALL toofar_negative
++  200008:     ec 0e 03 2e     ld\.w lr,r6\[lr<<0x2\]
++  20000c:     5d 1e           icall lr
++  20000e:     e0 6e 00 00     mov lr,0
++                      20000e: R_AVR32_GOTCALL different_section
++  200012:     ec 0e 03 2e     ld\.w lr,r6\[lr<<0x2\]
++  200016:     5d 1e           icall lr
++  200018:     e0 6e 00 00     mov lr,0
++                      200018: R_AVR32_GOTCALL undefined
++  20001c:     ec 0e 03 2e     ld\.w lr,r6\[lr<<0x2\]
++  200020:     5d 1e           icall lr
++  200022:     e0 6e 00 00     mov lr,0
++                      200022: R_AVR32_GOTCALL toofar_positive
++  200026:     ec 0e 03 2e     ld\.w lr,r6\[lr<<0x2\]
++  20002a:     5d 1e           icall lr
++  20002c:     00 00           add r0,r0
++  20002e:     00 00           add r0,r0
++  200030:     e0 a0 00 00     rcall 200030 <toofar_negative\+0x20002e>
++                      200030: R_AVR32_22H_PCREL       \.text\+0x40002e
++      \.\.\.
++
++0040002c <toofar_positive>:
++  40002c:     d7 03           nop
++0040002e <far_positive>:
++  40002e:     d7 03           nop
++Disassembly of section \.text\.init:
++
++00000000 <different_section>:
++   0: e2 c0 00 00     sub r0,r1,0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/call.s binutils-2.17-atmel/gas/testsuite/gas/avr32/call.s
+--- binutils-2.17/gas/testsuite/gas/avr32/call.s       1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/call.s 2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,30 @@
++
++      .text
++      .global call_test
++call_test:
++far_negative:
++      nop
++toofar_negative:
++
++      .org    0x200000
++
++      call    far_negative
++      call    toofar_negative
++      call    different_section
++      call    undefined
++      call    toofar_positive
++      .org    0x200030
++      call    far_positive
++
++      .cpool
++
++      .org    0x40002c
++
++toofar_positive:
++      nop
++far_positive:
++      nop
++
++      .section .text.init,"ax",@progbits
++different_section:
++      sub     r0, r1, 0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/dwarf2.d binutils-2.17-atmel/gas/testsuite/gas/avr32/dwarf2.d
+--- binutils-2.17/gas/testsuite/gas/avr32/dwarf2.d     1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/dwarf2.d       2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,42 @@
++#readelf: -wl
++#name: dwarf2
++#source: dwarf2.s
++
++Dump of debug contents of section \.debug_line:
++
++  Length:                      53
++  DWARF Version:               2
++  Prologue Length:             26
++  Minimum Instruction Length:  1
++  Initial value of 'is_stmt':  1
++  Line Base:                   -5
++  Line Range:                  14
++  Opcode Base:                 10
++  \(Pointer size:               4\)
++
++ Opcodes:
++  Opcode 1 has 0 args
++  Opcode 2 has 1 args
++  Opcode 3 has 1 args
++  Opcode 4 has 1 args
++  Opcode 5 has 1 args
++  Opcode 6 has 0 args
++  Opcode 7 has 0 args
++  Opcode 8 has 0 args
++  Opcode 9 has 1 args
++
++ The Directory Table is empty\.
++
++ The File Name Table:
++  Entry       Dir     Time    Size    Name
++  1   0       0       0       main\.c
++
++ Line Number Statements:
++  Extended opcode 2: set Address to 0x0
++  Advance Line by 87 to 88
++  Copy
++  Advance Line by 23 to 111
++  Special opcode .*: advance Address by 4 to 0x4 and Line by 0 to 111
++  Special opcode .*: advance Address by 10 to 0xe and Line by 1 to 112
++  Advance PC by 530 to 220
++  Extended opcode 1: End of Sequence
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/dwarf2.s binutils-2.17-atmel/gas/testsuite/gas/avr32/dwarf2.s
+--- binutils-2.17/gas/testsuite/gas/avr32/dwarf2.s     1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/dwarf2.s       2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,67 @@
++# Source file used to test DWARF2 information for AVR32.
++
++      .file   "main.c"
++
++      .section .debug_abbrev,"",@progbits
++.Ldebug_abbrev0:
++      .section .debug_info,"",@progbits
++.Ldebug_info0:
++      .section .debug_line,"",@progbits
++.Ldebug_line0:
++
++      .text
++      .align  1
++      .globl  main
++      .type   main, @function
++.Ltext0:
++main:
++      .file 1 "main.c"
++      .loc 1 88 0
++      pushm   r0-r7,lr
++      sub     sp, 4
++      .loc 1 111 0
++      lddpc   r12, .LC1
++      lddpc   r7, .LC1
++      icall   r7
++      .loc 1 112 0
++      lddpc   r6, .LC4
++
++      .align  2
++.LC4: .int    0
++
++      .fill   256, 2, 0
++
++      .align  2
++.LC1:
++      .int    0
++.LC2:
++      .int    0
++.LC3:
++      .int    0
++      .size   main, . - main
++
++.Letext0:
++
++      .section .debug_info
++      .int    .Ledebug_info0 - .Ldebug_info0  // size
++      .short  2                               // version
++      .int    .Ldebug_abbrev0                 // abbrev offset
++      .byte   4                               // bytes per addr
++
++      .uleb128 1                              // abbrev 1
++      .int    .Ldebug_line0                   // DW_AT_stmt_list
++      .int    .Letext0                        // DW_AT_high_pc
++      .int    .Ltext0                         // DW_AT_low_pc
++
++.Ledebug_info0:
++
++      .section .debug_abbrev
++      .uleb128 0x01
++      .uleb128 0x11           // DW_TAG_compile_unit
++      .byte   0               // DW_CHILDREN_no
++      .uleb128 0x10, 0x6      // DW_AT_stmt_list
++      .uleb128 0x12, 0x1      // DW_AT_high_pc
++      .uleb128 0x11, 0x1      // DW_AT_low_pc
++      .uleb128 0, 0
++
++      .byte   0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/fpinsn.d binutils-2.17-atmel/gas/testsuite/gas/avr32/fpinsn.d
+--- binutils-2.17/gas/testsuite/gas/avr32/fpinsn.d     1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/fpinsn.d       2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,271 @@
++#as:
++#objdump: -dr
++#name: fpinsn
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++[0-9a-f]* <fadd_s>:
++ *[0-9a-f]*:  e1 a2 0f ff     cop cp0,cr15,cr15,cr15,0x4
++ *[0-9a-f]*:  e1 a2 00 00     cop cp0,cr0,cr0,cr0,0x4
++ *[0-9a-f]*:  e1 a2 00 ff     cop cp0,cr0,cr15,cr15,0x4
++ *[0-9a-f]*:  e1 a2 0f 0f     cop cp0,cr15,cr0,cr15,0x4
++ *[0-9a-f]*:  e1 a2 0f f0     cop cp0,cr15,cr15,cr0,0x4
++ *[0-9a-f]*:  e1 a2 07 88     cop cp0,cr7,cr8,cr8,0x4
++ *[0-9a-f]*:  e1 a2 08 78     cop cp0,cr8,cr7,cr8,0x4
++ *[0-9a-f]*:  e1 a2 08 87     cop cp0,cr8,cr8,cr7,0x4
++
++[0-9a-f]* <fsub_s>:
++ *[0-9a-f]*:  e1 a2 1f ff     cop cp0,cr15,cr15,cr15,0x5
++ *[0-9a-f]*:  e1 a2 10 00     cop cp0,cr0,cr0,cr0,0x5
++ *[0-9a-f]*:  e1 a2 10 ff     cop cp0,cr0,cr15,cr15,0x5
++ *[0-9a-f]*:  e1 a2 1f 0f     cop cp0,cr15,cr0,cr15,0x5
++ *[0-9a-f]*:  e1 a2 1f f0     cop cp0,cr15,cr15,cr0,0x5
++ *[0-9a-f]*:  e1 a2 17 88     cop cp0,cr7,cr8,cr8,0x5
++ *[0-9a-f]*:  e1 a2 18 78     cop cp0,cr8,cr7,cr8,0x5
++ *[0-9a-f]*:  e1 a2 18 87     cop cp0,cr8,cr8,cr7,0x5
++
++[0-9a-f]* <fmac_s>:
++ *[0-9a-f]*:  e1 a0 0f ff     cop cp0,cr15,cr15,cr15,0x0
++ *[0-9a-f]*:  e1 a0 00 00     cop cp0,cr0,cr0,cr0,0x0
++ *[0-9a-f]*:  e1 a0 00 ff     cop cp0,cr0,cr15,cr15,0x0
++ *[0-9a-f]*:  e1 a0 0f 0f     cop cp0,cr15,cr0,cr15,0x0
++ *[0-9a-f]*:  e1 a0 0f f0     cop cp0,cr15,cr15,cr0,0x0
++ *[0-9a-f]*:  e1 a0 07 88     cop cp0,cr7,cr8,cr8,0x0
++ *[0-9a-f]*:  e1 a0 08 78     cop cp0,cr8,cr7,cr8,0x0
++ *[0-9a-f]*:  e1 a0 08 87     cop cp0,cr8,cr8,cr7,0x0
++
++[0-9a-f]* <fnmac_s>:
++ *[0-9a-f]*:  e1 a0 1f ff     cop cp0,cr15,cr15,cr15,0x1
++ *[0-9a-f]*:  e1 a0 10 00     cop cp0,cr0,cr0,cr0,0x1
++ *[0-9a-f]*:  e1 a0 10 ff     cop cp0,cr0,cr15,cr15,0x1
++ *[0-9a-f]*:  e1 a0 1f 0f     cop cp0,cr15,cr0,cr15,0x1
++ *[0-9a-f]*:  e1 a0 1f f0     cop cp0,cr15,cr15,cr0,0x1
++ *[0-9a-f]*:  e1 a0 17 88     cop cp0,cr7,cr8,cr8,0x1
++ *[0-9a-f]*:  e1 a0 18 78     cop cp0,cr8,cr7,cr8,0x1
++ *[0-9a-f]*:  e1 a0 18 87     cop cp0,cr8,cr8,cr7,0x1
++
++[0-9a-f]* <fmsc_s>:
++ *[0-9a-f]*:  e1 a1 0f ff     cop cp0,cr15,cr15,cr15,0x2
++ *[0-9a-f]*:  e1 a1 00 00     cop cp0,cr0,cr0,cr0,0x2
++ *[0-9a-f]*:  e1 a1 00 ff     cop cp0,cr0,cr15,cr15,0x2
++ *[0-9a-f]*:  e1 a1 0f 0f     cop cp0,cr15,cr0,cr15,0x2
++ *[0-9a-f]*:  e1 a1 0f f0     cop cp0,cr15,cr15,cr0,0x2
++ *[0-9a-f]*:  e1 a1 07 88     cop cp0,cr7,cr8,cr8,0x2
++ *[0-9a-f]*:  e1 a1 08 78     cop cp0,cr8,cr7,cr8,0x2
++ *[0-9a-f]*:  e1 a1 08 87     cop cp0,cr8,cr8,cr7,0x2
++
++[0-9a-f]* <fnmsc_s>:
++ *[0-9a-f]*:  e1 a1 1f ff     cop cp0,cr15,cr15,cr15,0x3
++ *[0-9a-f]*:  e1 a1 10 00     cop cp0,cr0,cr0,cr0,0x3
++ *[0-9a-f]*:  e1 a1 10 ff     cop cp0,cr0,cr15,cr15,0x3
++ *[0-9a-f]*:  e1 a1 1f 0f     cop cp0,cr15,cr0,cr15,0x3
++ *[0-9a-f]*:  e1 a1 1f f0     cop cp0,cr15,cr15,cr0,0x3
++ *[0-9a-f]*:  e1 a1 17 88     cop cp0,cr7,cr8,cr8,0x3
++ *[0-9a-f]*:  e1 a1 18 78     cop cp0,cr8,cr7,cr8,0x3
++ *[0-9a-f]*:  e1 a1 18 87     cop cp0,cr8,cr8,cr7,0x3
++
++[0-9a-f]* <fmul_s>:
++ *[0-9a-f]*:  e1 a3 0f ff     cop cp0,cr15,cr15,cr15,0x6
++ *[0-9a-f]*:  e1 a3 00 00     cop cp0,cr0,cr0,cr0,0x6
++ *[0-9a-f]*:  e1 a3 00 ff     cop cp0,cr0,cr15,cr15,0x6
++ *[0-9a-f]*:  e1 a3 0f 0f     cop cp0,cr15,cr0,cr15,0x6
++ *[0-9a-f]*:  e1 a3 0f f0     cop cp0,cr15,cr15,cr0,0x6
++ *[0-9a-f]*:  e1 a3 07 88     cop cp0,cr7,cr8,cr8,0x6
++ *[0-9a-f]*:  e1 a3 08 78     cop cp0,cr8,cr7,cr8,0x6
++ *[0-9a-f]*:  e1 a3 08 87     cop cp0,cr8,cr8,cr7,0x6
++
++[0-9a-f]* <fnmul_s>:
++ *[0-9a-f]*:  e1 a3 1f ff     cop cp0,cr15,cr15,cr15,0x7
++ *[0-9a-f]*:  e1 a3 10 00     cop cp0,cr0,cr0,cr0,0x7
++ *[0-9a-f]*:  e1 a3 10 ff     cop cp0,cr0,cr15,cr15,0x7
++ *[0-9a-f]*:  e1 a3 1f 0f     cop cp0,cr15,cr0,cr15,0x7
++ *[0-9a-f]*:  e1 a3 1f f0     cop cp0,cr15,cr15,cr0,0x7
++ *[0-9a-f]*:  e1 a3 17 88     cop cp0,cr7,cr8,cr8,0x7
++ *[0-9a-f]*:  e1 a3 18 78     cop cp0,cr8,cr7,cr8,0x7
++ *[0-9a-f]*:  e1 a3 18 87     cop cp0,cr8,cr8,cr7,0x7
++
++[0-9a-f]* <fneg_s>:
++ *[0-9a-f]*:  e1 a4 0f f0     cop cp0,cr15,cr15,cr0,0x8
++ *[0-9a-f]*:  e1 a4 00 00     cop cp0,cr0,cr0,cr0,0x8
++ *[0-9a-f]*:  e1 a4 00 f0     cop cp0,cr0,cr15,cr0,0x8
++ *[0-9a-f]*:  e1 a4 0f 00     cop cp0,cr15,cr0,cr0,0x8
++ *[0-9a-f]*:  e1 a4 07 80     cop cp0,cr7,cr8,cr0,0x8
++ *[0-9a-f]*:  e1 a4 08 70     cop cp0,cr8,cr7,cr0,0x8
++
++[0-9a-f]* <fabs_s>:
++ *[0-9a-f]*:  e1 a4 1f f0     cop cp0,cr15,cr15,cr0,0x9
++ *[0-9a-f]*:  e1 a4 10 00     cop cp0,cr0,cr0,cr0,0x9
++ *[0-9a-f]*:  e1 a4 10 f0     cop cp0,cr0,cr15,cr0,0x9
++ *[0-9a-f]*:  e1 a4 1f 00     cop cp0,cr15,cr0,cr0,0x9
++ *[0-9a-f]*:  e1 a4 17 80     cop cp0,cr7,cr8,cr0,0x9
++ *[0-9a-f]*:  e1 a4 18 70     cop cp0,cr8,cr7,cr0,0x9
++
++[0-9a-f]* <fcmp_s>:
++ *[0-9a-f]*:  e1 a6 10 ff     cop cp0,cr0,cr15,cr15,0xd
++ *[0-9a-f]*:  e1 a6 10 00     cop cp0,cr0,cr0,cr0,0xd
++ *[0-9a-f]*:  e1 a6 10 0f     cop cp0,cr0,cr0,cr15,0xd
++ *[0-9a-f]*:  e1 a6 10 f0     cop cp0,cr0,cr15,cr0,0xd
++ *[0-9a-f]*:  e1 a6 10 78     cop cp0,cr0,cr7,cr8,0xd
++ *[0-9a-f]*:  e1 a6 10 87     cop cp0,cr0,cr8,cr7,0xd
++
++[0-9a-f]* <fadd_d>:
++ *[0-9a-f]*:  e5 a2 0e ee     cop cp0,cr14,cr14,cr14,0x44
++ *[0-9a-f]*:  e5 a2 00 00     cop cp0,cr0,cr0,cr0,0x44
++ *[0-9a-f]*:  e5 a2 00 ee     cop cp0,cr0,cr14,cr14,0x44
++ *[0-9a-f]*:  e5 a2 0e 0e     cop cp0,cr14,cr0,cr14,0x44
++ *[0-9a-f]*:  e5 a2 0e e0     cop cp0,cr14,cr14,cr0,0x44
++ *[0-9a-f]*:  e5 a2 06 88     cop cp0,cr6,cr8,cr8,0x44
++ *[0-9a-f]*:  e5 a2 08 68     cop cp0,cr8,cr6,cr8,0x44
++ *[0-9a-f]*:  e5 a2 08 86     cop cp0,cr8,cr8,cr6,0x44
++
++[0-9a-f]* <fsub_d>:
++ *[0-9a-f]*:  e5 a2 1e ee     cop cp0,cr14,cr14,cr14,0x45
++ *[0-9a-f]*:  e5 a2 10 00     cop cp0,cr0,cr0,cr0,0x45
++ *[0-9a-f]*:  e5 a2 10 ee     cop cp0,cr0,cr14,cr14,0x45
++ *[0-9a-f]*:  e5 a2 1e 0e     cop cp0,cr14,cr0,cr14,0x45
++ *[0-9a-f]*:  e5 a2 1e e0     cop cp0,cr14,cr14,cr0,0x45
++ *[0-9a-f]*:  e5 a2 16 88     cop cp0,cr6,cr8,cr8,0x45
++ *[0-9a-f]*:  e5 a2 18 68     cop cp0,cr8,cr6,cr8,0x45
++ *[0-9a-f]*:  e5 a2 18 86     cop cp0,cr8,cr8,cr6,0x45
++
++[0-9a-f]* <fmac_d>:
++ *[0-9a-f]*:  e5 a0 0e ee     cop cp0,cr14,cr14,cr14,0x40
++ *[0-9a-f]*:  e5 a0 00 00     cop cp0,cr0,cr0,cr0,0x40
++ *[0-9a-f]*:  e5 a0 00 ee     cop cp0,cr0,cr14,cr14,0x40
++ *[0-9a-f]*:  e5 a0 0e 0e     cop cp0,cr14,cr0,cr14,0x40
++ *[0-9a-f]*:  e5 a0 0e e0     cop cp0,cr14,cr14,cr0,0x40
++ *[0-9a-f]*:  e5 a0 06 88     cop cp0,cr6,cr8,cr8,0x40
++ *[0-9a-f]*:  e5 a0 08 68     cop cp0,cr8,cr6,cr8,0x40
++ *[0-9a-f]*:  e5 a0 08 86     cop cp0,cr8,cr8,cr6,0x40
++
++[0-9a-f]* <fnmac_d>:
++ *[0-9a-f]*:  e5 a0 1e ee     cop cp0,cr14,cr14,cr14,0x41
++ *[0-9a-f]*:  e5 a0 10 00     cop cp0,cr0,cr0,cr0,0x41
++ *[0-9a-f]*:  e5 a0 10 ee     cop cp0,cr0,cr14,cr14,0x41
++ *[0-9a-f]*:  e5 a0 1e 0e     cop cp0,cr14,cr0,cr14,0x41
++ *[0-9a-f]*:  e5 a0 1e e0     cop cp0,cr14,cr14,cr0,0x41
++ *[0-9a-f]*:  e5 a0 16 88     cop cp0,cr6,cr8,cr8,0x41
++ *[0-9a-f]*:  e5 a0 18 68     cop cp0,cr8,cr6,cr8,0x41
++ *[0-9a-f]*:  e5 a0 18 86     cop cp0,cr8,cr8,cr6,0x41
++
++[0-9a-f]* <fmsc_d>:
++ *[0-9a-f]*:  e5 a1 0e ee     cop cp0,cr14,cr14,cr14,0x42
++ *[0-9a-f]*:  e5 a1 00 00     cop cp0,cr0,cr0,cr0,0x42
++ *[0-9a-f]*:  e5 a1 00 ee     cop cp0,cr0,cr14,cr14,0x42
++ *[0-9a-f]*:  e5 a1 0e 0e     cop cp0,cr14,cr0,cr14,0x42
++ *[0-9a-f]*:  e5 a1 0e e0     cop cp0,cr14,cr14,cr0,0x42
++ *[0-9a-f]*:  e5 a1 06 88     cop cp0,cr6,cr8,cr8,0x42
++ *[0-9a-f]*:  e5 a1 08 68     cop cp0,cr8,cr6,cr8,0x42
++ *[0-9a-f]*:  e5 a1 08 86     cop cp0,cr8,cr8,cr6,0x42
++
++[0-9a-f]* <fnmsc_d>:
++ *[0-9a-f]*:  e5 a1 1e ee     cop cp0,cr14,cr14,cr14,0x43
++ *[0-9a-f]*:  e5 a1 10 00     cop cp0,cr0,cr0,cr0,0x43
++ *[0-9a-f]*:  e5 a1 10 ee     cop cp0,cr0,cr14,cr14,0x43
++ *[0-9a-f]*:  e5 a1 1e 0e     cop cp0,cr14,cr0,cr14,0x43
++ *[0-9a-f]*:  e5 a1 1e e0     cop cp0,cr14,cr14,cr0,0x43
++ *[0-9a-f]*:  e5 a1 16 88     cop cp0,cr6,cr8,cr8,0x43
++ *[0-9a-f]*:  e5 a1 18 68     cop cp0,cr8,cr6,cr8,0x43
++ *[0-9a-f]*:  e5 a1 18 86     cop cp0,cr8,cr8,cr6,0x43
++
++[0-9a-f]* <fmul_d>:
++ *[0-9a-f]*:  e5 a3 0e ee     cop cp0,cr14,cr14,cr14,0x46
++ *[0-9a-f]*:  e5 a3 00 00     cop cp0,cr0,cr0,cr0,0x46
++ *[0-9a-f]*:  e5 a3 00 ee     cop cp0,cr0,cr14,cr14,0x46
++ *[0-9a-f]*:  e5 a3 0e 0e     cop cp0,cr14,cr0,cr14,0x46
++ *[0-9a-f]*:  e5 a3 0e e0     cop cp0,cr14,cr14,cr0,0x46
++ *[0-9a-f]*:  e5 a3 06 88     cop cp0,cr6,cr8,cr8,0x46
++ *[0-9a-f]*:  e5 a3 08 68     cop cp0,cr8,cr6,cr8,0x46
++ *[0-9a-f]*:  e5 a3 08 86     cop cp0,cr8,cr8,cr6,0x46
++
++[0-9a-f]* <fnmul_d>:
++ *[0-9a-f]*:  e5 a3 1e ee     cop cp0,cr14,cr14,cr14,0x47
++ *[0-9a-f]*:  e5 a3 10 00     cop cp0,cr0,cr0,cr0,0x47
++ *[0-9a-f]*:  e5 a3 10 ee     cop cp0,cr0,cr14,cr14,0x47
++ *[0-9a-f]*:  e5 a3 1e 0e     cop cp0,cr14,cr0,cr14,0x47
++ *[0-9a-f]*:  e5 a3 1e e0     cop cp0,cr14,cr14,cr0,0x47
++ *[0-9a-f]*:  e5 a3 16 88     cop cp0,cr6,cr8,cr8,0x47
++ *[0-9a-f]*:  e5 a3 18 68     cop cp0,cr8,cr6,cr8,0x47
++ *[0-9a-f]*:  e5 a3 18 86     cop cp0,cr8,cr8,cr6,0x47
++
++[0-9a-f]* <fneg_d>:
++ *[0-9a-f]*:  e5 a4 0e e0     cop cp0,cr14,cr14,cr0,0x48
++ *[0-9a-f]*:  e5 a4 00 00     cop cp0,cr0,cr0,cr0,0x48
++ *[0-9a-f]*:  e5 a4 00 e0     cop cp0,cr0,cr14,cr0,0x48
++ *[0-9a-f]*:  e5 a4 0e 00     cop cp0,cr14,cr0,cr0,0x48
++ *[0-9a-f]*:  e5 a4 06 80     cop cp0,cr6,cr8,cr0,0x48
++ *[0-9a-f]*:  e5 a4 08 60     cop cp0,cr8,cr6,cr0,0x48
++
++[0-9a-f]* <fabs_d>:
++ *[0-9a-f]*:  e5 a4 1e e0     cop cp0,cr14,cr14,cr0,0x49
++ *[0-9a-f]*:  e5 a4 10 00     cop cp0,cr0,cr0,cr0,0x49
++ *[0-9a-f]*:  e5 a4 10 e0     cop cp0,cr0,cr14,cr0,0x49
++ *[0-9a-f]*:  e5 a4 1e 00     cop cp0,cr14,cr0,cr0,0x49
++ *[0-9a-f]*:  e5 a4 16 80     cop cp0,cr6,cr8,cr0,0x49
++ *[0-9a-f]*:  e5 a4 18 60     cop cp0,cr8,cr6,cr0,0x49
++
++[0-9a-f]* <fcmp_d>:
++ *[0-9a-f]*:  e5 a6 10 ee     cop cp0,cr0,cr14,cr14,0x4d
++ *[0-9a-f]*:  e5 a6 10 00     cop cp0,cr0,cr0,cr0,0x4d
++ *[0-9a-f]*:  e5 a6 10 0e     cop cp0,cr0,cr0,cr14,0x4d
++ *[0-9a-f]*:  e5 a6 10 e0     cop cp0,cr0,cr14,cr0,0x4d
++ *[0-9a-f]*:  e5 a6 10 68     cop cp0,cr0,cr6,cr8,0x4d
++ *[0-9a-f]*:  e5 a6 10 86     cop cp0,cr0,cr8,cr6,0x4d
++
++[0-9a-f]* <fmov_s>:
++ *[0-9a-f]*:  e1 a5 0f f0     cop cp0,cr15,cr15,cr0,0xa
++ *[0-9a-f]*:  e1 a5 00 00     cop cp0,cr0,cr0,cr0,0xa
++ *[0-9a-f]*:  e1 a5 0f 00     cop cp0,cr15,cr0,cr0,0xa
++ *[0-9a-f]*:  e1 a5 00 f0     cop cp0,cr0,cr15,cr0,0xa
++ *[0-9a-f]*:  e1 a5 08 70     cop cp0,cr8,cr7,cr0,0xa
++ *[0-9a-f]*:  e1 a5 07 80     cop cp0,cr7,cr8,cr0,0xa
++ *[0-9a-f]*:  ef af 0f 00     mvcr.w cp0,pc,cr15
++ *[0-9a-f]*:  ef a0 00 00     mvcr.w cp0,r0,cr0
++ *[0-9a-f]*:  ef af 00 00     mvcr.w cp0,pc,cr0
++ *[0-9a-f]*:  ef a0 0f 00     mvcr.w cp0,r0,cr15
++ *[0-9a-f]*:  ef a8 07 00     mvcr.w cp0,r8,cr7
++ *[0-9a-f]*:  ef a7 08 00     mvcr.w cp0,r7,cr8
++ *[0-9a-f]*:  ef af 0f 20     mvrc.w cp0,cr15,pc
++ *[0-9a-f]*:  ef a0 00 20     mvrc.w cp0,cr0,r0
++ *[0-9a-f]*:  ef a0 0f 20     mvrc.w cp0,cr15,r0
++ *[0-9a-f]*:  ef af 00 20     mvrc.w cp0,cr0,pc
++ *[0-9a-f]*:  ef a7 08 20     mvrc.w cp0,cr8,r7
++ *[0-9a-f]*:  ef a8 07 20     mvrc.w cp0,cr7,r8
++
++[0-9a-f]* <fmov_d>:
++ *[0-9a-f]*:  e5 a5 0e e0     cop cp0,cr14,cr14,cr0,0x4a
++ *[0-9a-f]*:  e5 a5 00 00     cop cp0,cr0,cr0,cr0,0x4a
++ *[0-9a-f]*:  e5 a5 0e 00     cop cp0,cr14,cr0,cr0,0x4a
++ *[0-9a-f]*:  e5 a5 00 e0     cop cp0,cr0,cr14,cr0,0x4a
++ *[0-9a-f]*:  e5 a5 08 60     cop cp0,cr8,cr6,cr0,0x4a
++ *[0-9a-f]*:  e5 a5 06 80     cop cp0,cr6,cr8,cr0,0x4a
++ *[0-9a-f]*:  ef ae 0e 10     mvcr.d cp0,lr,cr14
++ *[0-9a-f]*:  ef a0 00 10     mvcr.d cp0,r0,cr0
++ *[0-9a-f]*:  ef ae 00 10     mvcr.d cp0,lr,cr0
++ *[0-9a-f]*:  ef a0 0e 10     mvcr.d cp0,r0,cr14
++ *[0-9a-f]*:  ef a8 06 10     mvcr.d cp0,r8,cr6
++ *[0-9a-f]*:  ef a6 08 10     mvcr.d cp0,r6,cr8
++ *[0-9a-f]*:  ef ae 0e 30     mvrc.d cp0,cr14,lr
++ *[0-9a-f]*:  ef a0 00 30     mvrc.d cp0,cr0,r0
++ *[0-9a-f]*:  ef a0 0e 30     mvrc.d cp0,cr14,r0
++ *[0-9a-f]*:  ef ae 00 30     mvrc.d cp0,cr0,lr
++ *[0-9a-f]*:  ef a6 08 30     mvrc.d cp0,cr8,r6
++ *[0-9a-f]*:  ef a8 06 30     mvrc.d cp0,cr6,r8
++
++[0-9a-f]* <fcasts_d>:
++ *[0-9a-f]*:  e1 a7 1f e0     cop cp0,cr15,cr14,cr0,0xf
++ *[0-9a-f]*:  e1 a7 10 00     cop cp0,cr0,cr0,cr0,0xf
++ *[0-9a-f]*:  e1 a7 1f 00     cop cp0,cr15,cr0,cr0,0xf
++ *[0-9a-f]*:  e1 a7 10 e0     cop cp0,cr0,cr14,cr0,0xf
++ *[0-9a-f]*:  e1 a7 18 60     cop cp0,cr8,cr6,cr0,0xf
++ *[0-9a-f]*:  e1 a7 17 80     cop cp0,cr7,cr8,cr0,0xf
++
++[0-9a-f]* <fcastd_s>:
++ *[0-9a-f]*:  e1 a8 0e f0     cop cp0,cr14,cr15,cr0,0x10
++ *[0-9a-f]*:  e1 a8 00 00     cop cp0,cr0,cr0,cr0,0x10
++ *[0-9a-f]*:  e1 a8 0e 00     cop cp0,cr14,cr0,cr0,0x10
++ *[0-9a-f]*:  e1 a8 00 f0     cop cp0,cr0,cr15,cr0,0x10
++ *[0-9a-f]*:  e1 a8 08 70     cop cp0,cr8,cr7,cr0,0x10
++ *[0-9a-f]*:  e1 a8 06 80     cop cp0,cr6,cr8,cr0,0x10
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/fpinsn.s binutils-2.17-atmel/gas/testsuite/gas/avr32/fpinsn.s
+--- binutils-2.17/gas/testsuite/gas/avr32/fpinsn.s     1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/fpinsn.s       2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,266 @@
++
++      .text
++      .global fadd_s
++fadd_s:
++      fadd.s fr15, fr15, fr15
++      fadd.s fr0, fr0, fr0
++      fadd.s fr0, fr15, fr15
++      fadd.s fr15, fr0, fr15
++      fadd.s fr15, fr15, fr0
++      fadd.s fr7, fr8, fr8
++      fadd.s fr8, fr7, fr8
++      fadd.s fr8, fr8, fr7
++      .global fsub_s
++fsub_s:
++      fsub.s fr15, fr15, fr15
++      fsub.s fr0, fr0, fr0
++      fsub.s fr0, fr15, fr15
++      fsub.s fr15, fr0, fr15
++      fsub.s fr15, fr15, fr0
++      fsub.s fr7, fr8, fr8
++      fsub.s fr8, fr7, fr8
++      fsub.s fr8, fr8, fr7
++      .global fmac_s
++fmac_s:
++      fmac.s fr15, fr15, fr15
++      fmac.s fr0, fr0, fr0
++      fmac.s fr0, fr15, fr15
++      fmac.s fr15, fr0, fr15
++      fmac.s fr15, fr15, fr0
++      fmac.s fr7, fr8, fr8
++      fmac.s fr8, fr7, fr8
++      fmac.s fr8, fr8, fr7
++      .global fnmac_s
++fnmac_s:
++      fnmac.s fr15, fr15, fr15
++      fnmac.s fr0, fr0, fr0
++      fnmac.s fr0, fr15, fr15
++      fnmac.s fr15, fr0, fr15
++      fnmac.s fr15, fr15, fr0
++      fnmac.s fr7, fr8, fr8
++      fnmac.s fr8, fr7, fr8
++      fnmac.s fr8, fr8, fr7
++      .global fmsc_s
++fmsc_s:
++      fmsc.s fr15, fr15, fr15
++      fmsc.s fr0, fr0, fr0
++      fmsc.s fr0, fr15, fr15
++      fmsc.s fr15, fr0, fr15
++      fmsc.s fr15, fr15, fr0
++      fmsc.s fr7, fr8, fr8
++      fmsc.s fr8, fr7, fr8
++      fmsc.s fr8, fr8, fr7
++      .global fnmsc_s
++fnmsc_s:
++      fnmsc.s fr15, fr15, fr15
++      fnmsc.s fr0, fr0, fr0
++      fnmsc.s fr0, fr15, fr15
++      fnmsc.s fr15, fr0, fr15
++      fnmsc.s fr15, fr15, fr0
++      fnmsc.s fr7, fr8, fr8
++      fnmsc.s fr8, fr7, fr8
++      fnmsc.s fr8, fr8, fr7
++      .global fmul_s
++fmul_s:
++      fmul.s fr15, fr15, fr15
++      fmul.s fr0, fr0, fr0
++      fmul.s fr0, fr15, fr15
++      fmul.s fr15, fr0, fr15
++      fmul.s fr15, fr15, fr0
++      fmul.s fr7, fr8, fr8
++      fmul.s fr8, fr7, fr8
++      fmul.s fr8, fr8, fr7
++      .global fnmul_s
++fnmul_s:
++      fnmul.s fr15, fr15, fr15
++      fnmul.s fr0, fr0, fr0
++      fnmul.s fr0, fr15, fr15
++      fnmul.s fr15, fr0, fr15
++      fnmul.s fr15, fr15, fr0
++      fnmul.s fr7, fr8, fr8
++      fnmul.s fr8, fr7, fr8
++      fnmul.s fr8, fr8, fr7
++      .global fneg_s
++fneg_s:
++      fneg.s fr15, fr15
++      fneg.s fr0, fr0
++      fneg.s fr0, fr15
++      fneg.s fr15, fr0
++      fneg.s fr7, fr8
++      fneg.s fr8, fr7
++      .global fabs_s
++fabs_s:
++      fabs.s fr15, fr15
++      fabs.s fr0, fr0
++      fabs.s fr0, fr15
++      fabs.s fr15, fr0
++      fabs.s fr7, fr8
++      fabs.s fr8, fr7
++      .global fcmp_s
++fcmp_s:
++      fcmp.s fr15, fr15
++      fcmp.s fr0, fr0
++      fcmp.s fr0, fr15
++      fcmp.s fr15, fr0
++      fcmp.s fr7, fr8
++      fcmp.s fr8, fr7
++      .global fadd_d
++fadd_d:
++      fadd.d fr14, fr14, fr14
++      fadd.d fr0, fr0, fr0
++      fadd.d fr0, fr14, fr14
++      fadd.d fr14, fr0, fr14
++      fadd.d fr14, fr14, fr0
++      fadd.d fr6, fr8, fr8
++      fadd.d fr8, fr6, fr8
++      fadd.d fr8, fr8, fr6
++      .global fsub_d
++fsub_d:
++      fsub.d fr14, fr14, fr14
++      fsub.d fr0, fr0, fr0
++      fsub.d fr0, fr14, fr14
++      fsub.d fr14, fr0, fr14
++      fsub.d fr14, fr14, fr0
++      fsub.d fr6, fr8, fr8
++      fsub.d fr8, fr6, fr8
++      fsub.d fr8, fr8, fr6
++      .global fmac_d
++fmac_d:
++      fmac.d fr14, fr14, fr14
++      fmac.d fr0, fr0, fr0
++      fmac.d fr0, fr14, fr14
++      fmac.d fr14, fr0, fr14
++      fmac.d fr14, fr14, fr0
++      fmac.d fr6, fr8, fr8
++      fmac.d fr8, fr6, fr8
++      fmac.d fr8, fr8, fr6
++      .global fnmac_d
++fnmac_d:
++      fnmac.d fr14, fr14, fr14
++      fnmac.d fr0, fr0, fr0
++      fnmac.d fr0, fr14, fr14
++      fnmac.d fr14, fr0, fr14
++      fnmac.d fr14, fr14, fr0
++      fnmac.d fr6, fr8, fr8
++      fnmac.d fr8, fr6, fr8
++      fnmac.d fr8, fr8, fr6
++      .global fmsc_d
++fmsc_d:
++      fmsc.d fr14, fr14, fr14
++      fmsc.d fr0, fr0, fr0
++      fmsc.d fr0, fr14, fr14
++      fmsc.d fr14, fr0, fr14
++      fmsc.d fr14, fr14, fr0
++      fmsc.d fr6, fr8, fr8
++      fmsc.d fr8, fr6, fr8
++      fmsc.d fr8, fr8, fr6
++      .global fnmsc_d
++fnmsc_d:
++      fnmsc.d fr14, fr14, fr14
++      fnmsc.d fr0, fr0, fr0
++      fnmsc.d fr0, fr14, fr14
++      fnmsc.d fr14, fr0, fr14
++      fnmsc.d fr14, fr14, fr0
++      fnmsc.d fr6, fr8, fr8
++      fnmsc.d fr8, fr6, fr8
++      fnmsc.d fr8, fr8, fr6
++      .global fmul_d
++fmul_d:
++      fmul.d fr14, fr14, fr14
++      fmul.d fr0, fr0, fr0
++      fmul.d fr0, fr14, fr14
++      fmul.d fr14, fr0, fr14
++      fmul.d fr14, fr14, fr0
++      fmul.d fr6, fr8, fr8
++      fmul.d fr8, fr6, fr8
++      fmul.d fr8, fr8, fr6
++      .global fnmul_d
++fnmul_d:
++      fnmul.d fr14, fr14, fr14
++      fnmul.d fr0, fr0, fr0
++      fnmul.d fr0, fr14, fr14
++      fnmul.d fr14, fr0, fr14
++      fnmul.d fr14, fr14, fr0
++      fnmul.d fr6, fr8, fr8
++      fnmul.d fr8, fr6, fr8
++      fnmul.d fr8, fr8, fr6
++      .global fneg_d
++fneg_d:
++      fneg.d fr14, fr14
++      fneg.d fr0, fr0
++      fneg.d fr0, fr14
++      fneg.d fr14, fr0
++      fneg.d fr6, fr8
++      fneg.d fr8, fr6
++      .global fabs_d
++fabs_d:
++      fabs.d fr14, fr14
++      fabs.d fr0, fr0
++      fabs.d fr0, fr14
++      fabs.d fr14, fr0
++      fabs.d fr6, fr8
++      fabs.d fr8, fr6
++      .global fcmp_d
++fcmp_d:
++      fcmp.d fr14, fr14
++      fcmp.d fr0, fr0
++      fcmp.d fr0, fr14
++      fcmp.d fr14, fr0
++      fcmp.d fr6, fr8
++      fcmp.d fr8, fr6
++      .global fmov_s
++fmov_s:
++      fmov.s fr15, fr15
++      fmov.s fr0, fr0
++      fmov.s fr15, fr0
++      fmov.s fr0, fr15
++      fmov.s fr8, fr7
++      fmov.s fr7, fr8
++      fmov.s pc, fr15
++      fmov.s r0, fr0
++      fmov.s pc, fr0
++      fmov.s r0, fr15
++      fmov.s r8, fr7
++      fmov.s r7, fr8
++      fmov.s fr15, pc
++      fmov.s fr0, r0
++      fmov.s fr15, r0
++      fmov.s fr0, pc
++      fmov.s fr8, r7
++      fmov.s fr7, r8
++      .global fmov_d
++fmov_d:
++      fmov.d fr14, fr14
++      fmov.d fr0, fr0
++      fmov.d fr14, fr0
++      fmov.d fr0, fr14
++      fmov.d fr8, fr6
++      fmov.d fr6, fr8
++      fmov.d lr, fr14
++      fmov.d r0, fr0
++      fmov.d lr, fr0
++      fmov.d r0, fr14
++      fmov.d r8, fr6
++      fmov.d r6, fr8
++      fmov.d fr14, lr
++      fmov.d fr0, r0
++      fmov.d fr14, r0
++      fmov.d fr0, lr
++      fmov.d fr8, r6
++      fmov.d fr6, r8
++      .global fcasts_d
++fcasts_d:
++      fcasts.d fr15, fr14
++      fcasts.d fr0, fr0
++      fcasts.d fr15, fr0
++      fcasts.d fr0, fr14
++      fcasts.d fr8, fr6
++      fcasts.d fr7, fr8
++      .global fcastd_s
++fcastd_s:
++      fcastd.s fr14, fr15
++      fcastd.s fr0, fr0
++      fcastd.s fr14, fr0
++      fcastd.s fr0, fr15
++      fcastd.s fr8, fr7
++      fcastd.s fr6, fr8
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/hwrd-lwrd.d binutils-2.17-atmel/gas/testsuite/gas/avr32/hwrd-lwrd.d
+--- binutils-2.17/gas/testsuite/gas/avr32/hwrd-lwrd.d  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/hwrd-lwrd.d    2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,47 @@
++#as:
++#objdump: -dr
++#name: hwrd-lwrd
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <test_hwrd>:
++   0: e0 60 87 65     mov r0,34661
++   4: e0 60 12 34     mov r0,4660
++   8: e0 60 00 00     mov r0,0
++                      8: R_AVR32_HI16 \.text\+0x60
++   c: e0 60 00 00     mov r0,0
++                      c: R_AVR32_HI16 extsym1
++  10: ea 10 87 65     orh r0,0x8765
++  14: ea 10 12 34     orh r0,0x1234
++  18: ea 10 00 00     orh r0,0x0
++                      18: R_AVR32_HI16        \.text\+0x60
++  1c: ea 10 00 00     orh r0,0x0
++                      1c: R_AVR32_HI16        extsym1
++  20: e4 10 87 65     andh r0,0x8765
++  24: e4 10 12 34     andh r0,0x1234
++  28: e4 10 00 00     andh r0,0x0
++                      28: R_AVR32_HI16        \.text\+0x60
++  2c: e4 10 00 00     andh r0,0x0
++                      2c: R_AVR32_HI16        extsym1
++
++00000030 <test_lwrd>:
++  30: e0 60 43 21     mov r0,17185
++  34: e0 60 56 78     mov r0,22136
++  38: e0 60 00 00     mov r0,0
++                      38: R_AVR32_LO16        \.text\+0x60
++  3c: e0 60 00 00     mov r0,0
++                      3c: R_AVR32_LO16        extsym1
++  40: e8 10 43 21     orl r0,0x4321
++  44: e8 10 56 78     orl r0,0x5678
++  48: e8 10 00 00     orl r0,0x0
++                      48: R_AVR32_LO16        \.text\+0x60
++  4c: e8 10 00 00     orl r0,0x0
++                      4c: R_AVR32_LO16        extsym1
++  50: e0 10 43 21     andl r0,0x4321
++  54: e0 10 56 78     andl r0,0x5678
++  58: e0 10 00 00     andl r0,0x0
++                      58: R_AVR32_LO16        \.text\+0x60
++  5c: e0 10 00 00     andl r0,0x0
++                      5c: R_AVR32_LO16        extsym1
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/hwrd-lwrd.s binutils-2.17-atmel/gas/testsuite/gas/avr32/hwrd-lwrd.s
+--- binutils-2.17/gas/testsuite/gas/avr32/hwrd-lwrd.s  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/hwrd-lwrd.s    2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,39 @@
++
++        .equ    sym1, 0x12345678
++
++        .text
++        .global test_hwrd
++test_hwrd:
++        mov     r0, hi(0x87654321)
++        mov     r0, hi(sym1)
++        mov     r0, hi(sym2)
++        mov     r0, hi(extsym1)
++
++        orh   r0, hi(0x87654321)
++        orh   r0, hi(sym1)
++        orh   r0, hi(sym2)
++        orh   r0, hi(extsym1)
++
++        andh  r0, hi(0x87654321)
++        andh  r0, hi(sym1)
++        andh  r0, hi(sym2)
++        andh  r0, hi(extsym1)
++
++        .global test_lwrd
++test_lwrd:
++        mov     r0, lo(0x87654321)
++        mov     r0, lo(sym1)
++        mov     r0, lo(sym2)
++        mov     r0, lo(extsym1)
++
++        orl   r0, lo(0x87654321)
++        orl   r0, lo(sym1)
++        orl   r0, lo(sym2)
++        orl   r0, lo(extsym1)
++
++        andl  r0, lo(0x87654321)
++        andl  r0, lo(sym1)
++        andl  r0, lo(sym2)
++        andl  r0, lo(extsym1)
++
++sym2:
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/jmptable.d binutils-2.17-atmel/gas/testsuite/gas/avr32/jmptable.d
+--- binutils-2.17/gas/testsuite/gas/avr32/jmptable.d   1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/jmptable.d     2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,20 @@
++#source: jmptable.s
++#as:
++#objdump: -dr
++#name: jmptable
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <jmptable_test>:
++   0: fe c8 ff f4     sub r8,pc,-12
++   4: f0 00 00 2f     add pc,r8,r0<<0x2
++   8: d7 03           nop
++   a: 00 00           add r0,r0
++   c: c0 38           rjmp 12 <jmptable_test\+0x12>
++   e: c0 38           rjmp 14 <jmptable_test\+0x14>
++  10: c0 38           rjmp 16 <jmptable_test\+0x16>
++  12: d7 03           nop
++  14: d7 03           nop
++  16: d7 03           nop
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/jmptable_linkrelax.d binutils-2.17-atmel/gas/testsuite/gas/avr32/jmptable_linkrelax.d
+--- binutils-2.17/gas/testsuite/gas/avr32/jmptable_linkrelax.d 1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/jmptable_linkrelax.d   2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,25 @@
++#source: jmptable.s
++#as: --linkrelax
++#objdump: -dr
++#name: jmptable_linkrelax
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <jmptable_test>:
++   0: fe c8 00 00     sub r8,pc,0
++                      0: R_AVR32_16N_PCREL    \.text\+0xc
++   4: f0 00 00 2f     add pc,r8,r0<<0x2
++   8: d7 03           nop
++   a: 00 00           add r0,r0
++                      a: R_AVR32_ALIGN        \*ABS\*\+0x2
++   c: c0 08           rjmp c <jmptable_test\+0xc>
++                      c: R_AVR32_11H_PCREL    \.text\+0x12
++   e: c0 08           rjmp e <jmptable_test\+0xe>
++                      e: R_AVR32_11H_PCREL    \.text\+0x14
++  10: c0 08           rjmp 10 <jmptable_test\+0x10>
++                      10: R_AVR32_11H_PCREL   \.text\+0x16
++  12: d7 03           nop
++  14: d7 03           nop
++  16: d7 03           nop
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/jmptable.s binutils-2.17-atmel/gas/testsuite/gas/avr32/jmptable.s
+--- binutils-2.17/gas/testsuite/gas/avr32/jmptable.s   1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/jmptable.s     2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,14 @@
++
++      .text
++      .global jmptable_test
++jmptable_test:
++      sub     r8, pc, -(.L1 - .)
++      add     pc, r8, r0 << 2
++      nop
++      .align  2
++.L1:  rjmp    1f
++      rjmp    2f
++      rjmp    3f
++1:    nop
++2:    nop
++3:    nop
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/lda_nopic.d binutils-2.17-atmel/gas/testsuite/gas/avr32/lda_nopic.d
+--- binutils-2.17/gas/testsuite/gas/avr32/lda_nopic.d  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/lda_nopic.d    2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,32 @@
++#source: lda.s
++#as:
++#objdump: -dr
++#name: lda_nopic
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <lda_test>:
++       0:     f2 c8 00 00     sub r8,r9,0
++
++00000004 <far_negative>:
++       4:     f6 ca 00 00     sub r10,r11,0
++      ...
++    8000:     fe c0 7f fc     sub r0,pc,32764
++    8004:     48 31           lddpc r1,8010 <far_negative\+0x800c>
++    8006:     48 42           lddpc r2,8014 <far_negative\+0x8010>
++    8008:     48 43           lddpc r3,8018 <far_negative\+0x8014>
++    800a:     48 54           lddpc r4,801c <far_negative\+0x8018>
++    800c:     fe c5 80 04     sub r5,pc,-32764
++      ...
++                      8010: R_AVR32_32_CPENT  \.text
++                      8014: R_AVR32_32_CPENT  \.data
++                      8018: R_AVR32_32_CPENT  undefined
++                      801c: R_AVR32_32_CPENT  \.text\+0x1001c
++
++00010008 <far_positive>:
++   10008:     fa cc 00 00     sub r12,sp,0
++      ...
++0001001c <toofar_positive>:
++   1001c:     fe ce 00 00     sub lr,pc,0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/lda_nopic_linkrelax.d binutils-2.17-atmel/gas/testsuite/gas/avr32/lda_nopic_linkrelax.d
+--- binutils-2.17/gas/testsuite/gas/avr32/lda_nopic_linkrelax.d        1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/lda_nopic_linkrelax.d  2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,41 @@
++#source: lda.s
++#as: --linkrelax
++#objdump: -dr
++#name: lda_nopic_linkrelax
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <lda_test>:
++       0:     f2 c8 00 00     sub r8,r9,0
++
++00000004 <far_negative>:
++       4:     f6 ca 00 00     sub r10,r11,0
++      \.\.\.
++    8000:     48 00           lddpc r0,8000 <far_negative\+0x7ffc>
++                      8000: R_AVR32_9W_CP     \.text\+0x800c
++    8002:     48 01           lddpc r1,8000 <far_negative\+0x7ffc>
++                      8002: R_AVR32_9W_CP     \.text\+0x8010
++    8004:     48 02           lddpc r2,8004 <far_negative\+0x8000>
++                      8004: R_AVR32_9W_CP     \.text\+0x8014
++    8006:     48 03           lddpc r3,8004 <far_negative\+0x8000>
++                      8006: R_AVR32_9W_CP     \.text\+0x8018
++    8008:     48 04           lddpc r4,8008 <far_negative\+0x8004>
++                      8008: R_AVR32_9W_CP     \.text\+0x801c
++    800a:     48 05           lddpc r5,8008 <far_negative\+0x8004>
++                      800a: R_AVR32_9W_CP     \.text\+0x8020
++      \.\.\.
++                      800c: R_AVR32_ALIGN     \*ABS\*\+0x2
++                      800c: R_AVR32_32_CPENT  \.text\+0x4
++                      8010: R_AVR32_32_CPENT  \.text
++                      8014: R_AVR32_32_CPENT  \.data
++                      8018: R_AVR32_32_CPENT  undefined
++                      801c: R_AVR32_32_CPENT  \.text\+0x10020
++                      8020: R_AVR32_32_CPENT  \.text\+0x1000c
++
++0001000c <far_positive>:
++   1000c:     fa cc 00 00     sub r12,sp,0
++      \.\.\.
++00010020 <toofar_positive>:
++   10020:     fe ce 00 00     sub lr,pc,0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/lda_pic.d binutils-2.17-atmel/gas/testsuite/gas/avr32/lda_pic.d
+--- binutils-2.17/gas/testsuite/gas/avr32/lda_pic.d    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/lda_pic.d      2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,32 @@
++#source: lda.s
++#as: --pic
++#objdump: -dr
++#name: lda_pic
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <lda_test>:
++       0:     f2 c8 00 00     sub r8,r9,0
++
++00000004 <far_negative>:
++       4:     f6 ca 00 00     sub r10,r11,0
++      ...
++    8000:     fe c0 7f fc     sub r0,pc,32764
++    8004:     ec f1 00 00     ld.w r1,r6\[0\]
++                      8004: R_AVR32_GOT16S    toofar_negative
++    8008:     ec f2 00 00     ld.w r2,r6\[0\]
++                      8008: R_AVR32_GOT16S    different_section
++    800c:     ec f3 00 00     ld.w r3,r6\[0\]
++                      800c: R_AVR32_GOT16S    undefined
++    8010:     ec f4 00 00     ld.w r4,r6\[0\]
++                      8010: R_AVR32_GOT16S    toofar_positive
++    8014:     fe c5 80 14     sub r5,pc,-32748
++      ...
++
++00010000 <far_positive>:
++   10000:     fa cc 00 00     sub r12,sp,0
++      ...
++00010014 <toofar_positive>:
++   10014:     fe ce 00 00     sub lr,pc,0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/lda_pic_linkrelax.d binutils-2.17-atmel/gas/testsuite/gas/avr32/lda_pic_linkrelax.d
+--- binutils-2.17/gas/testsuite/gas/avr32/lda_pic_linkrelax.d  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/lda_pic_linkrelax.d    2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,40 @@
++#source: lda.s
++#as: --pic --linkrelax
++#objdump: -dr
++#name: lda_pic_linkrelax
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <lda_test>:
++       0:     f2 c8 00 00     sub r8,r9,0
++
++00000004 <far_negative>:
++       4:     f6 ca 00 00     sub r10,r11,0
++      ...
++    8000:     e0 60 00 00     mov r0,0
++                      8000: R_AVR32_LDA_GOT   far_negative
++    8004:     ec 00 03 20     ld\.w r0,r6\[r0<<0x2\]
++    8008:     e0 61 00 00     mov r1,0
++                      8008: R_AVR32_LDA_GOT   toofar_negative
++    800c:     ec 01 03 21     ld\.w r1,r6\[r1<<0x2\]
++    8010:     e0 62 00 00     mov r2,0
++                      8010: R_AVR32_LDA_GOT   different_section
++    8014:     ec 02 03 22     ld\.w r2,r6\[r2<<0x2\]
++    8018:     e0 63 00 00     mov r3,0
++                      8018: R_AVR32_LDA_GOT   undefined
++    801c:     ec 03 03 23     ld\.w r3,r6\[r3<<0x2\]
++    8020:     e0 64 00 00     mov r4,0
++                      8020: R_AVR32_LDA_GOT   toofar_positive
++    8024:     ec 04 03 24     ld\.w r4,r6\[r4<<0x2\]
++    8028:     e0 65 00 00     mov r5,0
++                      8028: R_AVR32_LDA_GOT   far_positive
++    802c:     ec 05 03 25     ld\.w r5,r6\[r5<<0x2\]
++      ...
++
++00010018 <far_positive>:
++   10018:     fa cc 00 00     sub r12,sp,0
++      ...
++0001002c <toofar_positive>:
++   1002c:     fe ce 00 00     sub lr,pc,0
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/lda.s binutils-2.17-atmel/gas/testsuite/gas/avr32/lda.s
+--- binutils-2.17/gas/testsuite/gas/avr32/lda.s        1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/lda.s  2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,30 @@
++
++      .text
++      .global lda_test
++lda_test:
++toofar_negative:
++      sub     r8, r9, 0
++far_negative:
++      sub     r10, r11, 0
++
++      .fill   32760, 1, 0x00
++
++      lda.w   r0, far_negative
++      lda.w   r1, toofar_negative
++      lda.w   r2, different_section
++      lda.w   r3, undefined
++      lda.w   r4, toofar_positive
++      lda.w   r5, far_positive
++
++      .cpool
++
++      .fill   32744, 1, 0x00
++far_positive:
++      sub     r12, sp, 0
++      .fill   16, 1, 0x00
++toofar_positive:
++      sub     lr, pc, 0
++
++      .data
++different_section:
++      .long   0x12345678
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/pcrel.d binutils-2.17-atmel/gas/testsuite/gas/avr32/pcrel.d
+--- binutils-2.17/gas/testsuite/gas/avr32/pcrel.d      1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/pcrel.d        2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,64 @@
++#as:
++#objdump: -dr
++#name: pcrel
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <test_rjmp>:
++   0: d7 03           nop
++   2: c0 28           rjmp 6 <test_rjmp\+0x6>
++   4: d7 03           nop
++   6: e0 8f 00 00     bral 6 <test_rjmp\+0x6>
++                      6: R_AVR32_22H_PCREL    extsym10
++
++0000000a <test_rcall>:
++   a: d7 03           nop
++0000000c <test_rcall2>:
++   c: c0 2c           rcall 10 <test_rcall2\+0x4>
++   e: d7 03           nop
++  10: e0 a0 00 00     rcall 10 <test_rcall2\+0x4>
++                      10: R_AVR32_22H_PCREL   extsym21
++
++00000014 <test_branch>:
++  14: c0 31           brne 1a <test_branch\+0x6>
++  16: e0 8f 00 00     bral 16 <test_branch\+0x2>
++                      16: R_AVR32_22H_PCREL   test_branch
++  1a: e0 80 00 00     breq 1a <test_branch\+0x6>
++                      1a: R_AVR32_22H_PCREL   extsym21
++
++0000001e <test_lddpc>:
++  1e: 48 30           lddpc r0,28 <sym1>
++  20: 48 20           lddpc r0,28 <sym1>
++  22: fe f0 00 00     ld.w r0,pc\[0\]
++                      22: R_AVR32_16B_PCREL   extsym16
++      \.\.\.
++
++00000028 <sym1>:
++  28: d7 03           nop
++  2a: d7 03           nop
++
++0000002c <test_local>:
++  2c: 48 20           lddpc r0,34 <test_local\+0x8>
++  2e: 48 30           lddpc r0,38 <test_local\+0xc>
++  30: 48 20           lddpc r0,38 <test_local\+0xc>
++  32: 00 00           add r0,r0
++  34: d7 03           nop
++  36: d7 03           nop
++  38: d7 03           nop
++  3a: d7 03           nop
++
++Disassembly of section \.text\.init:
++
++00000000 <test_inter_section>:
++   0: e0 a0 .. ..     rcall [0-9a-f]+ <.*>
++                      0: R_AVR32_22H_PCREL    test_rcall
++   4: d7 03           nop
++   6: e0 a0 .. ..     rcall [0-9a-f]+ <.*>
++                      6: R_AVR32_22H_PCREL    test_rcall
++   a: e0 a0 .. ..     rcall [0-9a-z]+ <.*>
++                      a: R_AVR32_22H_PCREL    \.text\+0xc
++   e: d7 03           nop
++  10: e0 a0 .. ..     rcall [0-9a-f]+ <.*>
++                      10: R_AVR32_22H_PCREL   \.text\+0xc
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/pcrel.s binutils-2.17-atmel/gas/testsuite/gas/avr32/pcrel.s
+--- binutils-2.17/gas/testsuite/gas/avr32/pcrel.s      1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/pcrel.s        2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,57 @@
++
++        .text
++        .global test_rjmp
++test_rjmp:
++        nop
++        rjmp    0f
++        nop
++0:      rjmp    extsym10
++
++        .global test_rcall
++test_rcall:
++        nop
++test_rcall2:
++        rcall   0f
++        nop
++0:      rcall   extsym21
++
++        .global test_branch
++test_branch:
++        brne    0f
++      /* This will generate a reloc since test_branch is global */
++        bral    test_branch
++0:    breq    extsym21
++
++        .global test_lddpc
++test_lddpc:
++        lddpc   r0,sym1
++        lddpc   r0,sym1
++        lddpc   r0,extsym16
++
++        .align        2
++sym1:   nop
++        nop
++
++      .global test_local
++test_local:
++      lddpc   r0, .LC1
++      lddpc   r0, .LC2
++      lddpc   r0, .LC1 + 0x4
++
++      .align  2
++.LC1:
++      nop
++      nop
++.LC2:
++      nop
++      nop
++
++      .section .text.init,"ax"
++      .global test_inter_section
++test_inter_section:
++      rcall   test_rcall
++      nop
++      rcall   test_rcall
++      rcall   test_rcall2
++      nop
++      rcall   test_rcall2
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/pico.d binutils-2.17-atmel/gas/testsuite/gas/avr32/pico.d
+--- binutils-2.17/gas/testsuite/gas/avr32/pico.d       1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/pico.d 2007-01-29 12:21:57.000000000 +0100
+@@ -0,0 +1,149 @@
++#as:
++#objdump: -dr
++#name: pico
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++[0-9a-f]* <picosvmac>:
++ *[0-9a-f]*:  e1 a6 20 00     cop cp1,cr0,cr0,cr0,0xc
++ *[0-9a-f]*:  e1 a7 2b bb     cop cp1,cr11,cr11,cr11,0xe
++ *[0-9a-f]*:  e1 a6 3a 05     cop cp1,cr10,cr0,cr5,0xd
++ *[0-9a-f]*:  e1 a7 36 90     cop cp1,cr6,cr9,cr0,0xf
++
++[0-9a-f]* <picosvmul>:
++ *[0-9a-f]*:  e1 a4 20 00     cop cp1,cr0,cr0,cr0,0x8
++ *[0-9a-f]*:  e1 a5 2b bb     cop cp1,cr11,cr11,cr11,0xa
++ *[0-9a-f]*:  e1 a4 3a 05     cop cp1,cr10,cr0,cr5,0x9
++ *[0-9a-f]*:  e1 a5 36 90     cop cp1,cr6,cr9,cr0,0xb
++
++[0-9a-f]* <picovmac>:
++ *[0-9a-f]*:  e1 a2 20 00     cop cp1,cr0,cr0,cr0,0x4
++ *[0-9a-f]*:  e1 a3 2b bb     cop cp1,cr11,cr11,cr11,0x6
++ *[0-9a-f]*:  e1 a2 3a 05     cop cp1,cr10,cr0,cr5,0x5
++ *[0-9a-f]*:  e1 a3 36 90     cop cp1,cr6,cr9,cr0,0x7
++
++[0-9a-f]* <picovmul>:
++ *[0-9a-f]*:  e1 a0 20 00     cop cp1,cr0,cr0,cr0,0x0
++ *[0-9a-f]*:  e1 a1 2b bb     cop cp1,cr11,cr11,cr11,0x2
++ *[0-9a-f]*:  e1 a0 3a 05     cop cp1,cr10,cr0,cr5,0x1
++ *[0-9a-f]*:  e1 a1 36 90     cop cp1,cr6,cr9,cr0,0x3
++
++[0-9a-f]* <picold_d>:
++ *[0-9a-f]*:  e9 af 3e ff     ldc\.d cp1,cr14,pc\[0x3fc\]
++ *[0-9a-f]*:  e9 a0 30 ff     ldc\.d cp1,cr0,r0\[0x3fc\]
++ *[0-9a-f]*:  e9 a0 30 00     ldc\.d cp1,cr0,r0\[0x0\]
++ *[0-9a-f]*:  ef a8 26 50     ldc\.d cp1,cr6,--r8
++ *[0-9a-f]*:  ef a7 28 50     ldc\.d cp1,cr8,--r7
++ *[0-9a-f]*:  ef aa 32 65     ldc\.d cp1,cr2,r10\[r5<<0x2\]
++ *[0-9a-f]*:  ef a3 3c 46     ldc\.d cp1,cr12,r3\[r6\]
++
++[0-9a-f]* <picold_w>:
++ *[0-9a-f]*:  e9 af 2f ff     ldc\.w cp1,cr15,pc\[0x3fc\]
++ *[0-9a-f]*:  e9 a0 20 ff     ldc\.w cp1,cr0,r0\[0x3fc\]
++ *[0-9a-f]*:  e9 a0 20 00     ldc\.w cp1,cr0,r0\[0x0\]
++ *[0-9a-f]*:  ef a8 27 40     ldc\.w cp1,cr7,--r8
++ *[0-9a-f]*:  ef a7 28 40     ldc\.w cp1,cr8,--r7
++ *[0-9a-f]*:  ef aa 31 25     ldc\.w cp1,cr1,r10\[r5<<0x2\]
++ *[0-9a-f]*:  ef a3 3d 06     ldc\.w cp1,cr13,r3\[r6\]
++
++[0-9a-f]* <picoldm_d>:
++ *[0-9a-f]*:  ed af 24 ff     ldcm\.d cp1,pc,cr0-cr15
++ *[0-9a-f]*:  ed a0 24 01     ldcm\.d cp1,r0,cr0-cr1
++ *[0-9a-f]*:  ed a7 24 80     ldcm\.d cp1,r7,cr14-cr15
++ *[0-9a-f]*:  ed a8 24 7f     ldcm\.d cp1,r8,cr0-cr13
++
++[0-9a-f]* <picoldm_d_pu>:
++ *[0-9a-f]*:  ed af 34 ff     ldcm\.d cp1,pc\+\+,cr0-cr15
++ *[0-9a-f]*:  ed a0 34 01     ldcm\.d cp1,r0\+\+,cr0-cr1
++ *[0-9a-f]*:  ed a7 34 80     ldcm\.d cp1,r7\+\+,cr14-cr15
++ *[0-9a-f]*:  ed a8 34 7f     ldcm\.d cp1,r8\+\+,cr0-cr13
++
++[0-9a-f]* <picoldm_w>:
++ *[0-9a-f]*:  ed af 20 ff     ldcm\.w cp1,pc,cr0-cr7
++ *[0-9a-f]*:  ed a0 20 01     ldcm\.w cp1,r0,cr0
++ *[0-9a-f]*:  ed a7 20 80     ldcm\.w cp1,r7,cr7
++ *[0-9a-f]*:  ed a8 20 7f     ldcm\.w cp1,r8,cr0-cr6
++ *[0-9a-f]*:  ed af 21 ff     ldcm\.w cp1,pc,cr8-cr15
++ *[0-9a-f]*:  ed a0 21 01     ldcm\.w cp1,r0,cr8
++ *[0-9a-f]*:  ed a7 21 80     ldcm\.w cp1,r7,cr15
++ *[0-9a-f]*:  ed a8 21 7f     ldcm\.w cp1,r8,cr8-cr14
++
++[0-9a-f]* <picoldm_w_pu>:
++ *[0-9a-f]*:  ed af 30 ff     ldcm\.w cp1,pc\+\+,cr0-cr7
++ *[0-9a-f]*:  ed a0 30 01     ldcm\.w cp1,r0\+\+,cr0
++ *[0-9a-f]*:  ed a7 30 80     ldcm\.w cp1,r7\+\+,cr7
++ *[0-9a-f]*:  ed a8 30 7f     ldcm\.w cp1,r8\+\+,cr0-cr6
++ *[0-9a-f]*:  ed af 31 ff     ldcm\.w cp1,pc\+\+,cr8-cr15
++ *[0-9a-f]*:  ed a0 31 01     ldcm\.w cp1,r0\+\+,cr8
++ *[0-9a-f]*:  ed a7 31 80     ldcm\.w cp1,r7\+\+,cr15
++ *[0-9a-f]*:  ed a8 31 7f     ldcm\.w cp1,r8\+\+,cr8-cr14
++
++[0-9a-f]* <picomv_d>:
++ *[0-9a-f]*:  ef ae 2e 30     mvrc\.d cp1,cr14,lr
++ *[0-9a-f]*:  ef a0 20 30     mvrc\.d cp1,cr0,r0
++ *[0-9a-f]*:  ef a8 26 30     mvrc\.d cp1,cr6,r8
++ *[0-9a-f]*:  ef a6 28 30     mvrc\.d cp1,cr8,r6
++ *[0-9a-f]*:  ef ae 2e 10     mvcr\.d cp1,lr,cr14
++ *[0-9a-f]*:  ef a0 20 10     mvcr\.d cp1,r0,cr0
++ *[0-9a-f]*:  ef a8 26 10     mvcr\.d cp1,r8,cr6
++ *[0-9a-f]*:  ef a6 28 10     mvcr\.d cp1,r6,cr8
++
++[0-9a-f]* <picomv_w>:
++ *[0-9a-f]*:  ef af 2f 20     mvrc\.w cp1,cr15,pc
++ *[0-9a-f]*:  ef a0 20 20     mvrc\.w cp1,cr0,r0
++ *[0-9a-f]*:  ef a8 27 20     mvrc\.w cp1,cr7,r8
++ *[0-9a-f]*:  ef a7 28 20     mvrc\.w cp1,cr8,r7
++ *[0-9a-f]*:  ef af 2f 00     mvcr\.w cp1,pc,cr15
++ *[0-9a-f]*:  ef a0 20 00     mvcr\.w cp1,r0,cr0
++ *[0-9a-f]*:  ef a8 27 00     mvcr\.w cp1,r8,cr7
++ *[0-9a-f]*:  ef a7 28 00     mvcr\.w cp1,r7,cr8
++
++[0-9a-f]* <picost_d>:
++ *[0-9a-f]*:  eb af 3e ff     stc\.d cp1,pc\[0x3fc\],cr14
++ *[0-9a-f]*:  eb a0 30 00     stc\.d cp1,r0\[0x0\],cr0
++ *[0-9a-f]*:  ef a8 26 70     stc\.d cp1,r8\+\+,cr6
++ *[0-9a-f]*:  ef a7 28 70     stc\.d cp1,r7\+\+,cr8
++ *[0-9a-f]*:  ef aa 32 e5     stc\.d cp1,r10\[r5<<0x2\],cr2
++ *[0-9a-f]*:  ef a3 3c c6     stc\.d cp1,r3\[r6\],cr12
++
++[0-9a-f]* <picost_w>:
++ *[0-9a-f]*:  eb af 2f ff     stc\.w cp1,pc\[0x3fc\],cr15
++ *[0-9a-f]*:  eb a0 20 00     stc\.w cp1,r0\[0x0\],cr0
++ *[0-9a-f]*:  ef a8 27 60     stc\.w cp1,r8\+\+,cr7
++ *[0-9a-f]*:  ef a7 28 60     stc\.w cp1,r7\+\+,cr8
++ *[0-9a-f]*:  ef aa 31 a5     stc\.w cp1,r10\[r5<<0x2\],cr1
++ *[0-9a-f]*:  ef a3 3d 86     stc\.w cp1,r3\[r6\],cr13
++
++[0-9a-f]* <picostm_d>:
++ *[0-9a-f]*:  ed af 25 ff     stcm\.d cp1,pc,cr0-cr15
++ *[0-9a-f]*:  ed a0 25 01     stcm\.d cp1,r0,cr0-cr1
++ *[0-9a-f]*:  ed a7 25 80     stcm\.d cp1,r7,cr14-cr15
++ *[0-9a-f]*:  ed a8 25 7f     stcm\.d cp1,r8,cr0-cr13
++
++[0-9a-f]* <picostm_d_pu>:
++ *[0-9a-f]*:  ed af 35 ff     stcm\.d cp1,--pc,cr0-cr15
++ *[0-9a-f]*:  ed a0 35 01     stcm\.d cp1,--r0,cr0-cr1
++ *[0-9a-f]*:  ed a7 35 80     stcm\.d cp1,--r7,cr14-cr15
++ *[0-9a-f]*:  ed a8 35 7f     stcm\.d cp1,--r8,cr0-cr13
++
++[0-9a-f]* <picostm_w>:
++ *[0-9a-f]*:  ed af 22 ff     stcm\.w cp1,pc,cr0-cr7
++ *[0-9a-f]*:  ed a0 22 01     stcm\.w cp1,r0,cr0
++ *[0-9a-f]*:  ed a7 22 80     stcm\.w cp1,r7,cr7
++ *[0-9a-f]*:  ed a8 22 7f     stcm\.w cp1,r8,cr0-cr6
++ *[0-9a-f]*:  ed af 23 ff     stcm\.w cp1,pc,cr8-cr15
++ *[0-9a-f]*:  ed a0 23 01     stcm\.w cp1,r0,cr8
++ *[0-9a-f]*:  ed a7 23 80     stcm\.w cp1,r7,cr15
++ *[0-9a-f]*:  ed a8 23 7f     stcm\.w cp1,r8,cr8-cr14
++
++[0-9a-f]* <picostm_w_pu>:
++ *[0-9a-f]*:  ed af 32 ff     stcm\.w cp1,--pc,cr0-cr7
++ *[0-9a-f]*:  ed a0 32 01     stcm\.w cp1,--r0,cr0
++ *[0-9a-f]*:  ed a7 32 80     stcm\.w cp1,--r7,cr7
++ *[0-9a-f]*:  ed a8 32 7f     stcm\.w cp1,--r8,cr0-cr6
++ *[0-9a-f]*:  ed af 33 ff     stcm\.w cp1,--pc,cr8-cr15
++ *[0-9a-f]*:  ed a0 33 01     stcm\.w cp1,--r0,cr8
++ *[0-9a-f]*:  ed a7 33 80     stcm\.w cp1,--r7,cr15
++ *[0-9a-f]*:  ed a8 33 7f     stcm\.w cp1,--r8,cr8-cr14
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/pico.s binutils-2.17-atmel/gas/testsuite/gas/avr32/pico.s
+--- binutils-2.17/gas/testsuite/gas/avr32/pico.s       1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/pico.s 2007-01-29 12:21:57.000000000 +0100
+@@ -0,0 +1,144 @@
++
++      .text
++      .global picosvmac
++picosvmac:
++      picosvmac       out0, in0, in0, in0
++      picosvmac       out2, in11, in11, in11
++      picosvmac       out1, in10, in0, in5
++      picosvmac       out3, in6, in9, in0
++      .global picosvmul
++picosvmul:
++      picosvmul       out0, in0, in0, in0
++      picosvmul       out2, in11, in11, in11
++      picosvmul       out1, in10, in0, in5
++      picosvmul       out3, in6, in9, in0
++      .global picovmac
++picovmac:
++      picovmac        out0, in0, in0, in0
++      picovmac        out2, in11, in11, in11
++      picovmac        out1, in10, in0, in5
++      picovmac        out3, in6, in9, in0
++      .global picovmul
++picovmul:
++      picovmul        out0, in0, in0, in0
++      picovmul        out2, in11, in11, in11
++      picovmul        out1, in10, in0, in5
++      picovmul        out3, in6, in9, in0
++      .global picold_d
++picold_d:
++      picold.d        vmu2_out, pc[1020]
++      picold.d        inpix2, r0[1020]
++      picold.d        inpix2, r0[0]
++      picold.d        coeff0_a, --r8
++      picold.d        coeff1_a, --r7
++      picold.d        inpix0, r10[r5 << 2]
++      picold.d        vmu0_out, r3[r6 << 0]
++      .global picold_w
++picold_w:     
++      picold.w        config, pc[1020]
++      picold.w        inpix2, r0[1020]
++      picold.w        inpix2, r0[0]
++      picold.w        coeff0_b, --r8
++      picold.w        coeff1_a, --r7
++      picold.w        inpix1, r10[r5 << 2]
++      picold.w        vmu1_out, r3[r6 << 0]
++      .global picoldm_d
++picoldm_d:
++      picoldm.d       pc, inpix2-config
++      picoldm.d       r0, inpix2, inpix1
++      picoldm.d       r7, vmu2_out, config
++      picoldm.d       r8, inpix2-vmu1_out
++      .global picoldm_d_pu
++picoldm_d_pu:
++      picoldm.d       pc++, inpix2, inpix1, inpix0, outpix2, outpix1, outpix0, coeff0_a, coeff0_b, coeff1_a, coeff1_b, coeff2_a, coeff2_b, vmu0_out, vmu1_out, vmu2_out, config
++      picoldm.d       r0++, inpix2, inpix1
++      picoldm.d       r7++, vmu2_out, config
++      picoldm.d       r8++, inpix2, inpix1, inpix0, outpix2, outpix1, outpix0, coeff0_a, coeff0_b, coeff1_a, coeff1_b, coeff2_a, coeff2_b, vmu0_out, vmu1_out
++      .global picoldm_w
++picoldm_w:
++      picoldm.w       pc, inpix2-coeff0_b
++      picoldm.w       r0, inpix2
++      picoldm.w       r7, coeff0_b
++      picoldm.w       r8, inpix2-coeff0_a
++      picoldm.w       pc, coeff1_a-config
++      picoldm.w       r0, coeff1_a
++      picoldm.w       r7, config
++      picoldm.w       r8, coeff1_a-vmu2_out
++      .global picoldm_w_pu
++picoldm_w_pu:
++      picoldm.w       pc++, inpix2-coeff0_b
++      picoldm.w       r0++, inpix2
++      picoldm.w       r7++, coeff0_b
++      picoldm.w       r8++, inpix2-coeff0_a
++      picoldm.w       pc++, coeff1_a-config
++      picoldm.w       r0++, coeff1_a
++      picoldm.w       r7++, config
++      picoldm.w       r8++, coeff1_a-vmu2_out
++      .global picomv_d
++picomv_d:
++      picomv.d        vmu2_out, lr
++      picomv.d        inpix2, r0
++      picomv.d        coeff0_a, r8
++      picomv.d        coeff1_a, r6
++      picomv.d        pc, vmu2_out
++      picomv.d        r0, inpix2
++      picomv.d        r8, coeff0_a
++      picomv.d        r6, coeff1_a
++      .global picomv_w
++picomv_w:
++      picomv.w        config, pc
++      picomv.w        inpix2, r0
++      picomv.w        coeff0_b, r8
++      picomv.w        coeff1_a, r7
++      picomv.w        pc, config
++      picomv.w        r0, inpix2
++      picomv.w        r8, coeff0_b
++      picomv.w        r7, coeff1_a
++      .global picost_d
++picost_d:
++      picost.d        pc[1020], vmu2_out
++      picost.d        r0[0], inpix2
++      picost.d        r8++, coeff0_a
++      picost.d        r7++, coeff1_a
++      picost.d        r10[r5 << 2], inpix0
++      picost.d        r3[r6 << 0], vmu0_out
++      .global picost_w
++picost_w:     
++      picost.w        pc[1020], config
++      picost.w        r0[0], inpix2
++      picost.w        r8++, coeff0_b
++      picost.w        r7++, coeff1_a
++      picost.w        r10[r5 << 2], inpix1
++      picost.w        r3[r6 << 0], vmu1_out
++      .global picostm_d
++picostm_d:
++      picostm.d       pc, inpix2-config
++      picostm.d       r0, inpix2, inpix1
++      picostm.d       r7, vmu2_out, config
++      picostm.d       r8, inpix2-vmu1_out
++      .global picostm_d_pu
++picostm_d_pu:
++      picostm.d       --pc, inpix2, inpix1, inpix0, outpix2, outpix1, outpix0, coeff0_a, coeff0_b, coeff1_a, coeff1_b, coeff2_a, coeff2_b, vmu0_out, vmu1_out, vmu2_out, config
++      picostm.d       --r0, inpix2, inpix1
++      picostm.d       --r7, vmu2_out, config
++      picostm.d       --r8, inpix2, inpix1, inpix0, outpix2, outpix1, outpix0, coeff0_a, coeff0_b, coeff1_a, coeff1_b, coeff2_a, coeff2_b, vmu0_out, vmu1_out
++      .global picostm_w
++picostm_w:
++      picostm.w       pc, inpix2-coeff0_b
++      picostm.w       r0, inpix2
++      picostm.w       r7, coeff0_b
++      picostm.w       r8, inpix2-coeff0_a
++      picostm.w       pc, coeff1_a-config
++      picostm.w       r0, coeff1_a
++      picostm.w       r7, config
++      picostm.w       r8, coeff1_a-vmu2_out
++      .global picostm_w_pu
++picostm_w_pu:
++      picostm.w       --pc, inpix2-coeff0_b
++      picostm.w       --r0, inpix2
++      picostm.w       --r7, coeff0_b
++      picostm.w       --r8, inpix2-coeff0_a
++      picostm.w       --pc, coeff1_a-config
++      picostm.w       --r0, coeff1_a
++      picostm.w       --r7, config
++      picostm.w       --r8, coeff1_a-vmu2_out
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/pic_reloc.d binutils-2.17-atmel/gas/testsuite/gas/avr32/pic_reloc.d
+--- binutils-2.17/gas/testsuite/gas/avr32/pic_reloc.d  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/pic_reloc.d    2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,27 @@
++#as:
++#objdump: -dr
++#name: pic_reloc
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <mcall_got>:
++   0: f0 16 00 00     mcall r6\[0\]
++                      0: R_AVR32_GOT18SW      extfunc
++   4: f0 16 00 00     mcall r6\[0\]
++                      4: R_AVR32_GOT18SW      \.L1
++   8: f0 16 00 00     mcall r6\[0\]
++                      8: R_AVR32_GOT18SW      \.L2
++   c: f0 16 00 00     mcall r6\[0\]
++                      c: R_AVR32_GOT18SW      mcall_got
++
++00000010 <ldw_got>:
++  10: ec f0 00 00     ld.w r0,r6\[0\]
++                      10: R_AVR32_GOT16S      extvar
++  14: ec f0 00 00     ld.w r0,r6\[0\]
++                      14: R_AVR32_GOT16S      \.L3
++  18: ec f0 00 00     ld.w r0,r6\[0\]
++                      18: R_AVR32_GOT16S      \.L4
++  1c: ec f0 00 00     ld.w r0,r6\[0\]
++                      1c: R_AVR32_GOT16S      ldw_got
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/pic_reloc.s binutils-2.17-atmel/gas/testsuite/gas/avr32/pic_reloc.s
+--- binutils-2.17/gas/testsuite/gas/avr32/pic_reloc.s  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/pic_reloc.s    2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,18 @@
++
++      .text
++      .global mcall_got
++mcall_got:
++.L1:
++      mcall   r6[extfunc@got]
++      mcall   r6[.L1@got]
++      mcall   r6[.L2@got]
++      mcall   r6[mcall_got@got]
++.L2:
++
++      .global ldw_got
++ldw_got:
++.L3:  ld.w    r0,r6[extvar@got]
++      ld.w    r0,r6[.L3@got]
++      ld.w    r0,r6[.L4@got]
++      ld.w    r0,r6[ldw_got@got]
++.L4:
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/symdiff.d binutils-2.17-atmel/gas/testsuite/gas/avr32/symdiff.d
+--- binutils-2.17/gas/testsuite/gas/avr32/symdiff.d    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/symdiff.d      2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,24 @@
++#source: symdiff.s
++#as:
++#objdump: -dr
++#name: symdiff
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <diff32>:
++   0: 00 00           add r0,r0
++   2: 00 04           add r4,r0
++
++00000004 <diff16>:
++   4: 00 04           add r4,r0
++
++00000006 <diff8>:
++   6: 04 00           add r0,r2
++
++00000008 <symdiff_test>:
++   8: d7 03           nop
++   a: d7 03           nop
++   c: d7 03           nop
++   e: d7 03           nop
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/symdiff_linkrelax.d binutils-2.17-atmel/gas/testsuite/gas/avr32/symdiff_linkrelax.d
+--- binutils-2.17/gas/testsuite/gas/avr32/symdiff_linkrelax.d  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/symdiff_linkrelax.d    2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,28 @@
++#source: symdiff.s
++#as: --linkrelax
++#objdump: -dr
++#name: symdiff_linkrelax
++
++.*: +file format .*
++
++Disassembly of section \.text:
++
++00000000 <diff32>:
++   0: 00 00           add r0,r0
++                      0: R_AVR32_DIFF32       \.text\+0xa
++   2: 00 04           add r4,r0
++
++00000004 <diff16>:
++   4: 00 04           add r4,r0
++                      4: R_AVR32_DIFF16       \.text\+0xa
++
++00000006 <diff8>:
++   6: 04 00           add r0,r2
++                      6: R_AVR32_DIFF8        \.text\+0xa
++                      7: R_AVR32_ALIGN        \*ABS\*\+0x1
++
++00000008 <symdiff_test>:
++   8: d7 03           nop
++   a: d7 03           nop
++   c: d7 03           nop
++   e: d7 03           nop
+diff -Nrup binutils-2.17/gas/testsuite/gas/avr32/symdiff.s binutils-2.17-atmel/gas/testsuite/gas/avr32/symdiff.s
+--- binutils-2.17/gas/testsuite/gas/avr32/symdiff.s    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/gas/testsuite/gas/avr32/symdiff.s      2006-08-04 14:51:13.000000000 +0200
+@@ -0,0 +1,19 @@
++
++      .text
++      .global diff32
++diff32:
++      .long   .L2 - .L1
++      .global diff16
++diff16:
++      .short  .L2 - .L1
++      .global diff8
++diff8:
++      .byte   .L2 - .L1
++
++      .global symdiff_test
++      .align  1
++symdiff_test:
++      nop
++.L1:  nop
++      nop
++.L2:  nop
+diff -Nrup binutils-2.17/gas/write.c binutils-2.17-atmel/gas/write.c
+--- binutils-2.17/gas/write.c  2006-05-10 15:43:37.000000000 +0200
++++ binutils-2.17-atmel/gas/write.c    2007-02-12 15:37:09.000000000 +0100
+@@ -126,7 +126,9 @@ static fixS *fix_new_internal (fragS *, 
+                              offsetT offset, int pcrel,
+                              RELOC_ENUM r_type);
+ static long fixup_segment (fixS *, segT);
++#if !defined (TC_RELAX_ALIGN)
+ static relax_addressT relax_align (relax_addressT addr, int align);
++#endif
+ static fragS *chain_frchains_together_1 (segT, struct frchain *);
+ static void chain_frchains_together (bfd *, segT, PTR);
+ static void cvt_frag_to_fill (segT, fragS *);
+@@ -1684,6 +1686,10 @@ relax_frag (segT segment, fragS *fragP, 
+ #endif /* defined (TC_GENERIC_RELAX_TABLE)  */
++#ifdef TC_RELAX_ALIGN
++#define RELAX_ALIGN(SEG, FRAG, ADDR) TC_RELAX_ALIGN(SEG, FRAG, ADDR)
++#else
++#define RELAX_ALIGN(SEG, FRAG, ADDR) relax_align(ADDR, (FRAG)->fr_offset)
+ /* Relax_align. Advance location counter to next address that has 'alignment'
+    lowest order bits all 0s, return size of adjustment made.  */
+ static relax_addressT
+@@ -1703,6 +1709,7 @@ relax_align (register relax_addressT add
+ #endif
+   return (new_address - address);
+ }
++#endif
+ /* Now we have a segment, not a crowd of sub-segments, we can make
+    fr_address values.
+@@ -1746,7 +1753,7 @@ relax_segment (struct frag *segment_frag
+       case rs_align_code:
+       case rs_align_test:
+         {
+-          addressT offset = relax_align (address, (int) fragP->fr_offset);
++          addressT offset = RELAX_ALIGN(segment, fragP, address);
+           if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
+             offset = 0;
+@@ -1922,10 +1929,10 @@ relax_segment (struct frag *segment_frag
+               {
+                 addressT oldoff, newoff;
+-                oldoff = relax_align (was_address + fragP->fr_fix,
+-                                      (int) offset);
+-                newoff = relax_align (address + fragP->fr_fix,
+-                                      (int) offset);
++                oldoff = RELAX_ALIGN (segment, fragP,
++                                      was_address + fragP->fr_fix);
++                newoff = RELAX_ALIGN (segment, fragP,
++                                      address + fragP->fr_fix);
+                 if (fragP->fr_subtype != 0)
+                   {
+diff -Nrup binutils-2.17/include/dis-asm.h binutils-2.17-atmel/include/dis-asm.h
+--- binutils-2.17/include/dis-asm.h    2006-02-17 15:36:26.000000000 +0100
++++ binutils-2.17-atmel/include/dis-asm.h      2007-02-12 15:37:09.000000000 +0100
+@@ -223,6 +223,7 @@ extern int print_insn_big_arm              (bfd_vma,
+ extern int print_insn_little_arm      (bfd_vma, disassemble_info *);
+ extern int print_insn_sparc           (bfd_vma, disassemble_info *);
+ extern int print_insn_avr             (bfd_vma, disassemble_info *);
++extern int print_insn_avr32           (bfd_vma, disassemble_info *);
+ extern int print_insn_bfin            (bfd_vma, disassemble_info *);
+ extern int print_insn_d10v            (bfd_vma, disassemble_info *);
+ extern int print_insn_d30v            (bfd_vma, disassemble_info *);
+@@ -276,7 +277,9 @@ extern disassembler_ftype cris_get_disas
+ extern void print_mips_disassembler_options (FILE *);
+ extern void print_ppc_disassembler_options (FILE *);
+ extern void print_arm_disassembler_options (FILE *);
++extern void print_avr32_disassembler_options (FILE *);
+ extern void parse_arm_disassembler_option (char *);
++extern void parse_avr32_disassembler_option (char *);
+ extern int get_arm_regname_num_options (void);
+ extern int set_arm_regname_option (int);
+ extern int get_arm_regnames (int, const char **, const char **, const char *const **);
+diff -Nrup binutils-2.17/include/elf/avr32.h binutils-2.17-atmel/include/elf/avr32.h
+--- binutils-2.17/include/elf/avr32.h  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/include/elf/avr32.h    2006-08-04 14:50:43.000000000 +0200
+@@ -0,0 +1,95 @@
++/* AVR32 ELF support for BFD.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   This file is part of BFD, the Binary File Descriptor library.
++
++   This program is free software; you can redistribute it and/or
++   modify it under the terms of the GNU General Public License as
++   published by the Free Software Foundation; either version 2 of the
++   License, or (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful, but
++   WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++   General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++   02111-1307, USA.  */
++
++#include "elf/reloc-macros.h"
++
++/* CPU-specific flags for the ELF header e_flags field */
++#define EF_AVR32_LINKRELAX            0x01
++#define EF_AVR32_PIC                  0x02
++
++START_RELOC_NUMBERS (elf_avr32_reloc_type)
++    RELOC_NUMBER (R_AVR32_NONE,                       0)
++
++    /* Data Relocations */
++    RELOC_NUMBER (R_AVR32_32,                 1)
++    RELOC_NUMBER (R_AVR32_16,                 2)
++    RELOC_NUMBER (R_AVR32_8,                  3)
++    RELOC_NUMBER (R_AVR32_32_PCREL,           4)
++    RELOC_NUMBER (R_AVR32_16_PCREL,           5)
++    RELOC_NUMBER (R_AVR32_8_PCREL,            6)
++    RELOC_NUMBER (R_AVR32_DIFF32,             7)
++    RELOC_NUMBER (R_AVR32_DIFF16,             8)
++    RELOC_NUMBER (R_AVR32_DIFF8,              9)
++    RELOC_NUMBER (R_AVR32_GOT32,              10)
++    RELOC_NUMBER (R_AVR32_GOT16,              11)
++    RELOC_NUMBER (R_AVR32_GOT8,                       12)
++
++    /* Normal Code Relocations */
++    RELOC_NUMBER (R_AVR32_21S,                        13)
++    RELOC_NUMBER (R_AVR32_16U,                        14)
++    RELOC_NUMBER (R_AVR32_16S,                        15)
++    RELOC_NUMBER (R_AVR32_8S,                 16)
++    RELOC_NUMBER (R_AVR32_8S_EXT,             17)
++
++    /* PC-Relative Code Relocations */
++    RELOC_NUMBER (R_AVR32_22H_PCREL,          18)
++    RELOC_NUMBER (R_AVR32_18W_PCREL,          19)
++    RELOC_NUMBER (R_AVR32_16B_PCREL,          20)
++    RELOC_NUMBER (R_AVR32_16N_PCREL,          21)
++    RELOC_NUMBER (R_AVR32_14UW_PCREL,         22)
++    RELOC_NUMBER (R_AVR32_11H_PCREL,          23)
++    RELOC_NUMBER (R_AVR32_10UW_PCREL,         24)
++    RELOC_NUMBER (R_AVR32_9H_PCREL,           25)
++    RELOC_NUMBER (R_AVR32_9UW_PCREL,          26)
++
++    /* Special Code Relocations */
++    RELOC_NUMBER (R_AVR32_HI16,                       27)
++    RELOC_NUMBER (R_AVR32_LO16,                       28)
++
++    /* PIC Relocations */
++    RELOC_NUMBER (R_AVR32_GOTPC,              29)
++    RELOC_NUMBER (R_AVR32_GOTCALL,            30)
++    RELOC_NUMBER (R_AVR32_LDA_GOT,            31)
++    RELOC_NUMBER (R_AVR32_GOT21S,             32)
++    RELOC_NUMBER (R_AVR32_GOT18SW,            33)
++    RELOC_NUMBER (R_AVR32_GOT16S,             34)
++    RELOC_NUMBER (R_AVR32_GOT7UW,             35)
++
++    /* Constant Pool Relocations */
++    RELOC_NUMBER (R_AVR32_32_CPENT,           36)
++    RELOC_NUMBER (R_AVR32_CPCALL,             37)
++    RELOC_NUMBER (R_AVR32_16_CP,              38)
++    RELOC_NUMBER (R_AVR32_9W_CP,              39)
++
++    /* Dynamic Relocations */
++    RELOC_NUMBER (R_AVR32_RELATIVE,           40)
++    RELOC_NUMBER (R_AVR32_GLOB_DAT,           41)
++    RELOC_NUMBER (R_AVR32_JMP_SLOT,           42)
++
++    /* Linkrelax Information */
++    RELOC_NUMBER (R_AVR32_ALIGN,              43)
++END_RELOC_NUMBERS (R_AVR32_max)
++
++/* Processor specific dynamic array tags.  */
++
++/* The total size in bytes of the Global Offset Table */
++#define DT_AVR32_GOTSZ                        0x70000001
+diff -Nrup binutils-2.17/include/elf/common.h binutils-2.17-atmel/include/elf/common.h
+--- binutils-2.17/include/elf/common.h 2006-02-17 15:36:26.000000000 +0100
++++ binutils-2.17-atmel/include/elf/common.h   2007-02-12 15:37:09.000000000 +0100
+@@ -256,6 +256,9 @@
+ /* V850 backend magic number.  Written in the absense of an ABI.  */
+ #define EM_CYGNUS_V850                0x9080
++/* AVR32 magic number, picked by IAR Systems. */
++#define EM_AVR32              0x18ad
++
+ /* old S/390 backend magic number. Written in the absence of an ABI.  */
+ #define EM_S390_OLD           0xa390
+diff -Nrup binutils-2.17/ld/config.in binutils-2.17-atmel/ld/config.in
+--- binutils-2.17/ld/config.in 2006-04-16 20:20:30.000000000 +0200
++++ binutils-2.17-atmel/ld/config.in   2007-02-20 16:07:39.000000000 +0100
+@@ -187,7 +187,7 @@
+ /* If using the C implementation of alloca, define if you know the
+    direction of stack growth for your system; otherwise it will be
+-   automatically deduced at run-time.
++   automatically deduced at runtime.
+       STACK_DIRECTION > 0 => grows toward higher addresses
+       STACK_DIRECTION < 0 => grows toward lower addresses
+       STACK_DIRECTION = 0 => direction of growth unknown */
+@@ -215,8 +215,8 @@
+ #undef inline
+ #endif
+-/* Define to `long' if <sys/types.h> does not define. */
++/* Define to `long int' if <sys/types.h> does not define. */
+ #undef off_t
+-/* Define to `unsigned' if <sys/types.h> does not define. */
++/* Define to `unsigned int' if <sys/types.h> does not define. */
+ #undef size_t
+diff -Nrup binutils-2.17/ld/configure binutils-2.17-atmel/ld/configure
+--- binutils-2.17/ld/configure 2006-04-11 12:36:26.000000000 +0200
++++ binutils-2.17-atmel/ld/configure   2007-02-20 16:07:37.000000000 +0100
+@@ -1,25 +1,54 @@
+ #! /bin/sh
+ # Guess values for system-dependent variables and create Makefiles.
+-# Generated by GNU Autoconf 2.59.
++# Generated by GNU Autoconf 2.61.
+ #
+-# Copyright (C) 2003 Free Software Foundation, Inc.
++# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ # This configure script is free software; the Free Software Foundation
+ # gives unlimited permission to copy, distribute and modify it.
+ ## --------------------- ##
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -29,8 +58,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -44,18 +108,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -63,157 +128,388 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++# CDPATH.
++$as_unset CDPATH
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
++if test "x$CONFIG_SHELL" = x; then
++  if (eval ":") 2>/dev/null; then
++  as_have_required=yes
++else
++  as_have_required=no
++fi
++
++  if test $as_have_required = yes &&   (eval ":
++(as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
+ fi
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0) || { (exit 1); exit 1; }
++
++(
++  as_lineno_1=\$LINENO
++  as_lineno_2=\$LINENO
++  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
++  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
++") 2> /dev/null; then
++  :
++else
++  as_candidate_shells=
+     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
++  case $as_dir in
+        /*)
+-         if ("$as_dir/$as_base" -c '
++         for as_base in sh bash ksh sh5; do
++           as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
++         done;;
++       esac
++done
++IFS=$as_save_IFS
++
++
++      for as_shell in $as_candidate_shells $SHELL; do
++       # Try only shells that exist, to save several forks.
++       if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
++              { ("$as_shell") 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++_ASEOF
++}; then
++  CONFIG_SHELL=$as_shell
++             as_have_required=yes
++             if { "$as_shell" 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++(as_func_return () {
++  (exit $1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = "$1" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test $exitcode = 0) || { (exit 1); exit 1; }
++
++(
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
++
++_ASEOF
++}; then
++  break
++fi
++
++fi
++
++      done
++
++      if test "x$CONFIG_SHELL" != x; then
++  for as_var in BASH_ENV ENV
++        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++        done
++        export CONFIG_SHELL
++        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
++fi
++
++
++    if test $as_have_required = no; then
++  echo This script requires a shell more modern than all the
++      echo shells that I found on your system.  Please install a
++      echo modern shell, or manually run the script under such a
++      echo shell if you do have one.
++      { (exit 1); exit 1; }
++fi
++
++
++fi
++
++fi
++
++
++
++(eval "as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0") || {
++  echo No shell found that supports shell functions.
++  echo Please tell autoconf@gnu.org about your system,
++  echo including any error possibly output before this
++  echo message
++}
++
++
++
++  as_lineno_1=$LINENO
++  as_lineno_2=$LINENO
++  test "x$as_lineno_1" != "x$as_lineno_2" &&
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
++  chmod +x "$as_me.lineno" ||
+     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -222,7 +518,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -231,39 +548,27 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
++exec 7<&0 </dev/null 6>&1
+ # Name of the host.
+ # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+ # so uname gets run too.
+ ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+-exec 6>&1
+-
+ #
+ # Initializations.
+ #
+ ac_default_prefix=/usr/local
++ac_clean_files=
+ ac_config_libobj_dir=.
++LIBOBJS=
+ cross_compiling=no
+ subdirs=
+ MFLAGS=
+ MAKEFLAGS=
+ SHELL=${CONFIG_SHELL-/bin/sh}
+-# Maximum number of lines to put in a shell here document.
+-# This variable seems obsolete.  It should probably be removed, and
+-# only ac_max_sed_lines should be used.
+-: ${ac_max_here_lines=38}
+-
+ # Identity of this package.
+ PACKAGE_NAME=
+ PACKAGE_TARNAME=
+@@ -275,42 +580,191 @@ ac_unique_file="ldmain.c"
+ # Factoring default headers for most tests.
+ ac_includes_default="\
+ #include <stdio.h>
+-#if HAVE_SYS_TYPES_H
++#ifdef HAVE_SYS_TYPES_H
+ # include <sys/types.h>
+ #endif
+-#if HAVE_SYS_STAT_H
++#ifdef HAVE_SYS_STAT_H
+ # include <sys/stat.h>
+ #endif
+-#if STDC_HEADERS
++#ifdef STDC_HEADERS
+ # include <stdlib.h>
+ # include <stddef.h>
+ #else
+-# if HAVE_STDLIB_H
++# ifdef HAVE_STDLIB_H
+ #  include <stdlib.h>
+ # endif
+ #endif
+-#if HAVE_STRING_H
+-# if !STDC_HEADERS && HAVE_MEMORY_H
++#ifdef HAVE_STRING_H
++# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+ #  include <memory.h>
+ # endif
+ # include <string.h>
+ #endif
+-#if HAVE_STRINGS_H
++#ifdef HAVE_STRINGS_H
+ # include <strings.h>
+ #endif
+-#if HAVE_INTTYPES_H
++#ifdef HAVE_INTTYPES_H
+ # include <inttypes.h>
+-#else
+-# if HAVE_STDINT_H
+-#  include <stdint.h>
+-# endif
+ #endif
+-#if HAVE_UNISTD_H
++#ifdef HAVE_STDINT_H
++# include <stdint.h>
++#endif
++#ifdef HAVE_UNISTD_H
+ # include <unistd.h>
+ #endif"
+-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE LN_S RANLIB ac_ct_RANLIB LIBTOOL use_sysroot TARGET_SYSTEM_ROOT TARGET_SYSTEM_ROOT_DEFINE WARN_CFLAGS NO_WERROR CPP EGREP ALLOCA USE_NLS MSGFMT GMSGFMT XGETTEXT USE_INCLUDED_LIBINTL CATALOGS CATOBJEXT DATADIRNAME GMOFILES INSTOBJEXT INTLDEPS INTLLIBS INTLOBJS POFILES POSUB INCLUDE_LOCALE_H GT_NO GT_YES MKINSTALLDIRS l YACC LEX LEXLIB LEX_OUTPUT_ROOT MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT HDEFINES HOSTING_CRT0 HOSTING_LIBS NATIVE_LIB_DIRS STRINGIFY EMUL EMULATION_OFILES EMUL_EXTRA_OFILES LIB_PATH EMULATION_LIBPATH TESTBFDLIB datarootdir docdir htmldir LIBOBJS LTLIBOBJS'
++ac_subst_vars='SHELL
++PATH_SEPARATOR
++PACKAGE_NAME
++PACKAGE_TARNAME
++PACKAGE_VERSION
++PACKAGE_STRING
++PACKAGE_BUGREPORT
++exec_prefix
++prefix
++program_transform_name
++bindir
++sbindir
++libexecdir
++datarootdir
++datadir
++sysconfdir
++sharedstatedir
++localstatedir
++includedir
++oldincludedir
++docdir
++infodir
++htmldir
++dvidir
++pdfdir
++psdir
++libdir
++localedir
++mandir
++DEFS
++ECHO_C
++ECHO_N
++ECHO_T
++LIBS
++build_alias
++host_alias
++target_alias
++build
++build_cpu
++build_vendor
++build_os
++host
++host_cpu
++host_vendor
++host_os
++target
++target_cpu
++target_vendor
++target_os
++CC
++CFLAGS
++LDFLAGS
++CPPFLAGS
++ac_ct_CC
++EXEEXT
++OBJEXT
++INSTALL_PROGRAM
++INSTALL_SCRIPT
++INSTALL_DATA
++CYGPATH_W
++PACKAGE
++VERSION
++ACLOCAL
++AUTOCONF
++AUTOMAKE
++AUTOHEADER
++MAKEINFO
++install_sh
++STRIP
++INSTALL_STRIP_PROGRAM
++mkdir_p
++AWK
++SET_MAKE
++am__leading_dot
++AMTAR
++am__tar
++am__untar
++DEPDIR
++am__include
++am__quote
++AMDEP_TRUE
++AMDEP_FALSE
++AMDEPBACKSLASH
++CCDEPMODE
++am__fastdepCC_TRUE
++am__fastdepCC_FALSE
++LN_S
++RANLIB
++LIBTOOL
++use_sysroot
++TARGET_SYSTEM_ROOT
++TARGET_SYSTEM_ROOT_DEFINE
++WARN_CFLAGS
++NO_WERROR
++CPP
++GREP
++EGREP
++ALLOCA
++USE_NLS
++MSGFMT
++GMSGFMT
++XGETTEXT
++USE_INCLUDED_LIBINTL
++CATALOGS
++CATOBJEXT
++DATADIRNAME
++GMOFILES
++INSTOBJEXT
++INTLDEPS
++INTLLIBS
++INTLOBJS
++POFILES
++POSUB
++INCLUDE_LOCALE_H
++GT_NO
++GT_YES
++MKINSTALLDIRS
++l
++YACC
++YFLAGS
++LEX
++LEX_OUTPUT_ROOT
++LEXLIB
++MAINTAINER_MODE_TRUE
++MAINTAINER_MODE_FALSE
++MAINT
++HDEFINES
++HOSTING_CRT0
++HOSTING_LIBS
++NATIVE_LIB_DIRS
++STRINGIFY
++EMUL
++EMULATION_OFILES
++EMUL_EXTRA_OFILES
++LIB_PATH
++EMULATION_LIBPATH
++TESTBFDLIB
++LIBOBJS
++LTLIBOBJS'
+ ac_subst_files='TDIRS'
++      ac_precious_vars='build_alias
++host_alias
++target_alias
++CC
++CFLAGS
++LDFLAGS
++LIBS
++CPPFLAGS
++CPP
++YACC
++YFLAGS'
++
+ # Initialize some variables set by options.
+ ac_init_help=
+@@ -337,34 +791,48 @@ x_libraries=NONE
+ # and all the variables that are supposed to be based on exec_prefix
+ # by default will actually change.
+ # Use braces instead of parens because sh, perl, etc. also accept them.
++# (The list follows the same order as the GNU Coding Standards.)
+ bindir='${exec_prefix}/bin'
+ sbindir='${exec_prefix}/sbin'
+ libexecdir='${exec_prefix}/libexec'
+-datadir='${prefix}/share'
++datarootdir='${prefix}/share'
++datadir='${datarootdir}'
+ sysconfdir='${prefix}/etc'
+ sharedstatedir='${prefix}/com'
+ localstatedir='${prefix}/var'
+-libdir='${exec_prefix}/lib'
+ includedir='${prefix}/include'
+ oldincludedir='/usr/include'
+-infodir='${prefix}/info'
+-mandir='${prefix}/man'
++docdir='${datarootdir}/doc/${PACKAGE}'
++infodir='${datarootdir}/info'
++htmldir='${docdir}'
++dvidir='${docdir}'
++pdfdir='${docdir}'
++psdir='${docdir}'
++libdir='${exec_prefix}/lib'
++localedir='${datarootdir}/locale'
++mandir='${datarootdir}/man'
+ ac_prev=
++ac_dashdash=
+ for ac_option
+ do
+   # If the previous option needs an argument, assign it.
+   if test -n "$ac_prev"; then
+-    eval "$ac_prev=\$ac_option"
++    eval $ac_prev=\$ac_option
+     ac_prev=
+     continue
+   fi
+-  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
++  case $ac_option in
++  *=*)        ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
++  *)  ac_optarg=yes ;;
++  esac
+   # Accept the important Cygnus configure options, so we can diagnose typos.
+-  case $ac_option in
++  case $ac_dashdash$ac_option in
++  --)
++    ac_dashdash=yes ;;
+   -bindir | --bindir | --bindi | --bind | --bin | --bi)
+     ac_prev=bindir ;;
+@@ -386,33 +854,45 @@ do
+   --config-cache | -C)
+     cache_file=config.cache ;;
+-  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
++  -datadir | --datadir | --datadi | --datad)
+     ac_prev=datadir ;;
+-  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+-  | --da=*)
++  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+     datadir=$ac_optarg ;;
++  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
++  | --dataroo | --dataro | --datar)
++    ac_prev=datarootdir ;;
++  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
++  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
++    datarootdir=$ac_optarg ;;
++
+   -disable-* | --disable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    eval "enable_$ac_feature=no" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=no ;;
++
++  -docdir | --docdir | --docdi | --doc | --do)
++    ac_prev=docdir ;;
++  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
++    docdir=$ac_optarg ;;
++
++  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
++    ac_prev=dvidir ;;
++  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
++    dvidir=$ac_optarg ;;
+   -enable-* | --enable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "enable_$ac_feature='$ac_optarg'" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=\$ac_optarg ;;
+   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+@@ -439,6 +919,12 @@ do
+   -host=* | --host=* | --hos=* | --ho=*)
+     host_alias=$ac_optarg ;;
++  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
++    ac_prev=htmldir ;;
++  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
++  | --ht=*)
++    htmldir=$ac_optarg ;;
++
+   -includedir | --includedir | --includedi | --included | --include \
+   | --includ | --inclu | --incl | --inc)
+     ac_prev=includedir ;;
+@@ -463,13 +949,16 @@ do
+   | --libexe=* | --libex=* | --libe=*)
+     libexecdir=$ac_optarg ;;
++  -localedir | --localedir | --localedi | --localed | --locale)
++    ac_prev=localedir ;;
++  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
++    localedir=$ac_optarg ;;
++
+   -localstatedir | --localstatedir | --localstatedi | --localstated \
+-  | --localstate | --localstat | --localsta | --localst \
+-  | --locals | --local | --loca | --loc | --lo)
++  | --localstate | --localstat | --localsta | --localst | --locals)
+     ac_prev=localstatedir ;;
+   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+-  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+-  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
++  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+     localstatedir=$ac_optarg ;;
+   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+@@ -534,6 +1023,16 @@ do
+   | --progr-tra=* | --program-tr=* | --program-t=*)
+     program_transform_name=$ac_optarg ;;
++  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
++    ac_prev=pdfdir ;;
++  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
++    pdfdir=$ac_optarg ;;
++
++  -psdir | --psdir | --psdi | --psd | --ps)
++    ac_prev=psdir ;;
++  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
++    psdir=$ac_optarg ;;
++
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil)
+     silent=yes ;;
+@@ -586,24 +1085,20 @@ do
+   -with-* | --with-*)
+     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package| sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "with_$ac_package='$ac_optarg'" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=\$ac_optarg ;;
+   -without-* | --without-*)
+     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package | sed 's/-/_/g'`
+-    eval "with_$ac_package=no" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=no ;;
+   --x)
+     # Obsolete; use --with-x.
+@@ -634,8 +1129,7 @@ Try \`$0 --help' for more information." 
+     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
+    { (exit 1); exit 1; }; }
+-    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
+-    eval "$ac_envvar='$ac_optarg'"
++    eval $ac_envvar=\$ac_optarg
+     export $ac_envvar ;;
+   *)
+@@ -655,27 +1149,19 @@ if test -n "$ac_prev"; then
+    { (exit 1); exit 1; }; }
+ fi
+-# Be sure to have absolute paths.
+-for ac_var in exec_prefix prefix
++# Be sure to have absolute directory names.
++for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
++              datadir sysconfdir sharedstatedir localstatedir includedir \
++              oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
++              libdir localedir mandir
+ do
+-  eval ac_val=$`echo $ac_var`
++  eval ac_val=\$$ac_var
+   case $ac_val in
+-    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
+-  esac
+-done
+-
+-# Be sure to have absolute paths.
+-for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
+-            localstatedir libdir includedir oldincludedir infodir mandir
+-do
+-  eval ac_val=$`echo $ac_var`
+-  case $ac_val in
+-    [\\/$]* | ?:[\\/]* ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
++    [\\/$]* | ?:[\\/]* )  continue;;
++    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+   esac
++  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
++   { (exit 1); exit 1; }; }
+ done
+ # There might be people who depend on the old broken behavior: `$host'
+@@ -702,74 +1188,76 @@ test -n "$host_alias" && ac_tool_prefix=
+ test "$silent" = yes && exec 6>/dev/null
++ac_pwd=`pwd` && test -n "$ac_pwd" &&
++ac_ls_di=`ls -di .` &&
++ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
++  { echo "$as_me: error: Working directory cannot be determined" >&2
++   { (exit 1); exit 1; }; }
++test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
++  { echo "$as_me: error: pwd does not report name of working directory" >&2
++   { (exit 1); exit 1; }; }
++
++
+ # Find the source files, if location was not specified.
+ if test -z "$srcdir"; then
+   ac_srcdir_defaulted=yes
+-  # Try the directory containing this script, then its parent.
+-  ac_confdir=`(dirname "$0") 2>/dev/null ||
++  # Try the directory containing this script, then the parent directory.
++  ac_confdir=`$as_dirname -- "$0" ||
+ $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$0" : 'X\(//\)[^/]' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$0" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   srcdir=$ac_confdir
+-  if test ! -r $srcdir/$ac_unique_file; then
++  if test ! -r "$srcdir/$ac_unique_file"; then
+     srcdir=..
+   fi
+ else
+   ac_srcdir_defaulted=no
+ fi
+-if test ! -r $srcdir/$ac_unique_file; then
+-  if test "$ac_srcdir_defaulted" = yes; then
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
+-   { (exit 1); exit 1; }; }
+-  else
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-fi
+-(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
+-  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
+-   { (exit 1); exit 1; }; }
+-srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
+-ac_env_build_alias_set=${build_alias+set}
+-ac_env_build_alias_value=$build_alias
+-ac_cv_env_build_alias_set=${build_alias+set}
+-ac_cv_env_build_alias_value=$build_alias
+-ac_env_host_alias_set=${host_alias+set}
+-ac_env_host_alias_value=$host_alias
+-ac_cv_env_host_alias_set=${host_alias+set}
+-ac_cv_env_host_alias_value=$host_alias
+-ac_env_target_alias_set=${target_alias+set}
+-ac_env_target_alias_value=$target_alias
+-ac_cv_env_target_alias_set=${target_alias+set}
+-ac_cv_env_target_alias_value=$target_alias
+-ac_env_CC_set=${CC+set}
+-ac_env_CC_value=$CC
+-ac_cv_env_CC_set=${CC+set}
+-ac_cv_env_CC_value=$CC
+-ac_env_CFLAGS_set=${CFLAGS+set}
+-ac_env_CFLAGS_value=$CFLAGS
+-ac_cv_env_CFLAGS_set=${CFLAGS+set}
+-ac_cv_env_CFLAGS_value=$CFLAGS
+-ac_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_env_LDFLAGS_value=$LDFLAGS
+-ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_cv_env_LDFLAGS_value=$LDFLAGS
+-ac_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_env_CPPFLAGS_value=$CPPFLAGS
+-ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_cv_env_CPPFLAGS_value=$CPPFLAGS
+-ac_env_CPP_set=${CPP+set}
+-ac_env_CPP_value=$CPP
+-ac_cv_env_CPP_set=${CPP+set}
+-ac_cv_env_CPP_value=$CPP
++if test ! -r "$srcdir/$ac_unique_file"; then
++  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
++  { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
++   { (exit 1); exit 1; }; }
++fi
++ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
++ac_abs_confdir=`(
++      cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2
++   { (exit 1); exit 1; }; }
++      pwd)`
++# When building in place, set srcdir=.
++if test "$ac_abs_confdir" = "$ac_pwd"; then
++  srcdir=.
++fi
++# Remove unnecessary trailing slashes from srcdir.
++# Double slashes in file names in object file debugging info
++# mess up M-x gdb in Emacs.
++case $srcdir in
++*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
++esac
++for ac_var in $ac_precious_vars; do
++  eval ac_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_env_${ac_var}_value=\$${ac_var}
++  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_cv_env_${ac_var}_value=\$${ac_var}
++done
+ #
+ # Report the --help message.
+@@ -798,9 +1286,6 @@ Configuration:
+   -n, --no-create         do not create output files
+       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+-_ACEOF
+-
+-  cat <<_ACEOF
+ Installation directories:
+   --prefix=PREFIX         install architecture-independent files in PREFIX
+                         [$ac_default_prefix]
+@@ -818,15 +1303,22 @@ Fine tuning of the installation director
+   --bindir=DIR           user executables [EPREFIX/bin]
+   --sbindir=DIR          system admin executables [EPREFIX/sbin]
+   --libexecdir=DIR       program executables [EPREFIX/libexec]
+-  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
+   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
+   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
+   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
+   --libdir=DIR           object code libraries [EPREFIX/lib]
+   --includedir=DIR       C header files [PREFIX/include]
+   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
+-  --infodir=DIR          info documentation [PREFIX/info]
+-  --mandir=DIR           man documentation [PREFIX/man]
++  --datarootdir=DIR      read-only arch.-independent data root [PREFIX/share]
++  --datadir=DIR          read-only architecture-independent data [DATAROOTDIR]
++  --infodir=DIR          info documentation [DATAROOTDIR/info]
++  --localedir=DIR        locale-dependent data [DATAROOTDIR/locale]
++  --mandir=DIR           man documentation [DATAROOTDIR/man]
++  --docdir=DIR           documentation root [DATAROOTDIR/doc/PACKAGE]
++  --htmldir=DIR          html documentation [DOCDIR]
++  --dvidir=DIR           dvi documentation [DOCDIR]
++  --pdfdir=DIR           pdf documentation [DOCDIR]
++  --psdir=DIR            ps documentation [DOCDIR]
+ _ACEOF
+   cat <<\_ACEOF
+@@ -878,126 +1370,100 @@ Some influential environment variables:
+   CFLAGS      C compiler flags
+   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+               nonstandard directory <lib dir>
+-  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
+-              headers in a nonstandard directory <include dir>
++  LIBS        libraries to pass to the linker, e.g. -l<library>
++  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
++              you have headers in a nonstandard directory <include dir>
+   CPP         C preprocessor
++  YACC        The `Yet Another C Compiler' implementation to use. Defaults to
++              the first program found out of: `bison -y', `byacc', `yacc'.
++  YFLAGS      The list of arguments that will be passed by default to $YACC.
++              This script will default YFLAGS to the empty string to avoid a
++              default value of `-d' given by some make applications.
+ Use these variables to override the choices made by `configure' or to help
+ it to find libraries and programs with nonstandard names/locations.
+ _ACEOF
++ac_status=$?
+ fi
+ if test "$ac_init_help" = "recursive"; then
+   # If there are subdirs, report their specific --help.
+-  ac_popdir=`pwd`
+   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+-    test -d $ac_dir || continue
++    test -d "$ac_dir" || continue
+     ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
+-
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
+-
+-    cd $ac_dir
+-    # Check for guested configure; otherwise get Cygnus style configure.
+-    if test -f $ac_srcdir/configure.gnu; then
+-      echo
+-      $SHELL $ac_srcdir/configure.gnu  --help=recursive
+-    elif test -f $ac_srcdir/configure; then
+-      echo
+-      $SHELL $ac_srcdir/configure  --help=recursive
+-    elif test -f $ac_srcdir/configure.ac ||
+-         test -f $ac_srcdir/configure.in; then
+-      echo
+-      $ac_configure --help
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
++
++    cd "$ac_dir" || { ac_status=$?; continue; }
++    # Check for guested configure.
++    if test -f "$ac_srcdir/configure.gnu"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
++    elif test -f "$ac_srcdir/configure"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure" --help=recursive
+     else
+       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+-    fi
+-    cd $ac_popdir
++    fi || ac_status=$?
++    cd "$ac_pwd" || { ac_status=$?; break; }
+   done
+ fi
+-test -n "$ac_init_help" && exit 0
++test -n "$ac_init_help" && exit $ac_status
+ if $ac_init_version; then
+   cat <<\_ACEOF
++configure
++generated by GNU Autoconf 2.61
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ This configure script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it.
+ _ACEOF
+-  exit 0
++  exit
+ fi
+-exec 5>config.log
+-cat >&5 <<_ACEOF
++cat >config.log <<_ACEOF
+ This file contains any messages produced by compilers while
+ running configure, to aid debugging if configure makes a mistake.
+ It was created by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   $ $0 $@
+ _ACEOF
++exec 5>>config.log
+ {
+ cat <<_ASUNAME
+ ## --------- ##
+@@ -1016,7 +1482,7 @@ uname -v = `(uname -v) 2>/dev/null || ec
+ /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+ /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+ /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+-hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
++/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+ /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+ /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+ /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+@@ -1030,6 +1496,7 @@ do
+   test -z "$as_dir" && as_dir=.
+   echo "PATH: $as_dir"
+ done
++IFS=$as_save_IFS
+ } >&5
+@@ -1051,7 +1518,6 @@ _ACEOF
+ ac_configure_args=
+ ac_configure_args0=
+ ac_configure_args1=
+-ac_sep=
+ ac_must_keep_next=false
+ for ac_pass in 1 2
+ do
+@@ -1062,7 +1528,7 @@ do
+     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+     | -silent | --silent | --silen | --sile | --sil)
+       continue ;;
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
++    *\'*)
+       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+     esac
+     case $ac_pass in
+@@ -1084,9 +1550,7 @@ do
+         -* ) ac_must_keep_next=true ;;
+       esac
+       fi
+-      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
+-      # Get rid of the leading space.
+-      ac_sep=" "
++      ac_configure_args="$ac_configure_args '$ac_arg'"
+       ;;
+     esac
+   done
+@@ -1097,8 +1561,8 @@ $as_unset ac_configure_args1 || test "${
+ # When interrupted or exit'd, cleanup temporary files, and complete
+ # config.log.  We remove comments because anyway the quotes in there
+ # would cause problems or look ugly.
+-# WARNING: Be sure not to use single quotes in there, as some shells,
+-# such as our DU 5.0 friend, will then `close' the trap.
++# WARNING: Use '\'' to represent an apostrophe within the trap.
++# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+ trap 'exit_status=$?
+   # Save into config.log some information that might help in debugging.
+   {
+@@ -1111,20 +1575,34 @@ trap 'exit_status=$?
+ _ASBOX
+     echo
+     # The following way of writing the cache mishandles newlines in values,
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
+   (set) 2>&1 |
+-    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       sed -n \
+-      "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
+-        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
+-      ;;
++      "s/'\''/'\''\\\\'\'''\''/g;
++        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
++      ;; #(
+     *)
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-}
++    esac |
++    sort
++)
+     echo
+     cat <<\_ASBOX
+@@ -1135,22 +1613,28 @@ _ASBOX
+     echo
+     for ac_var in $ac_subst_vars
+     do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+     done | sort
+     echo
+     if test -n "$ac_subst_files"; then
+       cat <<\_ASBOX
+-## ------------- ##
+-## Output files. ##
+-## ------------- ##
++## ------------------- ##
++## File substitutions. ##
++## ------------------- ##
+ _ASBOX
+       echo
+       for ac_var in $ac_subst_files
+       do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+       done | sort
+       echo
+     fi
+@@ -1162,26 +1646,24 @@ _ASBOX
+ ## ----------- ##
+ _ASBOX
+       echo
+-      sed "/^$/d" confdefs.h | sort
++      cat confdefs.h
+       echo
+     fi
+     test "$ac_signal" != 0 &&
+       echo "$as_me: caught signal $ac_signal"
+     echo "$as_me: exit $exit_status"
+   } >&5
+-  rm -f core *.core &&
+-  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
++  rm -f core *.core core.conftest.* &&
++    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+     exit $exit_status
+-     ' 0
++' 0
+ for ac_signal in 1 2 13 15; do
+   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+ done
+ ac_signal=0
+ # confdefs.h avoids OS command line length limits that DEFS can exceed.
+-rm -rf conftest* confdefs.h
+-# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+-echo >confdefs.h
++rm -f -r conftest* confdefs.h
+ # Predefined preprocessor variables.
+@@ -1212,14 +1694,17 @@ _ACEOF
+ # Let the site file select an alternate cache file if it wants to.
+ # Prefer explicitly selected file to automatically selected ones.
+-if test -z "$CONFIG_SITE"; then
+-  if test "x$prefix" != xNONE; then
+-    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+-  else
+-    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+-  fi
++if test -n "$CONFIG_SITE"; then
++  set x "$CONFIG_SITE"
++elif test "x$prefix" != xNONE; then
++  set x "$prefix/share/config.site" "$prefix/etc/config.site"
++else
++  set x "$ac_default_prefix/share/config.site" \
++      "$ac_default_prefix/etc/config.site"
+ fi
+-for ac_site_file in $CONFIG_SITE; do
++shift
++for ac_site_file
++do
+   if test -r "$ac_site_file"; then
+     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
+ echo "$as_me: loading site script $ac_site_file" >&6;}
+@@ -1235,8 +1720,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -1248,12 +1733,11 @@ fi
+ # Check that the precious variables saved in the cache have kept the same
+ # value.
+ ac_cache_corrupted=false
+-for ac_var in `(set) 2>&1 |
+-             sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
++for ac_var in $ac_precious_vars; do
+   eval ac_old_set=\$ac_cv_env_${ac_var}_set
+   eval ac_new_set=\$ac_env_${ac_var}_set
+-  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
+-  eval ac_new_val="\$ac_env_${ac_var}_value"
++  eval ac_old_val=\$ac_cv_env_${ac_var}_value
++  eval ac_new_val=\$ac_env_${ac_var}_value
+   case $ac_old_set,$ac_new_set in
+     set,)
+       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+@@ -1278,8 +1762,7 @@ echo "$as_me:   current value: $ac_new_v
+   # Pass precious variables to config.status.
+   if test "$ac_new_set" = set; then
+     case $ac_new_val in
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+-      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
++    *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+     *) ac_arg=$ac_var=$ac_new_val ;;
+     esac
+     case " $ac_configure_args " in
+@@ -1296,12 +1779,6 @@ echo "$as_me: error: run \`make distclea
+    { (exit 1); exit 1; }; }
+ fi
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+@@ -1318,108 +1795,163 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ ac_aux_dir=
+-for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
+-  if test -f $ac_dir/install-sh; then
++for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
++  if test -f "$ac_dir/install-sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install-sh -c"
+     break
+-  elif test -f $ac_dir/install.sh; then
++  elif test -f "$ac_dir/install.sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install.sh -c"
+     break
+-  elif test -f $ac_dir/shtool; then
++  elif test -f "$ac_dir/shtool"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/shtool install -c"
+     break
+   fi
+ done
+ if test -z "$ac_aux_dir"; then
+-  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
+-echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
++  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&5
++echo "$as_me: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-ac_config_guess="$SHELL $ac_aux_dir/config.guess"
+-ac_config_sub="$SHELL $ac_aux_dir/config.sub"
+-ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
++
++# These three variables are undocumented and unsupported,
++# and are intended to be withdrawn in a future Autoconf release.
++# They can cause serious problems if a builder's source tree is in a directory
++# whose full name contains unusual characters.
++ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
++ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
++ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
++
+ # Make sure we can run config.sub.
+-$ac_config_sub sun4 >/dev/null 2>&1 ||
+-  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
+-echo "$as_me: error: cannot run $ac_config_sub" >&2;}
++$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
++  { { echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
++echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking build system type" >&5
+-echo $ECHO_N "checking build system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking build system type" >&5
++echo $ECHO_N "checking build system type... $ECHO_C" >&6; }
+ if test "${ac_cv_build+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_build_alias=$build_alias
+-test -z "$ac_cv_build_alias" &&
+-  ac_cv_build_alias=`$ac_config_guess`
+-test -z "$ac_cv_build_alias" &&
++  ac_build_alias=$build_alias
++test "x$ac_build_alias" = x &&
++  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
++test "x$ac_build_alias" = x &&
+   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
+ echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
+    { (exit 1); exit 1; }; }
+-ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
++ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
++  { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_build" >&5
+-echo "${ECHO_T}$ac_cv_build" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_build" >&5
++echo "${ECHO_T}$ac_cv_build" >&6; }
++case $ac_cv_build in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
++echo "$as_me: error: invalid value of canonical build" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ build=$ac_cv_build
+-build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_build
++shift
++build_cpu=$1
++build_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++build_os=$*
++IFS=$ac_save_IFS
++case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking host system type" >&5
+-echo $ECHO_N "checking host system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking host system type" >&5
++echo $ECHO_N "checking host system type... $ECHO_C" >&6; }
+ if test "${ac_cv_host+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_host_alias=$host_alias
+-test -z "$ac_cv_host_alias" &&
+-  ac_cv_host_alias=$ac_cv_build_alias
+-ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
++  if test "x$host_alias" = x; then
++  ac_cv_host=$ac_cv_build
++else
++  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_host" >&5
+-echo "${ECHO_T}$ac_cv_host" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_host" >&5
++echo "${ECHO_T}$ac_cv_host" >&6; }
++case $ac_cv_host in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
++echo "$as_me: error: invalid value of canonical host" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ host=$ac_cv_host
+-host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_host
++shift
++host_cpu=$1
++host_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++host_os=$*
++IFS=$ac_save_IFS
++case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking target system type" >&5
+-echo $ECHO_N "checking target system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking target system type" >&5
++echo $ECHO_N "checking target system type... $ECHO_C" >&6; }
+ if test "${ac_cv_target+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_target_alias=$target_alias
+-test "x$ac_cv_target_alias" = "x" &&
+-  ac_cv_target_alias=$ac_cv_host_alias
+-ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
++  if test "x$target_alias" = x; then
++  ac_cv_target=$ac_cv_host
++else
++  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_target" >&5
+-echo "${ECHO_T}$ac_cv_target" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_target" >&5
++echo "${ECHO_T}$ac_cv_target" >&6; }
++case $ac_cv_target in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical target" >&5
++echo "$as_me: error: invalid value of canonical target" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ target=$ac_cv_target
+-target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_target
++shift
++target_cpu=$1
++target_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++target_os=$*
++IFS=$ac_save_IFS
++case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
+ # The aliases save the names the user supplied, while $host etc.
+@@ -1436,8 +1968,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1450,32 +1982,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_CC"; then
+   ac_ct_CC=$CC
+   # Extract the first word of "gcc", so it can be a program name with args.
+ set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1488,36 +2022,51 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ else
+   CC="$ac_cv_prog_CC"
+ fi
+ if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1530,74 +2079,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}cc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
+-
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++  fi
+ fi
+ if test -z "$CC"; then
+   # Extract the first word of "cc", so it can be a program name with args.
+ set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1611,7 +2120,7 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+        continue
+@@ -1622,6 +2131,7 @@ do
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ if test $ac_prog_rejected = yes; then
+   # We found a bogon in the path, so make sure we never use it.
+@@ -1639,22 +2149,23 @@ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$CC"; then
+   if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1667,36 +2178,38 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+     test -n "$CC" && break
+   done
+ fi
+ if test -z "$CC"; then
+   ac_ct_CC=$CC
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1709,29 +2222,45 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$ac_ct_CC" && break
+ done
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ fi
+ fi
+@@ -1744,21 +2273,35 @@ See \`config.log' for more details." >&2
+    { (exit 1); exit 1; }; }
+ # Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
++echo "$as_me:$LINENO: checking for C compiler version" >&5
+ ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+@@ -1783,47 +2326,77 @@ ac_clean_files="$ac_clean_files a.out a.
+ # Try to create an executable without -o first, disregard a.out.
+ # It will help us diagnose broken compilers, and finding out an intuition
+ # of exeext.
+-echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
+-echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
++echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6; }
+ ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+-if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
+-  (eval $ac_link_default) 2>&5
++#
++# List of possible output files, starting from the most likely.
++# The algorithm is not robust to junk in `.', hence go to wildcards (a.*)
++# only as a last resort.  b.out is created by i960 compilers.
++ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'
++#
++# The IRIX 6 linker writes into existing files which may not be
++# executable, retaining their permissions.  Remove them first so a
++# subsequent execution test works.
++ac_rmfiles=
++for ac_file in $ac_files
++do
++  case $ac_file in
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
++    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
++  esac
++done
++rm -f $ac_rmfiles
++
++if { (ac_try="$ac_link_default"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link_default") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  # Find the output, starting from the most likely.  This scheme is
+-# not robust to junk in `.', hence go to wildcards (a.*) only as a last
+-# resort.
+-
+-# Be careful to initialize this variable, since it used to be cached.
+-# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
+-ac_cv_exeext=
+-# b.out is created by i960 compilers.
+-for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
++  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
++# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
++# in a Makefile.  We should not override ac_cv_exeext if it was cached,
++# so that the user can short-circuit this test for compilers unknown to
++# Autoconf.
++for ac_file in $ac_files ''
+ do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
+-      ;;
+-    conftest.$ac_ext )
+-      # This is the source file.
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )
+       ;;
+     [ab].out )
+       # We found the default executable, but exeext='' is most
+       # certainly right.
+       break;;
+     *.* )
+-      ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-      # FIXME: I believe we export ac_cv_exeext for Libtool,
+-      # but it would be cool to find out if it's true.  Does anybody
+-      # maintain Libtool? --akim.
+-      export ac_cv_exeext
++        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
++      then :; else
++         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
++      fi
++      # We set ac_cv_exeext here because the later test for it is not
++      # safe: cross compilers may not add the suffix if given an `-o'
++      # argument, so we may need to know it at that point already.
++      # Even if this section looks crufty: it has the advantage of
++      # actually working.
+       break;;
+     * )
+       break;;
+   esac
+ done
++test "$ac_cv_exeext" = no && ac_cv_exeext=
++
+ else
++  ac_file=''
++fi
++
++{ echo "$as_me:$LINENO: result: $ac_file" >&5
++echo "${ECHO_T}$ac_file" >&6; }
++if test -z "$ac_file"; then
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+@@ -1835,19 +2408,21 @@ See \`config.log' for more details." >&2
+ fi
+ ac_exeext=$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_file" >&5
+-echo "${ECHO_T}$ac_file" >&6
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether the C compiler works" >&5
+-echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether the C compiler works" >&5
++echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6; }
+ # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
+ # If not cross compiling, check that we can run a simple program.
+ if test "$cross_compiling" != yes; then
+   if { ac_try='./$ac_file'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -1866,22 +2441,27 @@ See \`config.log' for more details." >&2
+     fi
+   fi
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ rm -f a.out a.exe conftest$ac_cv_exeext b.out
+ ac_clean_files=$ac_clean_files_save
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
+-echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
+-echo "$as_me:$LINENO: result: $cross_compiling" >&5
+-echo "${ECHO_T}$cross_compiling" >&6
+-
+-echo "$as_me:$LINENO: checking for suffix of executables" >&5
+-echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
++echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }
++{ echo "$as_me:$LINENO: result: $cross_compiling" >&5
++echo "${ECHO_T}$cross_compiling" >&6; }
++
++{ echo "$as_me:$LINENO: checking for suffix of executables" >&5
++echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+@@ -1892,9 +2472,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_l
+ for ac_file in conftest.exe conftest conftest.*; do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
+     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-        export ac_cv_exeext
+         break;;
+     * ) break;;
+   esac
+@@ -1908,14 +2487,14 @@ See \`config.log' for more details." >&2
+ fi
+ rm -f conftest$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
+-echo "${ECHO_T}$ac_cv_exeext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
++echo "${ECHO_T}$ac_cv_exeext" >&6; }
+ rm -f conftest.$ac_ext
+ EXEEXT=$ac_cv_exeext
+ ac_exeext=$EXEEXT
+-echo "$as_me:$LINENO: checking for suffix of object files" >&5
+-echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for suffix of object files" >&5
++echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }
+ if test "${ac_cv_objext+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1935,14 +2514,20 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.o conftest.obj
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>&5
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
++  for ac_file in conftest.o conftest.obj conftest.*; do
++  test -f "$ac_file" || continue;
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;
+     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+        break;;
+   esac
+@@ -1960,12 +2545,12 @@ fi
+ rm -f conftest.$ac_cv_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
+-echo "${ECHO_T}$ac_cv_objext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
++echo "${ECHO_T}$ac_cv_objext" >&6; }
+ OBJEXT=$ac_cv_objext
+ ac_objext=$OBJEXT
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+ if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1988,50 +2573,49 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+ GCC=`test $ac_compiler_gnu = yes && echo yes`
+ ac_test_CFLAGS=${CFLAGS+set}
+ ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -2047,38 +2631,118 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
++
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
+ if test "$ac_test_CFLAGS" = set; then
+   CFLAGS=$ac_save_CFLAGS
+ elif test $ac_cv_prog_cc_g = yes; then
+@@ -2094,12 +2758,12 @@ else
+     CFLAGS=
+   fi
+ fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_prog_cc_stdc=no
++  ac_cv_prog_cc_c89=no
+ ac_save_CC=$CC
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -2133,12 +2797,17 @@ static char *f (char * (*g) (char **, in
+ /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+    function prototypes and stuff, but not '\xHH' hex character constants.
+    These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
++   as 'x'.  The following induces an error, until -std is added to get
+    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+    array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
++   that's true only with -std.  */
+ int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
+ int test (int i, double x);
+ struct s1 {int (*f) (int a);};
+ struct s2 {int (*f) (double a);};
+@@ -2153,335 +2822,144 @@ return f (e, argv, 0) != argv[0]  ||  f 
+   return 0;
+ }
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+ do
+   CC="$ac_save_CC $ac_arg"
+   rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext
++
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+-rm -f conftest.$ac_ext conftest.$ac_objext
++rm -f conftest.$ac_ext
+ CC=$ac_save_CC
+ fi
+-
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
+   *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
+ esac
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
++
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
++
++
++{ echo "$as_me:$LINENO: checking for library containing strerror" >&5
++echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6; }
++if test "${ac_cv_search_strerror+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_func_search_save_LIBS=$LIBS
+ cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
++
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
++#ifdef __cplusplus
++extern "C"
++#endif
++char strerror ();
+ int
+ main ()
+ {
+-exit (42);
++return strerror ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++for ac_lib in '' cposix; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_strerror=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
+-fi
+-
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_strerror+set}" = set; then
++  break
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+-
+-echo "$as_me:$LINENO: checking for library containing strerror" >&5
+-echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6
++done
+ if test "${ac_cv_search_strerror+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_strerror=no
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="none required"
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_strerror" = no; then
+-  for ac_lib in cposix; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="-l$ac_lib"
+-break
++  :
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++  ac_cv_search_strerror=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
+-echo "${ECHO_T}$ac_cv_search_strerror" >&6
+-if test "$ac_cv_search_strerror" != no; then
+-  test "$ac_cv_search_strerror" = "none required" || LIBS="$ac_cv_search_strerror $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
++echo "${ECHO_T}$ac_cv_search_strerror" >&6; }
++ac_res=$ac_cv_search_strerror
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+@@ -2501,8 +2979,8 @@ am__api_version="1.9"
+ # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+ # OS/2's system install, which has a completely different semantic
+ # ./install, which can be erroneously created by make from ./install.sh.
+-echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+-echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+ if test -z "$INSTALL"; then
+ if test "${ac_cv_path_install+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -2524,7 +3002,7 @@ case $as_dir/ in
+     # by default.
+     for ac_prog in ginstall scoinst install; do
+       for ac_exec_ext in '' $ac_executable_extensions; do
+-      if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
++      if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+         if test $ac_prog = install &&
+           grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+           # AIX install.  It has an incompatible calling convention.
+@@ -2543,21 +3021,22 @@ case $as_dir/ in
+     ;;
+ esac
+ done
++IFS=$as_save_IFS
+ fi
+   if test "${ac_cv_path_install+set}" = set; then
+     INSTALL=$ac_cv_path_install
+   else
+-    # As a last resort, use the slow shell script.  We don't cache a
+-    # path for INSTALL within a source directory, because that will
++    # As a last resort, use the slow shell script.  Don't cache a
++    # value for INSTALL within a source directory, because that will
+     # break other packages using the cache if that directory is
+-    # removed, or if the path is relative.
++    # removed, or if the value is a relative name.
+     INSTALL=$ac_install_sh
+   fi
+ fi
+-echo "$as_me:$LINENO: result: $INSTALL" >&5
+-echo "${ECHO_T}$INSTALL" >&6
++{ echo "$as_me:$LINENO: result: $INSTALL" >&5
++echo "${ECHO_T}$INSTALL" >&6; }
+ # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+ # It thinks the first close brace ends the variable substitution.
+@@ -2567,8 +3046,8 @@ test -z "$INSTALL_SCRIPT" && INSTALL_SCR
+ test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+-echo "$as_me:$LINENO: checking whether build environment is sane" >&5
+-echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether build environment is sane" >&5
++echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6; }
+ # Just in case
+ sleep 1
+ echo timestamp > conftest.file
+@@ -2610,20 +3089,20 @@ echo "$as_me: error: newly created file 
+ Check your system clock" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ test "$program_prefix" != NONE &&
+-  program_transform_name="s,^,$program_prefix,;$program_transform_name"
++  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+ # Use a double $ so make ignores it.
+ test "$program_suffix" != NONE &&
+-  program_transform_name="s,\$,$program_suffix,;$program_transform_name"
++  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+ # Double any \ or $.  echo might interpret backslashes.
+ # By default was `s,x,x', remove it if useless.
+ cat <<\_ACEOF >conftest.sed
+ s/[\\$]/&&/g;s/;s,x,x,$//
+ _ACEOF
+ program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
+-rm conftest.sed
++rm -f conftest.sed
+ # expand $ac_aux_dir to an absolute path
+ am_aux_dir=`cd $ac_aux_dir && pwd`
+@@ -2675,8 +3154,8 @@ for ac_prog in gawk mawk nawk awk
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_AWK+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2689,54 +3168,57 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_AWK="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ AWK=$ac_cv_prog_AWK
+ if test -n "$AWK"; then
+-  echo "$as_me:$LINENO: result: $AWK" >&5
+-echo "${ECHO_T}$AWK" >&6
++  { echo "$as_me:$LINENO: result: $AWK" >&5
++echo "${ECHO_T}$AWK" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$AWK" && break
+ done
+-echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+-echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
+-set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
+-if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
++echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6; }
++set x ${MAKE-make}; ac_make=`echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
++if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.make <<\_ACEOF
++SHELL = /bin/sh
+ all:
+-      @echo 'ac_maketemp="$(MAKE)"'
++      @echo '@@@%%%=$(MAKE)=@@@%%%'
+ _ACEOF
+ # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
+-eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
+-if test -n "$ac_maketemp"; then
+-  eval ac_cv_prog_make_${ac_make}_set=yes
+-else
+-  eval ac_cv_prog_make_${ac_make}_set=no
+-fi
++case `${MAKE-make} -f conftest.make 2>/dev/null` in
++  *@@@%%%=?*=@@@%%%*)
++    eval ac_cv_prog_make_${ac_make}_set=yes;;
++  *)
++    eval ac_cv_prog_make_${ac_make}_set=no;;
++esac
+ rm -f conftest.make
+ fi
+-if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+   SET_MAKE=
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+   SET_MAKE="MAKE=${MAKE-make}"
+ fi
+@@ -2751,7 +3233,7 @@ rmdir .tst 2>/dev/null
+ DEPDIR="${am__leading_dot}deps"
+-          ac_config_commands="$ac_config_commands depfiles"
++ac_config_commands="$ac_config_commands depfiles"
+ am_make=${MAKE-make}
+@@ -2761,8 +3243,8 @@ am__doit:
+ .PHONY: am__doit
+ END
+ # If we don't find an include directive, just comment out the code.
+-echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
+-echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
++echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6; }
+ am__include="#"
+ am__quote=
+ _am_result=none
+@@ -2789,15 +3271,15 @@ if test "$am__include" = "#"; then
+ fi
+-echo "$as_me:$LINENO: result: $_am_result" >&5
+-echo "${ECHO_T}$_am_result" >&6
++{ echo "$as_me:$LINENO: result: $_am_result" >&5
++echo "${ECHO_T}$_am_result" >&6; }
+ rm -f confinc confmf
+-# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
++# Check whether --enable-dependency-tracking was given.
+ if test "${enable_dependency_tracking+set}" = set; then
+-  enableval="$enable_dependency_tracking"
++  enableval=$enable_dependency_tracking;
++fi
+-fi;
+ if test "x$enable_dependency_tracking" != xno; then
+   am_depcomp="$ac_aux_dir/depcomp"
+   AMDEPBACKSLASH='\'
+@@ -2872,8 +3354,8 @@ if test "$cross_compiling" != no; then
+   if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2886,32 +3368,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2924,27 +3408,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -2965,8 +3463,8 @@ am__tar='${AMTAR} chof - "$$tardir"'; am
+ depcc="$CC"   am_compiler_list=
+-echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
+-echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
++echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; }
+ if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3055,8 +3553,8 @@ else
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
+-echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
++echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; }
+ CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+@@ -3074,10 +3572,9 @@ fi
+-# Check whether --enable-shared or --disable-shared was given.
++# Check whether --enable-shared was given.
+ if test "${enable_shared+set}" = set; then
+-  enableval="$enable_shared"
+-  p=${PACKAGE-default}
++  enableval=$enable_shared; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_shared=yes ;;
+ no) enable_shared=no ;;
+@@ -3095,11 +3592,11 @@ no) enable_shared=no ;;
+ esac
+ else
+   enable_shared=yes
+-fi;
+-# Check whether --enable-static or --disable-static was given.
++fi
++
++# Check whether --enable-static was given.
+ if test "${enable_static+set}" = set; then
+-  enableval="$enable_static"
+-  p=${PACKAGE-default}
++  enableval=$enable_static; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_static=yes ;;
+ no) enable_static=no ;;
+@@ -3117,11 +3614,11 @@ no) enable_static=no ;;
+ esac
+ else
+   enable_static=yes
+-fi;
+-# Check whether --enable-fast-install or --disable-fast-install was given.
++fi
++
++# Check whether --enable-fast-install was given.
+ if test "${enable_fast_install+set}" = set; then
+-  enableval="$enable_fast_install"
+-  p=${PACKAGE-default}
++  enableval=$enable_fast_install; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_fast_install=yes ;;
+ no) enable_fast_install=no ;;
+@@ -3139,20 +3636,21 @@ no) enable_fast_install=no ;;
+ esac
+ else
+   enable_fast_install=yes
+-fi;
++fi
++
+-# Check whether --with-gnu-ld or --without-gnu-ld was given.
++# Check whether --with-gnu-ld was given.
+ if test "${with_gnu_ld+set}" = set; then
+-  withval="$with_gnu_ld"
+-  test "$withval" = no || with_gnu_ld=yes
++  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+ else
+   with_gnu_ld=no
+-fi;
++fi
++
+ ac_prog=ld
+ if test "$GCC" = yes; then
+   # Check if gcc -print-prog-name=ld gives a path.
+-  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
+-echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for ld used by GCC" >&5
++echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6; }
+   case $host in
+   *-*-mingw*)
+     # gcc leaves a trailing carriage return which upsets mingw
+@@ -3181,11 +3679,11 @@ echo $ECHO_N "checking for ld used by GC
+     ;;
+   esac
+ elif test "$with_gnu_ld" = yes; then
+-  echo "$as_me:$LINENO: checking for GNU ld" >&5
+-echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for GNU ld" >&5
++echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6; }
+ else
+-  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
+-echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for non-GNU ld" >&5
++echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6; }
+ fi
+ if test "${lt_cv_path_LD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -3214,17 +3712,17 @@ fi
+ LD="$lt_cv_path_LD"
+ if test -n "$LD"; then
+-  echo "$as_me:$LINENO: result: $LD" >&5
+-echo "${ECHO_T}$LD" >&6
++  { echo "$as_me:$LINENO: result: $LD" >&5
++echo "${ECHO_T}$LD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
+ echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
+-echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
++echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6; }
+ if test "${lt_cv_prog_gnu_ld+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3235,25 +3733,25 @@ else
+   lt_cv_prog_gnu_ld=no
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
+-echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
++echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6; }
+ with_gnu_ld=$lt_cv_prog_gnu_ld
+-echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
+-echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
++echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6; }
+ if test "${lt_cv_ld_reload_flag+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   lt_cv_ld_reload_flag='-r'
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
+-echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
++echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6; }
+ reload_flag=$lt_cv_ld_reload_flag
+ test -n "$reload_flag" && reload_flag=" $reload_flag"
+-echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
+-echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
++echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6; }
+ if test "${lt_cv_path_NM+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3288,22 +3786,22 @@ fi
+ fi
+ NM="$lt_cv_path_NM"
+-echo "$as_me:$LINENO: result: $NM" >&5
+-echo "${ECHO_T}$NM" >&6
++{ echo "$as_me:$LINENO: result: $NM" >&5
++echo "${ECHO_T}$NM" >&6; }
+-echo "$as_me:$LINENO: checking whether ln -s works" >&5
+-echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether ln -s works" >&5
++echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6; }
+ LN_S=$as_ln_s
+ if test "$LN_S" = "ln -s"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
+-echo "${ECHO_T}no, using $LN_S" >&6
++  { echo "$as_me:$LINENO: result: no, using $LN_S" >&5
++echo "${ECHO_T}no, using $LN_S" >&6; }
+ fi
+-echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
+-echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
++echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6; }
+ if test "${lt_cv_deplibs_check_method+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3465,8 +3963,8 @@ sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+ esac
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
+-echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
++echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6; }
+ file_magic_cmd=$lt_cv_file_magic_cmd
+ deplibs_check_method=$lt_cv_deplibs_check_method
+@@ -3476,8 +3974,8 @@ deplibs_check_method=$lt_cv_deplibs_chec
+ # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
+ # find the maximum length of command line arguments
+-echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
+-echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
++echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6; }
+ if test "${lt_cv_sys_max_cmd_len+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3528,11 +4026,11 @@ else
+ fi
+ if test -n "$lt_cv_sys_max_cmd_len" ; then
+-  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
+-echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
++  { echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
++echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: none" >&5
+-echo "${ECHO_T}none" >&6
++  { echo "$as_me:$LINENO: result: none" >&5
++echo "${ECHO_T}none" >&6; }
+ fi
+@@ -3540,8 +4038,8 @@ fi
+ case $deplibs_check_method in
+ file_magic*)
+   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+-    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
+-echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
++echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3595,17 +4093,17 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ if test -z "$lt_cv_path_MAGIC_CMD"; then
+   if test -n "$ac_tool_prefix"; then
+-    echo "$as_me:$LINENO: checking for file" >&5
+-echo $ECHO_N "checking for file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for file" >&5
++echo $ECHO_N "checking for file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3659,11 +4157,11 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+   else
+@@ -3678,8 +4176,8 @@ esac
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3692,32 +4190,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3730,27 +4230,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -3758,8 +4272,8 @@ fi
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3772,32 +4286,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3810,27 +4326,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -3845,22 +4375,22 @@ test "$GCC" = yes && libtool_flags="$lib
+ test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
+-# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
++# Check whether --enable-libtool-lock was given.
+ if test "${enable_libtool_lock+set}" = set; then
+-  enableval="$enable_libtool_lock"
++  enableval=$enable_libtool_lock;
++fi
+-fi;
+ test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
+ test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
+-# Check whether --with-pic or --without-pic was given.
++# Check whether --with-pic was given.
+ if test "${with_pic+set}" = set; then
+-  withval="$with_pic"
+-  pic_mode="$withval"
++  withval=$with_pic; pic_mode="$withval"
+ else
+   pic_mode=default
+-fi;
++fi
++
+ test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
+ test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
+@@ -3869,7 +4399,7 @@ test x"$pic_mode" = xno && libtool_flags
+ case $host in
+ *-*-irix6*)
+   # Find out which ABI we are using.
+-  echo '#line 3872 "configure"' > conftest.$ac_ext
++  echo '#line 4402 "configure"' > conftest.$ac_ext
+   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+   (eval $ac_compile) 2>&5
+   ac_status=$?
+@@ -3974,13 +4504,12 @@ x86_64-*linux*|ppc*-*linux*|powerpc*-*li
+   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+   SAVE_CFLAGS="$CFLAGS"
+   CFLAGS="$CFLAGS -belf"
+-  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
+-echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
++echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6; }
+ if test "${lt_cv_cc_needs_belf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -4003,35 +4532,32 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   lt_cv_cc_needs_belf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-lt_cv_cc_needs_belf=no
++      lt_cv_cc_needs_belf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+@@ -4040,8 +4566,8 @@ ac_link='$CC -o conftest$ac_exeext $CFLA
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
+-echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
++echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6; }
+   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+     CFLAGS="$SAVE_CFLAGS"
+@@ -4071,39 +4597,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -4129,8 +4674,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -4157,15 +4702,14 @@ exec 5>>./config.log
+-# Check whether --with-lib-path or --without-lib-path was given.
++# Check whether --with-lib-path was given.
+ if test "${with_lib_path+set}" = set; then
+-  withval="$with_lib_path"
+-  LIB_PATH=$withval
+-fi;
+-# Check whether --enable-targets or --disable-targets was given.
++  withval=$with_lib_path; LIB_PATH=$withval
++fi
++
++# Check whether --enable-targets was given.
+ if test "${enable_targets+set}" = set; then
+-  enableval="$enable_targets"
+-  case "${enableval}" in
++  enableval=$enable_targets; case "${enableval}" in
+   yes | "") { { echo "$as_me:$LINENO: error: enable-targets option must specify target names or 'all'" >&5
+ echo "$as_me: error: enable-targets option must specify target names or 'all'" >&2;}
+    { (exit 1); exit 1; }; }
+@@ -4173,10 +4717,10 @@ echo "$as_me: error: enable-targets opti
+   no)       enable_targets= ;;
+   *)        enable_targets=$enableval ;;
+ esac
+-fi; # Check whether --enable-64-bit-bfd or --disable-64-bit-bfd was given.
++fi
++# Check whether --enable-64-bit-bfd was given.
+ if test "${enable_64_bit_bfd+set}" = set; then
+-  enableval="$enable_64_bit_bfd"
+-  case "${enableval}" in
++  enableval=$enable_64_bit_bfd; case "${enableval}" in
+   yes)  want64=true  ;;
+   no)   want64=false ;;
+   *)    { { echo "$as_me:$LINENO: error: bad value ${enableval} for 64-bit-bfd option" >&5
+@@ -4185,12 +4729,12 @@ echo "$as_me: error: bad value ${enablev
+ esac
+ else
+   want64=false
+-fi;
++fi
+-# Check whether --with-sysroot or --without-sysroot was given.
+-if test "${with_sysroot+set}" = set; then
+-  withval="$with_sysroot"
++# Check whether --with-sysroot was given.
++if test "${with_sysroot+set}" = set; then
++  withval=$with_sysroot;
+  case ${with_sysroot} in
+  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_alias}/sys-root' ;;
+  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
+@@ -4222,7 +4766,8 @@ else
+  TARGET_SYSTEM_ROOT=
+  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"\"'
+-fi;
++fi
++
+@@ -4230,17 +4775,17 @@ fi;
+ GCC_WARN_CFLAGS="-W -Wall -Wstrict-prototypes -Wmissing-prototypes"
+-# Check whether --enable-werror or --disable-werror was given.
++# Check whether --enable-werror was given.
+ if test "${enable_werror+set}" = set; then
+-  enableval="$enable_werror"
+-  case "${enableval}" in
++  enableval=$enable_werror; case "${enableval}" in
+      yes | y) ERROR_ON_WARNING="yes" ;;
+      no | n)  ERROR_ON_WARNING="no" ;;
+      *) { { echo "$as_me:$LINENO: error: bad value ${enableval} for --enable-werror" >&5
+ echo "$as_me: error: bad value ${enableval} for --enable-werror" >&2;}
+    { (exit 1); exit 1; }; } ;;
+    esac
+-fi;
++fi
++
+ # Enable -Werror by default when using gcc
+ if test "${GCC}" = yes -a -z "${ERROR_ON_WARNING}" ; then
+@@ -4257,10 +4802,9 @@ if test "${GCC}" = yes ; then
+   WARN_CFLAGS="${GCC_WARN_CFLAGS}"
+ fi
+-# Check whether --enable-build-warnings or --disable-build-warnings was given.
++# Check whether --enable-build-warnings was given.
+ if test "${enable_build_warnings+set}" = set; then
+-  enableval="$enable_build_warnings"
+-  case "${enableval}" in
++  enableval=$enable_build_warnings; case "${enableval}" in
+   yes)        WARN_CFLAGS="${GCC_WARN_CFLAGS}";;
+   no) if test "${GCC}" = yes ; then
+         WARN_CFLAGS="-w"
+@@ -4271,7 +4815,8 @@ if test "${enable_build_warnings+set}" =
+         WARN_CFLAGS="${t} ${GCC_WARN_CFLAGS}";;
+   *)    WARN_CFLAGS=`echo "${enableval}" | sed -e "s/,/ /g"`;;
+ esac
+-fi;
++fi
++
+ if test x"$silent" != x"yes" && test x"$WARN_CFLAGS" != x""; then
+   echo "Setting warning flags = $WARN_CFLAGS" 6>&1
+@@ -4281,7 +4826,7 @@ fi
+-          ac_config_headers="$ac_config_headers config.h:config.in"
++ac_config_headers="$ac_config_headers config.h:config.in"
+ if test -z "$target" ; then
+@@ -4305,8 +4850,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4319,32 +4864,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_CC"; then
+   ac_ct_CC=$CC
+   # Extract the first word of "gcc", so it can be a program name with args.
+ set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4357,36 +4904,51 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ else
+   CC="$ac_cv_prog_CC"
+ fi
+ if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4399,74 +4961,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}cc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
+-
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++  fi
+ fi
+ if test -z "$CC"; then
+   # Extract the first word of "cc", so it can be a program name with args.
+ set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4480,7 +5002,7 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+        continue
+@@ -4491,6 +5013,7 @@ do
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ if test $ac_prog_rejected = yes; then
+   # We found a bogon in the path, so make sure we never use it.
+@@ -4508,22 +5031,23 @@ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$CC"; then
+   if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4536,36 +5060,38 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+     test -n "$CC" && break
+   done
+ fi
+ if test -z "$CC"; then
+   ac_ct_CC=$CC
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4578,29 +5104,45 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$ac_ct_CC" && break
+ done
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ fi
+ fi
+@@ -4613,27 +5155,41 @@ See \`config.log' for more details." >&2
+    { (exit 1); exit 1; }; }
+ # Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
++echo "$as_me:$LINENO: checking for C compiler version" >&5
+ ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+ if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4656,50 +5212,49 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+ GCC=`test $ac_compiler_gnu = yes && echo yes`
+ ac_test_CFLAGS=${CFLAGS+set}
+ ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -4715,59 +5270,139 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
+-if test "$ac_test_CFLAGS" = set; then
+-  CFLAGS=$ac_save_CFLAGS
+-elif test $ac_cv_prog_cc_g = yes; then
+-  if test "$GCC" = yes; then
+-    CFLAGS="-g -O2"
+-  else
+-    CFLAGS="-g"
+-  fi
+-else
+-  if test "$GCC" = yes; then
+-    CFLAGS="-O2"
+-  else
+-    CFLAGS=
+-  fi
+-fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_cv_prog_cc_stdc=no
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
++if test "$ac_test_CFLAGS" = set; then
++  CFLAGS=$ac_save_CFLAGS
++elif test $ac_cv_prog_cc_g = yes; then
++  if test "$GCC" = yes; then
++    CFLAGS="-g -O2"
++  else
++    CFLAGS="-g"
++  fi
++else
++  if test "$GCC" = yes; then
++    CFLAGS="-O2"
++  else
++    CFLAGS=
++  fi
++fi
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_cv_prog_cc_c89=no
+ ac_save_CC=$CC
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -4801,12 +5436,17 @@ static char *f (char * (*g) (char **, in
+ /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+    function prototypes and stuff, but not '\xHH' hex character constants.
+    These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
++   as 'x'.  The following induces an error, until -std is added to get
+    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+    array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
++   that's true only with -std.  */
+ int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
+ int test (int i, double x);
+ struct s1 {int (*f) (int a);};
+ struct s2 {int (*f) (double a);};
+@@ -4821,205 +5461,57 @@ return f (e, argv, 0) != argv[0]  ||  f 
+   return 0;
+ }
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+ do
+   CC="$ac_save_CC $ac_arg"
+   rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext
++
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+-rm -f conftest.$ac_ext conftest.$ac_objext
++rm -f conftest.$ac_ext
+ CC=$ac_save_CC
+ fi
+-
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
+   *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
+ esac
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
+-cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
+-fi
+-
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -5039,8 +5531,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+ # OS/2's system install, which has a completely different semantic
+ # ./install, which can be erroneously created by make from ./install.sh.
+-echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+-echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+ if test -z "$INSTALL"; then
+ if test "${ac_cv_path_install+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -5062,7 +5554,7 @@ case $as_dir/ in
+     # by default.
+     for ac_prog in ginstall scoinst install; do
+       for ac_exec_ext in '' $ac_executable_extensions; do
+-      if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
++      if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+         if test $ac_prog = install &&
+           grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+           # AIX install.  It has an incompatible calling convention.
+@@ -5081,21 +5573,22 @@ case $as_dir/ in
+     ;;
+ esac
+ done
++IFS=$as_save_IFS
+ fi
+   if test "${ac_cv_path_install+set}" = set; then
+     INSTALL=$ac_cv_path_install
+   else
+-    # As a last resort, use the slow shell script.  We don't cache a
+-    # path for INSTALL within a source directory, because that will
++    # As a last resort, use the slow shell script.  Don't cache a
++    # value for INSTALL within a source directory, because that will
+     # break other packages using the cache if that directory is
+-    # removed, or if the path is relative.
++    # removed, or if the value is a relative name.
+     INSTALL=$ac_install_sh
+   fi
+ fi
+-echo "$as_me:$LINENO: result: $INSTALL" >&5
+-echo "${ECHO_T}$INSTALL" >&6
++{ echo "$as_me:$LINENO: result: $INSTALL" >&5
++echo "${ECHO_T}$INSTALL" >&6; }
+ # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+ # It thinks the first close brace ends the variable substitution.
+@@ -5110,8 +5603,8 @@ ALL_LINGUAS="fr sv tr es da vi zh_CN"
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5124,32 +5617,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5162,27 +5657,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -5192,8 +5701,8 @@ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
+-echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
++echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }
+ # On Suns, sometimes $CPP names a directory.
+ if test -n "$CPP" && test -d "$CPP"; then
+   CPP=
+@@ -5227,24 +5736,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #endif
+                    Syntax error
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   :
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -5253,9 +5760,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   # Broken: fails on valid input.
+ continue
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
++  # OK, works on sane cases.  Now check whether nonexistent headers
+   # can be detected and how.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -5265,24 +5773,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   # Broken: success on invalid input.
+ continue
+ else
+@@ -5293,6 +5799,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ac_preproc_ok=:
+ break
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+ done
+@@ -5310,8 +5817,8 @@ fi
+ else
+   ac_cv_prog_CPP=$CPP
+ fi
+-echo "$as_me:$LINENO: result: $CPP" >&5
+-echo "${ECHO_T}$CPP" >&6
++{ echo "$as_me:$LINENO: result: $CPP" >&5
++echo "${ECHO_T}$CPP" >&6; }
+ ac_preproc_ok=false
+ for ac_c_preproc_warn_flag in '' yes
+ do
+@@ -5334,24 +5841,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #endif
+                    Syntax error
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   :
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -5360,9 +5865,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   # Broken: fails on valid input.
+ continue
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
++  # OK, works on sane cases.  Now check whether nonexistent headers
+   # can be detected and how.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -5372,24 +5878,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   # Broken: success on invalid input.
+ continue
+ else
+@@ -5400,6 +5904,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ac_preproc_ok=:
+ break
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+ done
+@@ -5422,79 +5927,222 @@ ac_link='$CC -o conftest$ac_exeext $CFLA
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-echo "$as_me:$LINENO: checking for egrep" >&5
+-echo $ECHO_N "checking for egrep... $ECHO_C" >&6
+-if test "${ac_cv_prog_egrep+set}" = set; then
++{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
++echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }
++if test "${ac_cv_path_GREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  # Extract the first word of "grep ggrep" to use in msg output
++if test -z "$GREP"; then
++set dummy grep ggrep; ac_prog_name=$2
++if test "${ac_cv_path_GREP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
+-    then ac_cv_prog_egrep='grep -E'
+-    else ac_cv_prog_egrep='egrep'
++  ac_path_GREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in grep ggrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
++    # Check for GNU ac_path_GREP and select it if it is found.
++  # Check for GNU $ac_path_GREP
++case `"$ac_path_GREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'GREP' >> "conftest.nl"
++    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_GREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_GREP="$ac_path_GREP"
++      ac_path_GREP_max=$ac_count
+     fi
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
+-echo "${ECHO_T}$ac_cv_prog_egrep" >&6
+- EGREP=$ac_cv_prog_egrep
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
+-echo "$as_me:$LINENO: checking for ANSI C header files" >&5
+-echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
+-if test "${ac_cv_header_stdc+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <stdlib.h>
+-#include <stdarg.h>
+-#include <string.h>
+-#include <float.h>
++    $ac_path_GREP_found && break 3
++  done
++done
+-int
+-main ()
+-{
++done
++IFS=$as_save_IFS
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_header_stdc=yes
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_header_stdc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-if test $ac_cv_header_stdc = yes; then
+-  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+-  cat >conftest.$ac_ext <<_ACEOF
++GREP="$ac_cv_path_GREP"
++if test -z "$GREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
++
++else
++  ac_cv_path_GREP=$GREP
++fi
++
++
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
++echo "${ECHO_T}$ac_cv_path_GREP" >&6; }
++ GREP="$ac_cv_path_GREP"
++
++
++{ echo "$as_me:$LINENO: checking for egrep" >&5
++echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }
++if test "${ac_cv_path_EGREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
++   then ac_cv_path_EGREP="$GREP -E"
++   else
++     # Extract the first word of "egrep" to use in msg output
++if test -z "$EGREP"; then
++set dummy egrep; ac_prog_name=$2
++if test "${ac_cv_path_EGREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_path_EGREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in egrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
++    # Check for GNU ac_path_EGREP and select it if it is found.
++  # Check for GNU $ac_path_EGREP
++case `"$ac_path_EGREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'EGREP' >> "conftest.nl"
++    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_EGREP="$ac_path_EGREP"
++      ac_path_EGREP_max=$ac_count
++    fi
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
++
++
++    $ac_path_EGREP_found && break 3
++  done
++done
++
++done
++IFS=$as_save_IFS
++
++
++fi
++
++EGREP="$ac_cv_path_EGREP"
++if test -z "$EGREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
++
++else
++  ac_cv_path_EGREP=$EGREP
++fi
++
++
++   fi
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
++echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }
++ EGREP="$ac_cv_path_EGREP"
++
++
++{ echo "$as_me:$LINENO: checking for ANSI C header files" >&5
++echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
++if test "${ac_cv_header_stdc+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <stdlib.h>
++#include <stdarg.h>
++#include <string.h>
++#include <float.h>
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_header_stdc=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_cv_header_stdc=no
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++
++if test $ac_cv_header_stdc = yes; then
++  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
++  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -5546,6 +6194,7 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ctype.h>
++#include <stdlib.h>
+ #if ((' ' & 0x0FF) == 0x020)
+ # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+ # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+@@ -5565,18 +6214,27 @@ main ()
+   for (i = 0; i < 256; i++)
+     if (XOR (islower (i), ISLOWER (i))
+       || toupper (i) != TOUPPER (i))
+-      exit(2);
+-  exit (0);
++      return 2;
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -5589,12 +6247,14 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_header_stdc=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
+-echo "${ECHO_T}$ac_cv_header_stdc" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
++echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
+ if test $ac_cv_header_stdc = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -5603,8 +6263,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
+-echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
++echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; }
+ if test "${ac_cv_c_const+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5622,10 +6282,10 @@ main ()
+ #ifndef __cplusplus
+   /* Ultrix mips cc rejects this.  */
+   typedef int charset[2];
+-  const charset x;
++  const charset cs;
+   /* SunOS 4.1.1 cc rejects this.  */
+-  char const *const *ccp;
+-  char **p;
++  char const *const *pcpcc;
++  char **ppc;
+   /* NEC SVR4.0.2 mips cc rejects this.  */
+   struct point {int x, y;};
+   static struct point const zero = {0,0};
+@@ -5634,16 +6294,17 @@ main ()
+      an arm of an if-expression whose if-part is not a constant
+      expression */
+   const char *g = "string";
+-  ccp = &g + (g ? g-g : 0);
++  pcpcc = &g + (g ? g-g : 0);
+   /* HPUX 7.0 cc rejects these. */
+-  ++ccp;
+-  p = (char**) ccp;
+-  ccp = (char const *const *) p;
++  ++pcpcc;
++  ppc = (char**) pcpcc;
++  pcpcc = (char const *const *) ppc;
+   { /* SCO 3.2v4 cc rejects this.  */
+     char *t;
+     char const *s = 0 ? (char *) 0 : (char const *) 0;
+     *t++ = 0;
++    if (s) return 0;
+   }
+   { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+     int x[] = {25, 17};
+@@ -5662,7 +6323,9 @@ main ()
+   }
+   { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+     const int foo = 10;
++    if (!foo) return 0;
+   }
++  return !cs[0] && !zero.x;
+ #endif
+   ;
+@@ -5670,38 +6333,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_c_const=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_c_const=no
++      ac_cv_c_const=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
+-echo "${ECHO_T}$ac_cv_c_const" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
++echo "${ECHO_T}$ac_cv_c_const" >&6; }
+ if test $ac_cv_c_const = no; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -5710,8 +6369,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for inline" >&5
+-echo $ECHO_N "checking for inline... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for inline" >&5
++echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
+ if test "${ac_cv_c_inline+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5731,39 +6390,37 @@ $ac_kw foo_t foo () {return 0; }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_c_inline=$ac_kw; break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_c_inline=$ac_kw
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++  test "$ac_cv_c_inline" != no && break
+ done
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
+-echo "${ECHO_T}$ac_cv_c_inline" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
++echo "${ECHO_T}$ac_cv_c_inline" >&6; }
+ case $ac_cv_c_inline in
+@@ -5795,9 +6452,9 @@ for ac_header in sys/types.h sys/stat.h 
+                 inttypes.h stdint.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -5811,38 +6468,35 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   eval "$as_ac_Header=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_Header=no"
++      eval "$as_ac_Header=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+@@ -5853,8 +6507,8 @@ fi
+ done
+-echo "$as_me:$LINENO: checking for off_t" >&5
+-echo $ECHO_N "checking for off_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for off_t" >&5
++echo $ECHO_N "checking for off_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_off_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5865,62 +6519,59 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef off_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((off_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (off_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_off_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_off_t=no
++      ac_cv_type_off_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
+-echo "${ECHO_T}$ac_cv_type_off_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
++echo "${ECHO_T}$ac_cv_type_off_t" >&6; }
+ if test $ac_cv_type_off_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define off_t long
++#define off_t long int
+ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for size_t" >&5
+-echo $ECHO_N "checking for size_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for size_t" >&5
++echo $ECHO_N "checking for size_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_size_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5931,64 +6582,61 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef size_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((size_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (size_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_size_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_size_t=no
++      ac_cv_type_size_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
+-echo "${ECHO_T}$ac_cv_type_size_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
++echo "${ECHO_T}$ac_cv_type_size_t" >&6; }
+ if test $ac_cv_type_size_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define size_t unsigned
++#define size_t unsigned int
+ _ACEOF
+ fi
+ # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+ # for constant arguments.  Useless!
+-echo "$as_me:$LINENO: checking for working alloca.h" >&5
+-echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working alloca.h" >&5
++echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6; }
+ if test "${ac_cv_working_alloca_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6003,44 +6651,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (2 * sizeof (int));
++                        if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_working_alloca_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_working_alloca_h=no
++      ac_cv_working_alloca_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
+-echo "${ECHO_T}$ac_cv_working_alloca_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
++echo "${ECHO_T}$ac_cv_working_alloca_h" >&6; }
+ if test $ac_cv_working_alloca_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -6049,8 +6695,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for alloca" >&5
+-echo $ECHO_N "checking for alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for alloca" >&5
++echo $ECHO_N "checking for alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_func_alloca_works+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6067,7 +6713,7 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #  include <malloc.h>
+ #  define alloca _alloca
+ # else
+-#  if HAVE_ALLOCA_H
++#  ifdef HAVE_ALLOCA_H
+ #   include <alloca.h>
+ #  else
+ #   ifdef _AIX
+@@ -6085,44 +6731,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (1);
++                                  if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_func_alloca_works=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_func_alloca_works=no
++      ac_cv_func_alloca_works=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
+-echo "${ECHO_T}$ac_cv_func_alloca_works" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
++echo "${ECHO_T}$ac_cv_func_alloca_works" >&6; }
+ if test $ac_cv_func_alloca_works = yes; then
+@@ -6136,15 +6780,15 @@ else
+ # contain a buggy version.  If you still want to use their alloca,
+ # use ar to extract alloca.o from them instead of compiling alloca.c.
+-ALLOCA=alloca.$ac_objext
++ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
+ cat >>confdefs.h <<\_ACEOF
+ #define C_ALLOCA 1
+ _ACEOF
+-echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
+-echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
++echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6; }
+ if test "${ac_cv_os_cray+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6154,7 +6798,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#if defined(CRAY) && ! defined(CRAY2)
++#if defined CRAY && ! defined CRAY2
+ webecray
+ #else
+ wenotbecray
+@@ -6170,14 +6814,14 @@ fi
+ rm -f conftest*
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
+-echo "${ECHO_T}$ac_cv_os_cray" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
++echo "${ECHO_T}$ac_cv_os_cray" >&6; }
+ if test $ac_cv_os_cray = yes; then
+   for ac_func in _getb67 GETB67 getb67; do
+     as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6203,68 +6847,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -6277,8 +6913,8 @@ fi
+   done
+ fi
+-echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
+-echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
++echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_c_stack_direction+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6291,6 +6927,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
++$ac_includes_default
+ int
+ find_stack_direction ()
+ {
+@@ -6308,17 +6945,26 @@ find_stack_direction ()
+ int
+ main ()
+ {
+-  exit (find_stack_direction () < 0);
++  return find_stack_direction () < 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -6331,11 +6977,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_c_stack_direction=-1
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
+-echo "${ECHO_T}$ac_cv_c_stack_direction" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
++echo "${ECHO_T}$ac_cv_c_stack_direction" >&6; }
+ cat >>confdefs.h <<_ACEOF
+ #define STACK_DIRECTION $ac_cv_c_stack_direction
+@@ -6349,18 +6997,19 @@ fi
+ for ac_header in stdlib.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6371,41 +7020,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6414,24 +7059,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -6439,9 +7082,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -6465,25 +7109,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -6499,9 +7137,9 @@ done
+ for ac_func in getpagesize
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6527,68 +7165,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -6597,8 +7227,8 @@ _ACEOF
+ fi
+ done
+-echo "$as_me:$LINENO: checking for working mmap" >&5
+-echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working mmap" >&5
++echo $ECHO_N "checking for working mmap... $ECHO_C" >&6; }
+ if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6640,21 +7270,21 @@ $ac_includes_default
+ #include <fcntl.h>
+ #include <sys/mman.h>
+-#if !STDC_HEADERS && !HAVE_STDLIB_H
++#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H
+ char *malloc ();
+ #endif
+ /* This mess was copied from the GNU getpagesize.h.  */
+-#if !HAVE_GETPAGESIZE
++#ifndef HAVE_GETPAGESIZE
+ /* Assume that all systems that can run configure have sys/param.h.  */
+-# if !HAVE_SYS_PARAM_H
++# ifndef HAVE_SYS_PARAM_H
+ #  define HAVE_SYS_PARAM_H 1
+ # endif
+ # ifdef _SC_PAGESIZE
+ #  define getpagesize() sysconf(_SC_PAGESIZE)
+ # else /* no _SC_PAGESIZE */
+-#  if HAVE_SYS_PARAM_H
++#  ifdef HAVE_SYS_PARAM_H
+ #   include <sys/param.h>
+ #   ifdef EXEC_PAGESIZE
+ #    define getpagesize() EXEC_PAGESIZE
+@@ -6693,15 +7323,15 @@ main ()
+   /* First, make a file with some known garbage in it. */
+   data = (char *) malloc (pagesize);
+   if (!data)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     *(data + i) = rand ();
+   umask (0);
+   fd = creat ("conftest.mmap", 0600);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   if (write (fd, data, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   close (fd);
+   /* Next, try to mmap the file at a fixed address which already has
+@@ -6709,17 +7339,17 @@ main ()
+      we see the same garbage.  */
+   fd = open ("conftest.mmap", O_RDWR);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   data2 = (char *) malloc (2 * pagesize);
+   if (!data2)
+-    exit (1);
+-  data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
++    return 1;
++  data2 += (pagesize - ((long int) data2 & (pagesize - 1))) & (pagesize - 1);
+   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_FIXED, fd, 0L))
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data2 + i))
+-      exit (1);
++      return 1;
+   /* Finally, make sure that changes to the mapped area do not
+      percolate back to the file as seen by read().  (This is a bug on
+@@ -6728,24 +7358,33 @@ main ()
+     *(data2 + i) = *(data2 + i) + 1;
+   data3 = (char *) malloc (pagesize);
+   if (!data3)
+-    exit (1);
++    return 1;
+   if (read (fd, data3, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data3 + i))
+-      exit (1);
++      return 1;
+   close (fd);
+-  exit (0);
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -6758,11 +7397,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_func_mmap_fixed_mapped=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
+-echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
++echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6; }
+ if test $ac_cv_func_mmap_fixed_mapped = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -6786,18 +7427,19 @@ for ac_header in argz.h limits.h locale.
+ unistd.h values.h sys/param.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6808,41 +7450,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6851,24 +7489,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -6876,9 +7512,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -6902,25 +7539,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -6946,9 +7577,9 @@ for ac_func in getcwd munmap putenv sete
+ __argz_count __argz_stringify __argz_next
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6974,68 +7605,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7050,9 +7673,9 @@ done
+ for ac_func in stpcpy
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7078,68 +7701,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7158,8 +7773,8 @@ _ACEOF
+    fi
+    if test $ac_cv_header_locale_h = yes; then
+-    echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
+-echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
++echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6; }
+ if test "${am_cv_val_LC_MESSAGES+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7179,39 +7794,36 @@ return LC_MESSAGES
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   am_cv_val_LC_MESSAGES=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-am_cv_val_LC_MESSAGES=no
++      am_cv_val_LC_MESSAGES=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
+-echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
++echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6; }
+     if test $am_cv_val_LC_MESSAGES = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -7220,34 +7832,34 @@ _ACEOF
+     fi
+   fi
+-   echo "$as_me:$LINENO: checking whether NLS is requested" >&5
+-echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6
+-        # Check whether --enable-nls or --disable-nls was given.
++   { echo "$as_me:$LINENO: checking whether NLS is requested" >&5
++echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6; }
++        # Check whether --enable-nls was given.
+ if test "${enable_nls+set}" = set; then
+-  enableval="$enable_nls"
+-  USE_NLS=$enableval
++  enableval=$enable_nls; USE_NLS=$enableval
+ else
+   USE_NLS=yes
+-fi;
+-    echo "$as_me:$LINENO: result: $USE_NLS" >&5
+-echo "${ECHO_T}$USE_NLS" >&6
++fi
++
++    { echo "$as_me:$LINENO: result: $USE_NLS" >&5
++echo "${ECHO_T}$USE_NLS" >&6; }
+     USE_INCLUDED_LIBINTL=no
+         if test "$USE_NLS" = "yes"; then
+-      echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
+-echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6
++      { echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
++echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6; }
+-# Check whether --with-included-gettext or --without-included-gettext was given.
++# Check whether --with-included-gettext was given.
+ if test "${with_included_gettext+set}" = set; then
+-  withval="$with_included_gettext"
+-  nls_cv_force_use_gnu_gettext=$withval
++  withval=$with_included_gettext; nls_cv_force_use_gnu_gettext=$withval
+ else
+   nls_cv_force_use_gnu_gettext=no
+-fi;
+-      echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
+-echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6
++fi
++
++      { echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
++echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6; }
+       nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext"
+       if test "$nls_cv_force_use_gnu_gettext" != "yes"; then
+@@ -7256,17 +7868,17 @@ echo "${ECHO_T}$nls_cv_force_use_gnu_get
+       CATOBJEXT=
+       if test "${ac_cv_header_libintl_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking libintl.h usability" >&5
+-echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h usability" >&5
++echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7277,41 +7889,37 @@ $ac_includes_default
+ #include <libintl.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking libintl.h presence" >&5
+-echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h presence" >&5
++echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7320,24 +7928,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <libintl.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -7345,9 +7951,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -7371,30 +7978,23 @@ echo "$as_me: WARNING: libintl.h:     se
+ echo "$as_me: WARNING: libintl.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: libintl.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: libintl.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_libintl_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ fi
+ if test $ac_cv_header_libintl_h = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libc" >&5
+-echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libc" >&5
++echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libc+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7414,43 +8014,40 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libc=no
++      gt_cv_func_gettext_libc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6; }
+          if test "$gt_cv_func_gettext_libc" != "yes"; then
+-           echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
+-echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6
++           { echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
++echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6; }
+ if test "${ac_cv_lib_intl_bindtextdomain+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7463,59 +8060,56 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char bindtextdomain ();
+ int
+ main ()
+ {
+-bindtextdomain ();
++return bindtextdomain ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_lib_intl_bindtextdomain=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_intl_bindtextdomain=no
++      ac_cv_lib_intl_bindtextdomain=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
+-echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
++echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6; }
+ if test $ac_cv_lib_intl_bindtextdomain = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libintl" >&5
+-echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libintl" >&5
++echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libintl+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7535,39 +8129,36 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libintl=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libintl=no
++      gt_cv_func_gettext_libintl=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6; }
+ fi
+          fi
+@@ -7581,8 +8172,8 @@ _ACEOF
+             # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7608,20 +8199,20 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+             if test "$MSGFMT" != "no"; then
+ for ac_func in dcgettext
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7647,68 +8238,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7719,8 +8302,8 @@ done
+               # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7735,32 +8318,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+               # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7786,11 +8370,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+               cat >conftest.$ac_ext <<_ACEOF
+@@ -7810,37 +8394,34 @@ extern int _nl_msg_cat_cntr;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   CATOBJEXT=.gmo
+                  DATADIRNAME=share
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-CATOBJEXT=.mo
++      CATOBJEXT=.mo
+                  DATADIRNAME=lib
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+               INSTOBJEXT=.mo
+             fi
+@@ -7862,8 +8443,8 @@ fi
+                 INTLOBJS="\$(GETTOBJS)"
+         # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7889,17 +8470,17 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+         # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7914,32 +8495,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+         # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7965,11 +8547,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+@@ -7988,8 +8570,8 @@ fi
+                       if $XGETTEXT --omit-header /dev/null 2> /dev/null; then
+         : ;
+       else
+-        echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
+-echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6
++        { echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
++echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6; }
+         XGETTEXT=":"
+       fi
+       fi
+@@ -8038,8 +8620,8 @@ _ACEOF
+      if test "x$ALL_LINGUAS" = "x"; then
+        LINGUAS=
+      else
+-       echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
+-echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6
++       { echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
++echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6; }
+        NEW_LINGUAS=
+        for lang in ${LINGUAS=$ALL_LINGUAS}; do
+          case "$ALL_LINGUAS" in
+@@ -8047,8 +8629,8 @@ echo $ECHO_N "checking for catalogs to b
+          esac
+        done
+        LINGUAS=$NEW_LINGUAS
+-       echo "$as_me:$LINENO: result: $LINGUAS" >&5
+-echo "${ECHO_T}$LINGUAS" >&6
++       { echo "$as_me:$LINENO: result: $LINGUAS" >&5
++echo "${ECHO_T}$LINGUAS" >&6; }
+      fi
+           if test -n "$LINGUAS"; then
+@@ -8067,17 +8649,17 @@ echo "${ECHO_T}$LINGUAS" >&6
+             if test -f $srcdir/po2tbl.sed.in; then
+       if test "$CATOBJEXT" = ".cat"; then
+        if test "${ac_cv_header_linux_version_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking linux/version.h usability" >&5
+-echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h usability" >&5
++echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8088,41 +8670,37 @@ $ac_includes_default
+ #include <linux/version.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking linux/version.h presence" >&5
+-echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h presence" >&5
++echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8131,24 +8709,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <linux/version.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -8156,9 +8732,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -8182,25 +8759,18 @@ echo "$as_me: WARNING: linux/version.h: 
+ echo "$as_me: WARNING: linux/version.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: linux/version.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: linux/version.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_linux_version_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ fi
+ if test $ac_cv_header_linux_version_h = yes; then
+@@ -8256,8 +8826,8 @@ for ac_prog in 'bison -y' byacc
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_YACC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8270,25 +8840,27 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_YACC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ YACC=$ac_cv_prog_YACC
+ if test -n "$YACC"; then
+-  echo "$as_me:$LINENO: result: $YACC" >&5
+-echo "${ECHO_T}$YACC" >&6
++  { echo "$as_me:$LINENO: result: $YACC" >&5
++echo "${ECHO_T}$YACC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$YACC" && break
+ done
+ test -n "$YACC" || YACC="yacc"
+@@ -8297,8 +8869,8 @@ for ac_prog in flex lex
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_LEX+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8311,253 +8883,182 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_LEX="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ LEX=$ac_cv_prog_LEX
+ if test -n "$LEX"; then
+-  echo "$as_me:$LINENO: result: $LEX" >&5
+-echo "${ECHO_T}$LEX" >&6
++  { echo "$as_me:$LINENO: result: $LEX" >&5
++echo "${ECHO_T}$LEX" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$LEX" && break
+ done
+ test -n "$LEX" || LEX=":"
+-if test -z "$LEXLIB"
+-then
+-  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
+-echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
+-if test "${ac_cv_lib_fl_yywrap+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
+-LIBS="-lfl  $LIBS"
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
++if test "x$LEX" != "x:"; then
++  cat >conftest.l <<_ACEOF
++%%
++a { ECHO; }
++b { REJECT; }
++c { yymore (); }
++d { yyless (1); }
++e { yyless (input () != 0); }
++f { unput (yytext[0]); }
++. { BEGIN INITIAL; }
++%%
++#ifdef YYTEXT_POINTER
++extern char *yytext;
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char yywrap ();
+ int
+-main ()
++main (void)
+ {
+-yywrap ();
+-  ;
+-  return 0;
++  return ! yylex () + ! yywrap ();
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++{ (ac_try="$LEX conftest.l"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$LEX conftest.l") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_lib_fl_yywrap=yes
++  (exit $ac_status); }
++{ echo "$as_me:$LINENO: checking lex output file root" >&5
++echo $ECHO_N "checking lex output file root... $ECHO_C" >&6; }
++if test "${ac_cv_prog_lex_root+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_fl_yywrap=no
++if test -f lex.yy.c; then
++  ac_cv_prog_lex_root=lex.yy
++elif test -f lexyy.c; then
++  ac_cv_prog_lex_root=lexyy
++else
++  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
++echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
++   { (exit 1); exit 1; }; }
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
+-echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
+-if test $ac_cv_lib_fl_yywrap = yes; then
+-  LEXLIB="-lfl"
+-else
+-  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
+-echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
+-if test "${ac_cv_lib_l_yywrap+set}" = set; then
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
++echo "${ECHO_T}$ac_cv_prog_lex_root" >&6; }
++LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
++
++if test -z "${LEXLIB+set}"; then
++  { echo "$as_me:$LINENO: checking lex library" >&5
++echo $ECHO_N "checking lex library... $ECHO_C" >&6; }
++if test "${ac_cv_lib_lex+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_check_lib_save_LIBS=$LIBS
+-LIBS="-ll  $LIBS"
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char yywrap ();
+-int
+-main ()
+-{
+-yywrap ();
+-  ;
+-  return 0;
+-}
++    ac_save_LIBS=$LIBS
++    ac_cv_lib_lex='none needed'
++    for ac_lib in '' -lfl -ll; do
++      LIBS="$ac_lib $ac_save_LIBS"
++      cat >conftest.$ac_ext <<_ACEOF
++`cat $LEX_OUTPUT_ROOT.c`
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_lib_l_yywrap=yes
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_lib_lex=$ac_lib
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_l_yywrap=no
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
+-echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
+-if test $ac_cv_lib_l_yywrap = yes; then
+-  LEXLIB="-ll"
+-fi
+ fi
+-fi
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext conftest.$ac_ext
++      test "$ac_cv_lib_lex" != 'none needed' && break
++    done
++    LIBS=$ac_save_LIBS
+-if test "x$LEX" != "x:"; then
+-  echo "$as_me:$LINENO: checking lex output file root" >&5
+-echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
+-if test "${ac_cv_prog_lex_root+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  # The minimal lex program is just a single line: %%.  But some broken lexes
+-# (Solaris, I think it was) want two %% lines, so accommodate them.
+-cat >conftest.l <<_ACEOF
+-%%
+-%%
+-_ACEOF
+-{ (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
+-  (eval $LEX conftest.l) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }
+-if test -f lex.yy.c; then
+-  ac_cv_prog_lex_root=lex.yy
+-elif test -f lexyy.c; then
+-  ac_cv_prog_lex_root=lexyy
+-else
+-  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
+-echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
+-   { (exit 1); exit 1; }; }
+ fi
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_lex" >&5
++echo "${ECHO_T}$ac_cv_lib_lex" >&6; }
++  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
+-echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
+-rm -f conftest.l
+-LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
+-echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
+-echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
++
++{ echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
++echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   # POSIX says lex can declare yytext either as a pointer or an array; the
+-# default is implementation-dependent. Figure out which it is, since
++# default is implementation-dependent.  Figure out which it is, since
+ # not all implementations provide the %pointer and %array declarations.
+ ac_cv_prog_lex_yytext_pointer=no
+-echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
+ ac_save_LIBS=$LIBS
+-LIBS="$LIBS $LEXLIB"
++LIBS="$LEXLIB $ac_save_LIBS"
+ cat >conftest.$ac_ext <<_ACEOF
++#define YYTEXT_POINTER 1
+ `cat $LEX_OUTPUT_ROOT.c`
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_prog_lex_yytext_pointer=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_save_LIBS
+-rm -f "${LEX_OUTPUT_ROOT}.c"
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
+-echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
++echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6; }
+ if test $ac_cv_prog_lex_yytext_pointer = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -8565,23 +9066,24 @@ cat >>confdefs.h <<\_ACEOF
+ _ACEOF
+ fi
++rm -f conftest.l $LEX_OUTPUT_ROOT.c
+ fi
+ if test "$LEX" = :; then
+   LEX=${am_missing_run}flex
+ fi
+-echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
+-echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
+-    # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
++{ echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
++echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6; }
++    # Check whether --enable-maintainer-mode was given.
+ if test "${enable_maintainer_mode+set}" = set; then
+-  enableval="$enable_maintainer_mode"
+-  USE_MAINTAINER_MODE=$enableval
++  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
+ else
+   USE_MAINTAINER_MODE=no
+-fi;
+-  echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
+-echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
++fi
++
++  { echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
++echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6; }
+ if test $USE_MAINTAINER_MODE = yes; then
+@@ -8611,18 +9113,19 @@ fi
+ for ac_header in string.h strings.h stdlib.h unistd.h elf-hints.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8633,41 +9136,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8676,24 +9175,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -8701,9 +9198,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -8727,25 +9225,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -8763,9 +9255,9 @@ done
+ for ac_func in sbrk realpath glob
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -8791,68 +9283,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -8869,9 +9353,9 @@ done
+ ac_header_dirent=no
+ for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do
+   as_ac_Header=`echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_hdr that defines DIR" >&5
+-echo $ECHO_N "checking for $ac_hdr that defines DIR... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_hdr that defines DIR" >&5
++echo $ECHO_N "checking for $ac_hdr that defines DIR... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -8893,38 +9377,35 @@ return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   eval "$as_ac_Header=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_Header=no"
++      eval "$as_ac_Header=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_hdr" | $as_tr_cpp` 1
+@@ -8936,13 +9417,12 @@ fi
+ done
+ # Two versions of opendir et al. are in -ldir and -lx on SCO Xenix.
+ if test $ac_header_dirent = dirent.h; then
+-  echo "$as_me:$LINENO: checking for library containing opendir" >&5
+-echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for library containing opendir" >&5
++echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6; }
+ if test "${ac_cv_search_opendir+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_opendir=no
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8950,126 +9430,83 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char opendir ();
+ int
+ main ()
+ {
+-opendir ();
++return opendir ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++for ac_lib in '' dir; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_opendir="none required"
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_opendir=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_opendir" = no; then
+-  for ac_lib in dir; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char opendir ();
+-int
+-main ()
+-{
+-opendir ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_opendir="-l$ac_lib"
+-break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_opendir+set}" = set; then
++  break
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++done
++if test "${ac_cv_search_opendir+set}" = set; then
++  :
++else
++  ac_cv_search_opendir=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5
+-echo "${ECHO_T}$ac_cv_search_opendir" >&6
+-if test "$ac_cv_search_opendir" != no; then
+-  test "$ac_cv_search_opendir" = "none required" || LIBS="$ac_cv_search_opendir $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5
++echo "${ECHO_T}$ac_cv_search_opendir" >&6; }
++ac_res=$ac_cv_search_opendir
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+ else
+-  echo "$as_me:$LINENO: checking for library containing opendir" >&5
+-echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for library containing opendir" >&5
++echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6; }
+ if test "${ac_cv_search_opendir+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_opendir=no
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -9077,123 +9514,81 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char opendir ();
+ int
+ main ()
+ {
+-opendir ();
++return opendir ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++for ac_lib in '' x; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_opendir="none required"
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_opendir=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_opendir" = no; then
+-  for ac_lib in x; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char opendir ();
+-int
+-main ()
+-{
+-opendir ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_opendir="-l$ac_lib"
+-break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++fi
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_opendir+set}" = set; then
++  break
+ fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++done
++if test "${ac_cv_search_opendir+set}" = set; then
++  :
++else
++  ac_cv_search_opendir=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5
+-echo "${ECHO_T}$ac_cv_search_opendir" >&6
+-if test "$ac_cv_search_opendir" != no; then
+-  test "$ac_cv_search_opendir" = "none required" || LIBS="$ac_cv_search_opendir $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5
++echo "${ECHO_T}$ac_cv_search_opendir" >&6; }
++ac_res=$ac_cv_search_opendir
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+ fi
+-echo "$as_me:$LINENO: checking for a known getopt prototype in unistd.h" >&5
+-echo $ECHO_N "checking for a known getopt prototype in unistd.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a known getopt prototype in unistd.h" >&5
++echo $ECHO_N "checking for a known getopt prototype in unistd.h... $ECHO_C" >&6; }
+ if test "${ld_cv_decl_getopt_unistd_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9213,39 +9608,35 @@ extern int getopt (int, char *const*, co
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ld_cv_decl_getopt_unistd_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ld_cv_decl_getopt_unistd_h=no
++      ld_cv_decl_getopt_unistd_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ld_cv_decl_getopt_unistd_h" >&5
+-echo "${ECHO_T}$ld_cv_decl_getopt_unistd_h" >&6
++{ echo "$as_me:$LINENO: result: $ld_cv_decl_getopt_unistd_h" >&5
++echo "${ECHO_T}$ld_cv_decl_getopt_unistd_h" >&6; }
+ if test $ld_cv_decl_getopt_unistd_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -9264,8 +9655,8 @@ _ACEOF
+  ;;
+ esac
+-echo "$as_me:$LINENO: checking whether strstr is declared" >&5
+-echo $ECHO_N "checking whether strstr is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether strstr is declared" >&5
++echo $ECHO_N "checking whether strstr is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_strstr+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9280,7 +9671,7 @@ int
+ main ()
+ {
+ #ifndef strstr
+-  char *p = (char *) strstr;
++  (void) strstr;
+ #endif
+   ;
+@@ -9288,38 +9679,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_strstr=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_strstr=no
++      ac_cv_have_decl_strstr=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_strstr" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_strstr" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_strstr" >&5
++echo "${ECHO_T}$ac_cv_have_decl_strstr" >&6; }
+ if test $ac_cv_have_decl_strstr = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -9334,8 +9721,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether free is declared" >&5
+-echo $ECHO_N "checking whether free is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether free is declared" >&5
++echo $ECHO_N "checking whether free is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_free+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9350,7 +9737,7 @@ int
+ main ()
+ {
+ #ifndef free
+-  char *p = (char *) free;
++  (void) free;
+ #endif
+   ;
+@@ -9358,38 +9745,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_free=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_free=no
++      ac_cv_have_decl_free=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_free" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_free" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_free" >&5
++echo "${ECHO_T}$ac_cv_have_decl_free" >&6; }
+ if test $ac_cv_have_decl_free = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -9404,8 +9787,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether sbrk is declared" >&5
+-echo $ECHO_N "checking whether sbrk is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether sbrk is declared" >&5
++echo $ECHO_N "checking whether sbrk is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_sbrk+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9420,7 +9803,7 @@ int
+ main ()
+ {
+ #ifndef sbrk
+-  char *p = (char *) sbrk;
++  (void) sbrk;
+ #endif
+   ;
+@@ -9428,38 +9811,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_sbrk=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_sbrk=no
++      ac_cv_have_decl_sbrk=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_sbrk" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_sbrk" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_sbrk" >&5
++echo "${ECHO_T}$ac_cv_have_decl_sbrk" >&6; }
+ if test $ac_cv_have_decl_sbrk = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -9474,8 +9853,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether getenv is declared" >&5
+-echo $ECHO_N "checking whether getenv is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether getenv is declared" >&5
++echo $ECHO_N "checking whether getenv is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_getenv+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9490,7 +9869,7 @@ int
+ main ()
+ {
+ #ifndef getenv
+-  char *p = (char *) getenv;
++  (void) getenv;
+ #endif
+   ;
+@@ -9498,38 +9877,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_getenv=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_getenv=no
++      ac_cv_have_decl_getenv=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_getenv" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_getenv" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_getenv" >&5
++echo "${ECHO_T}$ac_cv_have_decl_getenv" >&6; }
+ if test $ac_cv_have_decl_getenv = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -9544,8 +9919,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking whether environ is declared" >&5
+-echo $ECHO_N "checking whether environ is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether environ is declared" >&5
++echo $ECHO_N "checking whether environ is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_environ+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9560,7 +9935,7 @@ int
+ main ()
+ {
+ #ifndef environ
+-  char *p = (char *) environ;
++  (void) environ;
+ #endif
+   ;
+@@ -9568,38 +9943,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_environ=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_environ=no
++      ac_cv_have_decl_environ=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_environ" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_environ" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_environ" >&5
++echo "${ECHO_T}$ac_cv_have_decl_environ" >&6; }
+ if test $ac_cv_have_decl_environ = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -9623,8 +9994,8 @@ fi
+ # broken Microsoft MSVC compiler, which limits the length of string
+ # constants, while still supporting pre-ANSI compilers which do not
+ # support string concatenation.
+-echo "$as_me:$LINENO: checking whether ANSI C string concatenation works" >&5
+-echo $ECHO_N "checking whether ANSI C string concatenation works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether ANSI C string concatenation works" >&5
++echo $ECHO_N "checking whether ANSI C string concatenation works... $ECHO_C" >&6; }
+ if test "${ld_cv_string_concatenation+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -9644,39 +10015,35 @@ char *a = "a" "a";
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ld_cv_string_concatenation=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ld_cv_string_concatenation=no
++      ld_cv_string_concatenation=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ld_cv_string_concatenation" >&5
+-echo "${ECHO_T}$ld_cv_string_concatenation" >&6
++{ echo "$as_me:$LINENO: result: $ld_cv_string_concatenation" >&5
++echo "${ECHO_T}$ld_cv_string_concatenation" >&6; }
+ if test "$ld_cv_string_concatenation" = "yes"; then
+   STRINGIFY=astring.sed
+ else
+@@ -9801,8 +10168,10 @@ fi
+-                    ac_config_files="$ac_config_files Makefile po/Makefile.in:po/Make-in"
+-          ac_config_commands="$ac_config_commands default"
++ac_config_files="$ac_config_files Makefile po/Makefile.in:po/Make-in"
++
++ac_config_commands="$ac_config_commands default"
++
+ cat >confcache <<\_ACEOF
+ # This file is a shell script that caches the results of configure
+ # tests run on this system so they can be shared between configure
+@@ -9821,39 +10190,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -9862,32 +10250,18 @@ test "x$prefix" = xNONE && prefix=$ac_de
+ # Let make expand exec_prefix.
+ test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+-# VPATH may cause trouble with some makes, so we remove $(srcdir),
+-# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+-# trailing colons and then remove the whole line if VPATH becomes empty
+-# (actually we leave an empty line to preserve line numbers).
+-if test "x$srcdir" = x.; then
+-  ac_vpsub='/^[        ]*VPATH[        ]*=/{
+-s/:*\$(srcdir):*/:/;
+-s/:*\${srcdir}:*/:/;
+-s/:*@srcdir@:*/:/;
+-s/^\([^=]*=[   ]*\):*/\1/;
+-s/:*$//;
+-s/^[^=]*=[     ]*$//;
+-}'
+-fi
+-
+ DEFS=-DHAVE_CONFIG_H
+ ac_libobjs=
+ ac_ltlibobjs=
+ for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+   # 1. Remove the extension, and $U if already installed.
+-  ac_i=`echo "$ac_i" |
+-       sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
+-  # 2. Add them.
+-  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
+-  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
++  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
++  ac_i=`echo "$ac_i" | sed "$ac_script"`
++  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
++  #    will be set to the directory where LIBOBJS objects are built.
++  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
++  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
+ done
+ LIBOBJS=$ac_libobjs
+@@ -9939,17 +10313,45 @@ cat >>$CONFIG_STATUS <<\_ACEOF
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -9959,8 +10361,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -9974,18 +10411,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -9993,159 +10431,120 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-
+-
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
+-fi
++# CDPATH.
++$as_unset CDPATH
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+-echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
+-    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
+-       /*)
+-         if ("$as_dir/$as_base" -c '
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
+-    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+-echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
++  chmod +x "$as_me.lineno" ||
++    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -10154,7 +10553,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -10163,31 +10583,14 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
+-
+ exec 6>&1
+-# Open the log real soon, to keep \$[0] and so on meaningful, and to
++# Save the log message, to keep $[0] and so on meaningful, and to
+ # report actual input values of CONFIG_FILES etc. instead of their
+-# values after options handling.  Logging --version etc. is OK.
+-exec 5>>config.log
+-{
+-  echo
+-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+-## Running $as_me. ##
+-_ASBOX
+-} >&5
+-cat >&5 <<_CSEOF
+-
++# values after options handling.
++ac_log="
+ This file was extended by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   CONFIG_FILES    = $CONFIG_FILES
+   CONFIG_HEADERS  = $CONFIG_HEADERS
+@@ -10195,30 +10598,20 @@ generated by GNU Autoconf 2.59.  Invocat
+   CONFIG_COMMANDS = $CONFIG_COMMANDS
+   $ $0 $@
+-_CSEOF
+-echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+-echo >&5
++on `(hostname || uname -n) 2>/dev/null | sed 1q`
++"
++
+ _ACEOF
++cat >>$CONFIG_STATUS <<_ACEOF
+ # Files that config.status was made for.
+-if test -n "$ac_config_files"; then
+-  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_headers"; then
+-  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_links"; then
+-  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
+-fi
++config_files="$ac_config_files"
++config_headers="$ac_config_headers"
++config_commands="$ac_config_commands"
+-if test -n "$ac_config_commands"; then
+-  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
+-fi
++_ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-
+ ac_cs_usage="\
+ \`$as_me' instantiates files from templates according to the
+ current configuration.
+@@ -10226,7 +10619,7 @@ current configuration.
+ Usage: $0 [OPTIONS] [FILE]...
+   -h, --help       print this help, then exit
+-  -V, --version    print version number, then exit
++  -V, --version    print version number and configuration settings, then exit
+   -q, --quiet      do not print progress messages
+   -d, --debug      don't remove temporary files
+       --recheck    update $as_me by reconfiguring in the same conditions
+@@ -10245,19 +10638,21 @@ Configuration commands:
+ $config_commands
+ Report bugs to <bug-autoconf@gnu.org>."
+-_ACEOF
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ ac_cs_version="\\
+ config.status
+-configured by $0, generated by GNU Autoconf 2.59,
+-  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
++configured by $0, generated by GNU Autoconf 2.61,
++  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 2006 Free Software Foundation, Inc.
+ This config.status script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it."
+-srcdir=$srcdir
+-INSTALL="$INSTALL"
++
++ac_pwd='$ac_pwd'
++srcdir='$srcdir'
++INSTALL='$INSTALL'
+ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+@@ -10268,39 +10663,24 @@ while test $# != 0
+ do
+   case $1 in
+   --*=*)
+-    ac_option=`expr "x$1" : 'x\([^=]*\)='`
+-    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
++    ac_option=`expr "X$1" : 'X\([^=]*\)='`
++    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+     ac_shift=:
+     ;;
+-  -*)
++  *)
+     ac_option=$1
+     ac_optarg=$2
+     ac_shift=shift
+     ;;
+-  *) # This is not an option, so the user has probably given explicit
+-     # arguments.
+-     ac_option=$1
+-     ac_need_defaults=false;;
+   esac
+   case $ac_option in
+   # Handling of the options.
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+     ac_cs_recheck=: ;;
+-  --version | --vers* | -V )
+-    echo "$ac_cs_version"; exit 0 ;;
+-  --he | --h)
+-    # Conflict between --help and --header
+-    { { echo "$as_me:$LINENO: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&2;}
+-   { (exit 1); exit 1; }; };;
+-  --help | --hel | -h )
+-    echo "$ac_cs_usage"; exit 0 ;;
+-  --debug | --d* | -d )
++  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
++    echo "$ac_cs_version"; exit ;;
++  --debug | --debu | --deb | --de | --d | -d )
+     debug=: ;;
+   --file | --fil | --fi | --f )
+     $ac_shift
+@@ -10310,18 +10690,24 @@ Try \`$0 --help' for more information." 
+     $ac_shift
+     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+     ac_need_defaults=false;;
++  --he | --h)
++    # Conflict between --help and --header
++    { echo "$as_me: error: ambiguous option: $1
++Try \`$0 --help' for more information." >&2
++   { (exit 1); exit 1; }; };;
++  --help | --hel | -h )
++    echo "$ac_cs_usage"; exit ;;
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil | --si | --s)
+     ac_cs_silent=: ;;
+   # This is an error.
+-  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&2;}
++  -*) { echo "$as_me: error: unrecognized option: $1
++Try \`$0 --help' for more information." >&2
+    { (exit 1); exit 1; }; } ;;
+-  *) ac_config_targets="$ac_config_targets $1" ;;
++  *) ac_config_targets="$ac_config_targets $1"
++     ac_need_defaults=false ;;
+   esac
+   shift
+@@ -10337,39 +10723,51 @@ fi
+ _ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ if \$ac_cs_recheck; then
+-  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
+-  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
++  echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
++  CONFIG_SHELL=$SHELL
++  export CONFIG_SHELL
++  exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+ fi
+ _ACEOF
++cat >>$CONFIG_STATUS <<\_ACEOF
++exec 5>>config.log
++{
++  echo
++  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
++## Running $as_me. ##
++_ASBOX
++  echo "$ac_log"
++} >&5
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ #
+-# INIT-COMMANDS section.
++# INIT-COMMANDS
+ #
+-
+ AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+ _ACEOF
+-
+-
+ cat >>$CONFIG_STATUS <<\_ACEOF
++
++# Handling of arguments.
+ for ac_config_target in $ac_config_targets
+ do
+-  case "$ac_config_target" in
+-  # Handling of arguments.
+-  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+-  "po/Makefile.in" ) CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
+-  "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+-  "default" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
+-  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++  case $ac_config_target in
++    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
++    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
++    "po/Makefile.in") CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
++    "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
++
+   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+ echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+    { (exit 1); exit 1; }; };;
+   esac
+ done
++
+ # If the user did not use the arguments to specify the items to instantiate,
+ # then the envvar interface is used.  Set only those that are not.
+ # We use the long form for the default assignment because of an extremely
+@@ -10381,640 +10779,634 @@ if $ac_need_defaults; then
+ fi
+ # Have a temporary directory for convenience.  Make it in the build tree
+-# simply because there is no reason to put it here, and in addition,
++# simply because there is no reason against having it here, and in addition,
+ # creating and moving files from /tmp can sometimes cause problems.
+-# Create a temporary directory, and hook for its removal unless debugging.
++# Hook for its removal unless debugging.
++# Note that there is a small window in which the directory will not be cleaned:
++# after its creation but before its name has been assigned to `$tmp'.
+ $debug ||
+ {
+-  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
++  tmp=
++  trap 'exit_status=$?
++  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
++' 0
+   trap '{ (exit 1); exit 1; }' 1 2 13 15
+ }
+-
+ # Create a (secure) tmp directory for tmp files.
+ {
+-  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
++  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+   test -n "$tmp" && test -d "$tmp"
+ }  ||
+ {
+-  tmp=./confstat$$-$RANDOM
+-  (umask 077 && mkdir $tmp)
++  tmp=./conf$$-$RANDOM
++  (umask 077 && mkdir "$tmp")
+ } ||
+ {
+    echo "$me: cannot create a temporary directory in ." >&2
+    { (exit 1); exit 1; }
+ }
+-_ACEOF
+-
+-cat >>$CONFIG_STATUS <<_ACEOF
+-
+ #
+-# CONFIG_FILES section.
++# Set up the sed scripts for CONFIG_FILES section.
+ #
+ # No need to generate the scripts if there are no CONFIG_FILES.
+ # This happens for instance when ./config.status config.h
+-if test -n "\$CONFIG_FILES"; then
+-  # Protect against being on the right side of a sed subst in config.status.
+-  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
+-   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
+-s,@SHELL@,$SHELL,;t t
+-s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
+-s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
+-s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
+-s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
+-s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
+-s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
+-s,@exec_prefix@,$exec_prefix,;t t
+-s,@prefix@,$prefix,;t t
+-s,@program_transform_name@,$program_transform_name,;t t
+-s,@bindir@,$bindir,;t t
+-s,@sbindir@,$sbindir,;t t
+-s,@libexecdir@,$libexecdir,;t t
+-s,@datadir@,$datadir,;t t
+-s,@sysconfdir@,$sysconfdir,;t t
+-s,@sharedstatedir@,$sharedstatedir,;t t
+-s,@localstatedir@,$localstatedir,;t t
+-s,@libdir@,$libdir,;t t
+-s,@includedir@,$includedir,;t t
+-s,@oldincludedir@,$oldincludedir,;t t
+-s,@infodir@,$infodir,;t t
+-s,@mandir@,$mandir,;t t
+-s,@build_alias@,$build_alias,;t t
+-s,@host_alias@,$host_alias,;t t
+-s,@target_alias@,$target_alias,;t t
+-s,@DEFS@,$DEFS,;t t
+-s,@ECHO_C@,$ECHO_C,;t t
+-s,@ECHO_N@,$ECHO_N,;t t
+-s,@ECHO_T@,$ECHO_T,;t t
+-s,@LIBS@,$LIBS,;t t
+-s,@build@,$build,;t t
+-s,@build_cpu@,$build_cpu,;t t
+-s,@build_vendor@,$build_vendor,;t t
+-s,@build_os@,$build_os,;t t
+-s,@host@,$host,;t t
+-s,@host_cpu@,$host_cpu,;t t
+-s,@host_vendor@,$host_vendor,;t t
+-s,@host_os@,$host_os,;t t
+-s,@target@,$target,;t t
+-s,@target_cpu@,$target_cpu,;t t
+-s,@target_vendor@,$target_vendor,;t t
+-s,@target_os@,$target_os,;t t
+-s,@CC@,$CC,;t t
+-s,@CFLAGS@,$CFLAGS,;t t
+-s,@LDFLAGS@,$LDFLAGS,;t t
+-s,@CPPFLAGS@,$CPPFLAGS,;t t
+-s,@ac_ct_CC@,$ac_ct_CC,;t t
+-s,@EXEEXT@,$EXEEXT,;t t
+-s,@OBJEXT@,$OBJEXT,;t t
+-s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
+-s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
+-s,@INSTALL_DATA@,$INSTALL_DATA,;t t
+-s,@CYGPATH_W@,$CYGPATH_W,;t t
+-s,@PACKAGE@,$PACKAGE,;t t
+-s,@VERSION@,$VERSION,;t t
+-s,@ACLOCAL@,$ACLOCAL,;t t
+-s,@AUTOCONF@,$AUTOCONF,;t t
+-s,@AUTOMAKE@,$AUTOMAKE,;t t
+-s,@AUTOHEADER@,$AUTOHEADER,;t t
+-s,@MAKEINFO@,$MAKEINFO,;t t
+-s,@install_sh@,$install_sh,;t t
+-s,@STRIP@,$STRIP,;t t
+-s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
+-s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
+-s,@mkdir_p@,$mkdir_p,;t t
+-s,@AWK@,$AWK,;t t
+-s,@SET_MAKE@,$SET_MAKE,;t t
+-s,@am__leading_dot@,$am__leading_dot,;t t
+-s,@AMTAR@,$AMTAR,;t t
+-s,@am__tar@,$am__tar,;t t
+-s,@am__untar@,$am__untar,;t t
+-s,@DEPDIR@,$DEPDIR,;t t
+-s,@am__include@,$am__include,;t t
+-s,@am__quote@,$am__quote,;t t
+-s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
+-s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
+-s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
+-s,@CCDEPMODE@,$CCDEPMODE,;t t
+-s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
+-s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
+-s,@LN_S@,$LN_S,;t t
+-s,@RANLIB@,$RANLIB,;t t
+-s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
+-s,@LIBTOOL@,$LIBTOOL,;t t
+-s,@use_sysroot@,$use_sysroot,;t t
+-s,@TARGET_SYSTEM_ROOT@,$TARGET_SYSTEM_ROOT,;t t
+-s,@TARGET_SYSTEM_ROOT_DEFINE@,$TARGET_SYSTEM_ROOT_DEFINE,;t t
+-s,@WARN_CFLAGS@,$WARN_CFLAGS,;t t
+-s,@NO_WERROR@,$NO_WERROR,;t t
+-s,@CPP@,$CPP,;t t
+-s,@EGREP@,$EGREP,;t t
+-s,@ALLOCA@,$ALLOCA,;t t
+-s,@USE_NLS@,$USE_NLS,;t t
+-s,@MSGFMT@,$MSGFMT,;t t
+-s,@GMSGFMT@,$GMSGFMT,;t t
+-s,@XGETTEXT@,$XGETTEXT,;t t
+-s,@USE_INCLUDED_LIBINTL@,$USE_INCLUDED_LIBINTL,;t t
+-s,@CATALOGS@,$CATALOGS,;t t
+-s,@CATOBJEXT@,$CATOBJEXT,;t t
+-s,@DATADIRNAME@,$DATADIRNAME,;t t
+-s,@GMOFILES@,$GMOFILES,;t t
+-s,@INSTOBJEXT@,$INSTOBJEXT,;t t
+-s,@INTLDEPS@,$INTLDEPS,;t t
+-s,@INTLLIBS@,$INTLLIBS,;t t
+-s,@INTLOBJS@,$INTLOBJS,;t t
+-s,@POFILES@,$POFILES,;t t
+-s,@POSUB@,$POSUB,;t t
+-s,@INCLUDE_LOCALE_H@,$INCLUDE_LOCALE_H,;t t
+-s,@GT_NO@,$GT_NO,;t t
+-s,@GT_YES@,$GT_YES,;t t
+-s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t
+-s,@l@,$l,;t t
+-s,@YACC@,$YACC,;t t
+-s,@LEX@,$LEX,;t t
+-s,@LEXLIB@,$LEXLIB,;t t
+-s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
+-s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
+-s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
+-s,@MAINT@,$MAINT,;t t
+-s,@HDEFINES@,$HDEFINES,;t t
+-s,@HOSTING_CRT0@,$HOSTING_CRT0,;t t
+-s,@HOSTING_LIBS@,$HOSTING_LIBS,;t t
+-s,@NATIVE_LIB_DIRS@,$NATIVE_LIB_DIRS,;t t
+-s,@STRINGIFY@,$STRINGIFY,;t t
+-s,@EMUL@,$EMUL,;t t
+-s,@EMULATION_OFILES@,$EMULATION_OFILES,;t t
+-s,@EMUL_EXTRA_OFILES@,$EMUL_EXTRA_OFILES,;t t
+-s,@LIB_PATH@,$LIB_PATH,;t t
+-s,@EMULATION_LIBPATH@,$EMULATION_LIBPATH,;t t
+-s,@TESTBFDLIB@,$TESTBFDLIB,;t t
+-s,@datarootdir@,$datarootdir,;t t
+-s,@docdir@,$docdir,;t t
+-s,@htmldir@,$htmldir,;t t
+-s,@LIBOBJS@,$LIBOBJS,;t t
+-s,@LTLIBOBJS@,$LTLIBOBJS,;t t
+-/@TDIRS@/r $TDIRS
+-s,@TDIRS@,,;t t
+-CEOF
+-
+-_ACEOF
+-
+-  cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Split the substitutions into bite-sized pieces for seds with
+-  # small command number limits, like on Digital OSF/1 and HP-UX.
+-  ac_max_sed_lines=48
+-  ac_sed_frag=1 # Number of current file.
+-  ac_beg=1 # First line for current file.
+-  ac_end=$ac_max_sed_lines # Line after last line for current file.
+-  ac_more_lines=:
+-  ac_sed_cmds=
+-  while $ac_more_lines; do
+-    if test $ac_beg -gt 1; then
+-      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    else
+-      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    fi
+-    if test ! -s $tmp/subs.frag; then
+-      ac_more_lines=false
+-    else
+-      # The purpose of the label and of the branching condition is to
+-      # speed up the sed processing (if there are no `@' at all, there
+-      # is no need to browse any of the substitutions).
+-      # These are the two extra sed commands mentioned above.
+-      (echo ':t
+-  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
+-      if test -z "$ac_sed_cmds"; then
+-      ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
+-      else
+-      ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
+-      fi
+-      ac_sed_frag=`expr $ac_sed_frag + 1`
+-      ac_beg=$ac_end
+-      ac_end=`expr $ac_end + $ac_max_sed_lines`
+-    fi
+-  done
+-  if test -z "$ac_sed_cmds"; then
+-    ac_sed_cmds=cat
++if test -n "$CONFIG_FILES"; then
++
++_ACEOF
++
++# Create sed commands to just substitute file output variables.
++
++# Remaining file output variables are in a fragment that also has non-file
++# output varibles.
++
++
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++SHELL!$SHELL$ac_delim
++PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim
++PACKAGE_NAME!$PACKAGE_NAME$ac_delim
++PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim
++PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim
++PACKAGE_STRING!$PACKAGE_STRING$ac_delim
++PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim
++exec_prefix!$exec_prefix$ac_delim
++prefix!$prefix$ac_delim
++program_transform_name!$program_transform_name$ac_delim
++bindir!$bindir$ac_delim
++sbindir!$sbindir$ac_delim
++libexecdir!$libexecdir$ac_delim
++datarootdir!$datarootdir$ac_delim
++datadir!$datadir$ac_delim
++sysconfdir!$sysconfdir$ac_delim
++sharedstatedir!$sharedstatedir$ac_delim
++localstatedir!$localstatedir$ac_delim
++includedir!$includedir$ac_delim
++oldincludedir!$oldincludedir$ac_delim
++docdir!$docdir$ac_delim
++infodir!$infodir$ac_delim
++htmldir!$htmldir$ac_delim
++dvidir!$dvidir$ac_delim
++pdfdir!$pdfdir$ac_delim
++psdir!$psdir$ac_delim
++libdir!$libdir$ac_delim
++localedir!$localedir$ac_delim
++mandir!$mandir$ac_delim
++DEFS!$DEFS$ac_delim
++ECHO_C!$ECHO_C$ac_delim
++ECHO_N!$ECHO_N$ac_delim
++ECHO_T!$ECHO_T$ac_delim
++LIBS!$LIBS$ac_delim
++build_alias!$build_alias$ac_delim
++host_alias!$host_alias$ac_delim
++target_alias!$target_alias$ac_delim
++build!$build$ac_delim
++build_cpu!$build_cpu$ac_delim
++build_vendor!$build_vendor$ac_delim
++build_os!$build_os$ac_delim
++host!$host$ac_delim
++host_cpu!$host_cpu$ac_delim
++host_vendor!$host_vendor$ac_delim
++host_os!$host_os$ac_delim
++target!$target$ac_delim
++target_cpu!$target_cpu$ac_delim
++target_vendor!$target_vendor$ac_delim
++target_os!$target_os$ac_delim
++CC!$CC$ac_delim
++CFLAGS!$CFLAGS$ac_delim
++LDFLAGS!$LDFLAGS$ac_delim
++CPPFLAGS!$CPPFLAGS$ac_delim
++ac_ct_CC!$ac_ct_CC$ac_delim
++EXEEXT!$EXEEXT$ac_delim
++OBJEXT!$OBJEXT$ac_delim
++INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
++INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim
++INSTALL_DATA!$INSTALL_DATA$ac_delim
++CYGPATH_W!$CYGPATH_W$ac_delim
++PACKAGE!$PACKAGE$ac_delim
++VERSION!$VERSION$ac_delim
++ACLOCAL!$ACLOCAL$ac_delim
++AUTOCONF!$AUTOCONF$ac_delim
++AUTOMAKE!$AUTOMAKE$ac_delim
++AUTOHEADER!$AUTOHEADER$ac_delim
++MAKEINFO!$MAKEINFO$ac_delim
++install_sh!$install_sh$ac_delim
++STRIP!$STRIP$ac_delim
++INSTALL_STRIP_PROGRAM!$INSTALL_STRIP_PROGRAM$ac_delim
++mkdir_p!$mkdir_p$ac_delim
++AWK!$AWK$ac_delim
++SET_MAKE!$SET_MAKE$ac_delim
++am__leading_dot!$am__leading_dot$ac_delim
++AMTAR!$AMTAR$ac_delim
++am__tar!$am__tar$ac_delim
++am__untar!$am__untar$ac_delim
++DEPDIR!$DEPDIR$ac_delim
++am__include!$am__include$ac_delim
++am__quote!$am__quote$ac_delim
++AMDEP_TRUE!$AMDEP_TRUE$ac_delim
++AMDEP_FALSE!$AMDEP_FALSE$ac_delim
++AMDEPBACKSLASH!$AMDEPBACKSLASH$ac_delim
++CCDEPMODE!$CCDEPMODE$ac_delim
++am__fastdepCC_TRUE!$am__fastdepCC_TRUE$ac_delim
++am__fastdepCC_FALSE!$am__fastdepCC_FALSE$ac_delim
++LN_S!$LN_S$ac_delim
++RANLIB!$RANLIB$ac_delim
++LIBTOOL!$LIBTOOL$ac_delim
++use_sysroot!$use_sysroot$ac_delim
++TARGET_SYSTEM_ROOT!$TARGET_SYSTEM_ROOT$ac_delim
++TARGET_SYSTEM_ROOT_DEFINE!$TARGET_SYSTEM_ROOT_DEFINE$ac_delim
++WARN_CFLAGS!$WARN_CFLAGS$ac_delim
++NO_WERROR!$NO_WERROR$ac_delim
++_ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 94; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+   fi
+-fi # test -n "$CONFIG_FILES"
++done
++
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
++/^[    ]*@TDIRS@[      ]*$/{
++r $TDIRS
++d
++}
++_ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++CEOF$ac_eof
++_ACEOF
++
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++CPP!$CPP$ac_delim
++GREP!$GREP$ac_delim
++EGREP!$EGREP$ac_delim
++ALLOCA!$ALLOCA$ac_delim
++USE_NLS!$USE_NLS$ac_delim
++MSGFMT!$MSGFMT$ac_delim
++GMSGFMT!$GMSGFMT$ac_delim
++XGETTEXT!$XGETTEXT$ac_delim
++USE_INCLUDED_LIBINTL!$USE_INCLUDED_LIBINTL$ac_delim
++CATALOGS!$CATALOGS$ac_delim
++CATOBJEXT!$CATOBJEXT$ac_delim
++DATADIRNAME!$DATADIRNAME$ac_delim
++GMOFILES!$GMOFILES$ac_delim
++INSTOBJEXT!$INSTOBJEXT$ac_delim
++INTLDEPS!$INTLDEPS$ac_delim
++INTLLIBS!$INTLLIBS$ac_delim
++INTLOBJS!$INTLOBJS$ac_delim
++POFILES!$POFILES$ac_delim
++POSUB!$POSUB$ac_delim
++INCLUDE_LOCALE_H!$INCLUDE_LOCALE_H$ac_delim
++GT_NO!$GT_NO$ac_delim
++GT_YES!$GT_YES$ac_delim
++MKINSTALLDIRS!$MKINSTALLDIRS$ac_delim
++l!$l$ac_delim
++YACC!$YACC$ac_delim
++YFLAGS!$YFLAGS$ac_delim
++LEX!$LEX$ac_delim
++LEX_OUTPUT_ROOT!$LEX_OUTPUT_ROOT$ac_delim
++LEXLIB!$LEXLIB$ac_delim
++MAINTAINER_MODE_TRUE!$MAINTAINER_MODE_TRUE$ac_delim
++MAINTAINER_MODE_FALSE!$MAINTAINER_MODE_FALSE$ac_delim
++MAINT!$MAINT$ac_delim
++HDEFINES!$HDEFINES$ac_delim
++HOSTING_CRT0!$HOSTING_CRT0$ac_delim
++HOSTING_LIBS!$HOSTING_LIBS$ac_delim
++NATIVE_LIB_DIRS!$NATIVE_LIB_DIRS$ac_delim
++STRINGIFY!$STRINGIFY$ac_delim
++EMUL!$EMUL$ac_delim
++EMULATION_OFILES!$EMULATION_OFILES$ac_delim
++EMUL_EXTRA_OFILES!$EMUL_EXTRA_OFILES$ac_delim
++LIB_PATH!$LIB_PATH$ac_delim
++EMULATION_LIBPATH!$EMULATION_LIBPATH$ac_delim
++TESTBFDLIB!$TESTBFDLIB$ac_delim
++LIBOBJS!$LIBOBJS$ac_delim
++LTLIBOBJS!$LTLIBOBJS$ac_delim
++_ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 45; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
++  fi
++done
++
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-2.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end
++_ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++:end
++s/|#_!!_#|//g
++CEOF$ac_eof
+ _ACEOF
++
++
++# VPATH may cause trouble with some makes, so we remove $(srcdir),
++# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
++# trailing colons and then remove the whole line if VPATH becomes empty
++# (actually we leave an empty line to preserve line numbers).
++if test "x$srcdir" = x.; then
++  ac_vpsub='/^[        ]*VPATH[        ]*=/{
++s/:*\$(srcdir):*/:/
++s/:*\${srcdir}:*/:/
++s/:*@srcdir@:*/:/
++s/^\([^=]*=[   ]*\):*/\1/
++s/:*$//
++s/^[^=]*=[     ]*$//
++}'
++fi
++
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+-  case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++fi # test -n "$CONFIG_FILES"
++
++
++for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS
++do
++  case $ac_tag in
++  :[FHLC]) ac_mode=$ac_tag; continue;;
++  esac
++  case $ac_mode$ac_tag in
++  :[FHL]*:*);;
++  :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
++echo "$as_me: error: Invalid tag $ac_tag." >&2;}
++   { (exit 1); exit 1; }; };;
++  :[FH]-) ac_tag=-:-;;
++  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
++  esac
++  ac_save_IFS=$IFS
++  IFS=:
++  set x $ac_tag
++  IFS=$ac_save_IFS
++  shift
++  ac_file=$1
++  shift
++
++  case $ac_mode in
++  :L) ac_source=$1;;
++  :[FH])
++    ac_file_inputs=
++    for ac_f
++    do
++      case $ac_f in
++      -) ac_f="$tmp/stdin";;
++      *) # Look for the file first in the build tree, then in the source tree
++       # (if the path is not absolute).  The absolute path cannot be DOS-style,
++       # because $ac_f cannot contain `:'.
++       test -f "$ac_f" ||
++         case $ac_f in
++         [\\/$]*) false;;
++         *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
++         esac ||
++         { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
++echo "$as_me: error: cannot find input file: $ac_f" >&2;}
++   { (exit 1); exit 1; }; };;
++      esac
++      ac_file_inputs="$ac_file_inputs $ac_f"
++    done
++
++    # Let's still pretend it is `configure' which instantiates (i.e., don't
++    # use $as_me), people would be surprised to read:
++    #    /* config.h.  Generated by config.status.  */
++    configure_input="Generated from "`IFS=:
++        echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."
++    if test x"$ac_file" != x-; then
++      configure_input="$ac_file.  $configure_input"
++      { echo "$as_me:$LINENO: creating $ac_file" >&5
++echo "$as_me: creating $ac_file" >&6;}
++    fi
++
++    case $ac_tag in
++    *:-:* | *:-) cat >"$tmp/stdin";;
++    esac
++    ;;
+   esac
+-  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
+-  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
++  ac_dir=`$as_dirname -- "$ac_file" ||
+ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$ac_file" : 'X\(//\)[^/]' \| \
+        X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++  { as_dir="$ac_dir"
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+   ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  case $ac_mode in
++  :F)
++  #
++  # CONFIG_FILE
++  #
+   case $INSTALL in
+   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+-  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
++  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+   esac
++_ACEOF
+-  if test x"$ac_file" != x-; then
+-    { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-    rm -f "$ac_file"
+-  fi
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    configure_input=
+-  else
+-    configure_input="$ac_file.  "
+-  fi
+-  configure_input=$configure_input"Generated from `echo $ac_file_in |
+-                                   sed 's,.*/,,'` by configure."
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
++cat >>$CONFIG_STATUS <<\_ACEOF
++# If the template does not know about datarootdir, expand it.
++# FIXME: This hack should be removed a few years after 2.60.
++ac_datarootdir_hack=; ac_datarootdir_seen=
++
++case `sed -n '/datarootdir/ {
++  p
++  q
++}
++/@datadir@/p
++/@docdir@/p
++/@infodir@/p
++/@localedir@/p
++/@mandir@/p
++' $ac_file_inputs` in
++*datarootdir*) ac_datarootdir_seen=yes;;
++*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
++  { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
++echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+ _ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
++  ac_datarootdir_hack='
++  s&@datadir@&$datadir&g
++  s&@docdir@&$docdir&g
++  s&@infodir@&$infodir&g
++  s&@localedir@&$localedir&g
++  s&@mandir@&$mandir&g
++    s&\\\${datarootdir}&$datarootdir&g' ;;
++esac
++_ACEOF
++
++# Neutralize VPATH when `$srcdir' = `.'.
++# Shell code in configure.ac might set extrasub.
++# FIXME: do we really want to maintain this feature?
++cat >>$CONFIG_STATUS <<_ACEOF
+   sed "$ac_vpsub
+ $extrasub
+ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+ :t
+ /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+-s,@configure_input@,$configure_input,;t t
+-s,@srcdir@,$ac_srcdir,;t t
+-s,@abs_srcdir@,$ac_abs_srcdir,;t t
+-s,@top_srcdir@,$ac_top_srcdir,;t t
+-s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+-s,@builddir@,$ac_builddir,;t t
+-s,@abs_builddir@,$ac_abs_builddir,;t t
+-s,@top_builddir@,$ac_top_builddir,;t t
+-s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
+-s,@INSTALL@,$ac_INSTALL,;t t
+-" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
+-  rm -f $tmp/stdin
+-  if test x"$ac_file" != x-; then
+-    mv $tmp/out $ac_file
+-  else
+-    cat $tmp/out
+-    rm -f $tmp/out
+-  fi
+-
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_HEADER section.
+-#
+-
+-# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
+-# NAME is the cpp macro being defined and VALUE is the value it is being given.
+-#
+-# ac_d sets the value in "#define NAME VALUE" lines.
+-ac_dA='s,^\([  ]*\)#\([        ]*define[       ][      ]*\)'
+-ac_dB='[       ].*$,\1#\2'
+-ac_dC=' '
+-ac_dD=',;t'
+-# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
+-ac_uA='s,^\([  ]*\)#\([        ]*\)undef\([    ][      ]*\)'
+-ac_uB='$,\1#\2define\3'
+-ac_uC=' '
+-ac_uD=',;t'
++s&@configure_input@&$configure_input&;t t
++s&@top_builddir@&$ac_top_builddir_sub&;t t
++s&@srcdir@&$ac_srcdir&;t t
++s&@abs_srcdir@&$ac_abs_srcdir&;t t
++s&@top_srcdir@&$ac_top_srcdir&;t t
++s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
++s&@builddir@&$ac_builddir&;t t
++s&@abs_builddir@&$ac_abs_builddir&;t t
++s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
++s&@INSTALL@&$ac_INSTALL&;t t
++$ac_datarootdir_hack
++" $ac_file_inputs | sed -f "$tmp/subs-1.sed" | sed -f "$tmp/subs-2.sed" >$tmp/out
++
++test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
++  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
++  { ac_out=`sed -n '/^[        ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
++  { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&5
++echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&2;}
+-for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
++  rm -f "$tmp/stdin"
+   case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++  -) cat "$tmp/out"; rm -f "$tmp/out";;
++  *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;
+   esac
++ ;;
++  :H)
++  #
++  # CONFIG_HEADER
++  #
++_ACEOF
++
++# Transform confdefs.h into a sed script `conftest.defines', that
++# substitutes the proper values into config.h.in to produce config.h.
++rm -f conftest.defines conftest.tail
++# First, append a space to every undef/define line, to ease matching.
++echo 's/$/ /' >conftest.defines
++# Then, protect against being on the right side of a sed subst, or in
++# an unquoted here document, in config.status.  If some macros were
++# called several times there might be several #defines for the same
++# symbol, which is useless.  But do not sort them, since the last
++# AC_DEFINE must be honored.
++ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
++# These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where
++# NAME is the cpp macro being defined, VALUE is the value it is being given.
++# PARAMS is the parameter list in the macro definition--in most cases, it's
++# just an empty string.
++ac_dA='s,^\\([         #]*\\)[^        ]*\\([  ]*'
++ac_dB='\\)[    (].*,\\1define\\2'
++ac_dC=' '
++ac_dD=' ,'
+-  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       # Do quote $f, to prevent DOS paths from being IFS'd.
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
+-  # Remove the trailing spaces.
+-  sed 's/[     ]*$//' $ac_file_inputs >$tmp/in
+-
+-_ACEOF
+-
+-# Transform confdefs.h into two sed scripts, `conftest.defines' and
+-# `conftest.undefs', that substitutes the proper values into
+-# config.h.in to produce config.h.  The first handles `#define'
+-# templates, and the second `#undef' templates.
+-# And first: Protect against being on the right side of a sed subst in
+-# config.status.  Protect against being in an unquoted here document
+-# in config.status.
+-rm -f conftest.defines conftest.undefs
+-# Using a here document instead of a string reduces the quoting nightmare.
+-# Putting comments in sed scripts is not portable.
+-#
+-# `end' is used to avoid that the second main sed command (meant for
+-# 0-ary CPP macros) applies to n-ary macro definitions.
+-# See the Autoconf documentation for `clear'.
+-cat >confdef2sed.sed <<\_ACEOF
+-s/[\\&,]/\\&/g
+-s,[\\$`],\\&,g
+-t clear
+-: clear
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
+-t end
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
+-: end
+-_ACEOF
+-# If some macros were called several times there might be several times
+-# the same #defines, which is useless.  Nevertheless, we may not want to
+-# sort them, since we want the *last* AC-DEFINE to be honored.
+-uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
+-sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
+-rm -f confdef2sed.sed
++uniq confdefs.h |
++  sed -n '
++      t rset
++      :rset
++      s/^[     ]*#[    ]*define[       ][      ]*//
++      t ok
++      d
++      :ok
++      s/[\\&,]/\\&/g
++      s/^\('"$ac_word_re"'\)\(([^()]*)\)[      ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p
++      s/^\('"$ac_word_re"'\)[  ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p
++  ' >>conftest.defines
+-# This sed command replaces #undef with comments.  This is necessary, for
++# Remove the space that was appended to ease matching.
++# Then replace #undef with comments.  This is necessary, for
+ # example, in the case of _POSIX_SOURCE, which is predefined and required
+ # on some systems where configure will not decide to define it.
+-cat >>conftest.undefs <<\_ACEOF
+-s,^[   ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
++# (The regexp can be short, since the line contains either #define or #undef.)
++echo 's/ $//
++s,^[   #]*u.*,/* & */,' >>conftest.defines
++
++# Break up conftest.defines:
++ac_max_sed_lines=50
++
++# First sed command is:        sed -f defines.sed $ac_file_inputs >"$tmp/out1"
++# Second one is:       sed -f defines.sed "$tmp/out1" >"$tmp/out2"
++# Third one will be:   sed -f defines.sed "$tmp/out2" >"$tmp/out1"
++# et cetera.
++ac_in='$ac_file_inputs'
++ac_out='"$tmp/out1"'
++ac_nxt='"$tmp/out2"'
++
++while :
++do
++  # Write a here document:
++    cat >>$CONFIG_STATUS <<_ACEOF
++    # First, check the format of the line:
++    cat >"\$tmp/defines.sed" <<\\CEOF
++/^[    ]*#[    ]*undef[        ][      ]*$ac_word_re[  ]*\$/b def
++/^[    ]*#[    ]*define[       ][      ]*$ac_word_re[(         ]/b def
++b
++:def
+ _ACEOF
+-
+-# Break up conftest.defines because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
+-echo '  if grep "^[    ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
+-echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
+-echo '  :' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.defines >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/defines.sed.
+-  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#define' lines.
+-  echo '/^[    ]*#[    ]*define/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
++  sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS
+   echo 'CEOF
+-  sed -f $tmp/defines.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
++    sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS
++  ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in
++  sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail
++  grep . conftest.tail >/dev/null || break
+   rm -f conftest.defines
+   mv conftest.tail conftest.defines
+ done
+-rm -f conftest.defines
+-echo '  fi # grep' >>$CONFIG_STATUS
+-echo >>$CONFIG_STATUS
+-
+-# Break up conftest.undefs because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.undefs >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/undefs.sed.
+-  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#undef'
+-  echo '/^[    ]*#[    ]*undef/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
+-  echo 'CEOF
+-  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
+-  rm -f conftest.undefs
+-  mv conftest.tail conftest.undefs
+-done
+-rm -f conftest.undefs
++rm -f conftest.defines conftest.tail
++echo "ac_result=$ac_in" >>$CONFIG_STATUS
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    echo "/* Generated by configure.  */" >$tmp/config.h
+-  else
+-    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
+-  fi
+-  cat $tmp/in >>$tmp/config.h
+-  rm -f $tmp/in
+   if test x"$ac_file" != x-; then
+-    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
++    echo "/* $configure_input  */" >"$tmp/config.h"
++    cat "$ac_result" >>"$tmp/config.h"
++    if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then
+       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
+ echo "$as_me: $ac_file is unchanged" >&6;}
+     else
+-      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_file" : 'X\(//\)[^/]' \| \
+-       X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-      { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+       rm -f $ac_file
+-      mv $tmp/config.h $ac_file
++      mv "$tmp/config.h" $ac_file
+     fi
+   else
+-    cat $tmp/config.h
+-    rm -f $tmp/config.h
++    echo "/* $configure_input  */"
++    cat "$ac_result"
+   fi
++  rm -f "$tmp/out12"
+ # Compute $ac_file's index in $config_headers.
+ _am_stamp_count=1
+ for _am_header in $config_headers :; do
+@@ -11025,135 +11417,39 @@ for _am_header in $config_headers :; do
+       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+   esac
+ done
+-echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
++echo "timestamp for $ac_file" >`$as_dirname -- $ac_file ||
+ $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X$ac_file : 'X\(//\)[^/]' \| \
+        X$ac_file : 'X\(//\)$' \| \
+-       X$ac_file : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X$ac_file : 'X\(/\)' \| . 2>/dev/null ||
+ echo X$ac_file |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`/stamp-h$_am_stamp_count
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_COMMANDS section.
+-#
+-for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
+-  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
+-  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
+-$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_dest" : 'X\(//\)[^/]' \| \
+-       X"$ac_dest" : 'X\(//\)$' \| \
+-       X"$ac_dest" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_dest" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+-  ac_builddir=.
+-
+-if test "$ac_dir" != .; then
+-  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
+-
+-case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
+-    ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
+-    ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`/stamp-h$_am_stamp_count
++ ;;
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  :C)  { echo "$as_me:$LINENO: executing $ac_file commands" >&5
++echo "$as_me: executing $ac_file commands" >&6;}
++ ;;
++  esac
+-  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
+-echo "$as_me: executing $ac_dest commands" >&6;}
+-  case $ac_dest in
+-    depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
++  case $ac_file$ac_mode in
++    "depfiles":C) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
+   # Strip MF so we end up with the name of the file.
+   mf=`echo "$mf" | sed -e 's/:.*$//'`
+   # Check whether this is an Automake generated Makefile or not.
+@@ -11163,18 +11459,29 @@ echo "$as_me: executing $ac_dest command
+   # each Makefile.in and add a new line on top of each file to say so.
+   # So let's grep whole file.
+   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
+-    dirpart=`(dirname "$mf") 2>/dev/null ||
++    dirpart=`$as_dirname -- "$mf" ||
+ $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$mf" : 'X\(//\)[^/]' \| \
+        X"$mf" : 'X\(//\)$' \| \
+-       X"$mf" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$mf" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   else
+     continue
+   fi
+@@ -11196,54 +11503,80 @@ echo X"$mf" |
+        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+     # Make sure the directory exists.
+     test -f "$dirpart/$file" && continue
+-    fdir=`(dirname "$file") 2>/dev/null ||
++    fdir=`$as_dirname -- "$file" ||
+ $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$file" : 'X\(//\)[^/]' \| \
+        X"$file" : 'X\(//\)$' \| \
+-       X"$file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    { if $as_mkdir_p; then
+-    mkdir -p $dirpart/$fdir
+-  else
+-    as_dir=$dirpart/$fdir
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++    { as_dir=$dirpart/$fdir
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
+-echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+     # echo "creating $dirpart/$file"
+     echo '# dummy' > "$dirpart/$file"
+   done
+ done
+  ;;
+-    default ) sed -e '/POTFILES =/r po/POTFILES' po/Makefile.in > po/Makefile ;;
++    "default":C) sed -e '/POTFILES =/r po/POTFILES' po/Makefile.in > po/Makefile ;;
++
+   esac
+-done
+-_ACEOF
++done # for ac_tag
+-cat >>$CONFIG_STATUS <<\_ACEOF
+ { (exit 0); exit 0; }
+ _ACEOF
+diff -Nrup binutils-2.17/ld/configure.tgt binutils-2.17-atmel/ld/configure.tgt
+--- binutils-2.17/ld/configure.tgt     2006-04-05 14:41:57.000000000 +0200
++++ binutils-2.17-atmel/ld/configure.tgt       2007-02-12 15:37:09.000000000 +0100
+@@ -81,8 +81,10 @@ xscale-*-coff)              targ_emul=armcoff ;;
+ xscale-*-elf)         targ_emul=armelf
+                       ;;
+ avr-*-*)              targ_emul=avr2
+-                      targ_extra_emuls="avr1 avr3 avr4 avr5"
+-                      ;;
++                      targ_extra_emuls="avr1 avr3 avr4 avr5" ;;
++avr32-*-none)         targ_emul=avr32elf_ap7000
++                      targ_extra_emuls="avr32elf_uc3a0512" ;;
++avr32-*-linux*)               targ_emul=avr32linux ;;
+ bfin-*-elf)           targ_emul=elf32bfin; targ_extra_emuls="elf32bfinfd" ;;
+ bfin-*-uclinux*)      targ_emul=elf32bfin; targ_extra_emuls="elf32bfinfd" ;;
+ cr16c-*-elf*)           targ_emul=elf32cr16c
+diff -Nrup binutils-2.17/ld/emulparams/avr32elf_ap7000.sh binutils-2.17-atmel/ld/emulparams/avr32elf_ap7000.sh
+--- binutils-2.17/ld/emulparams/avr32elf_ap7000.sh     1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/ld/emulparams/avr32elf_ap7000.sh       2006-11-10 15:11:19.000000000 +0100
+@@ -0,0 +1,34 @@
++MACHINE=ap
++SCRIPT_NAME=elf_xip
++TEMPLATE_NAME=elf32
++OUTPUT_FORMAT="elf32-avr32"
++ARCH=avr32
++MAXPAGESIZE=4096
++ENTRY=_start
++EMBEDDED=yes
++NO_SMALL_DATA=yes
++NOP=0xd703d703
++
++TEXT_START_ADDR=0xa0000000
++DATA_SEGMENT_ALIGN=8
++BSS_ALIGNMENT=8
++
++INITIAL_READONLY_SECTIONS=".reset : {  *(.reset) } >FLASH AT>FLASH
++    . = . & 0x1fffffff;"
++
++MEMORY="MEMORY
++  {
++    FLASH (rxai) : ORIGIN = 0x00000000, LENGTH = 0x4000000
++    SRAM (rwxa) : ORIGIN = 0x24000000, LENGTH = 0x8000
++  }"
++RO_LMA_REGION="FLASH"
++RO_VMA_REGION="FLASH"
++RW_LMA_REGION="FLASH"
++RW_VMA_REGION="SRAM"
++
++STACK_SIZE=0x1000
++STACK_ADDR="ORIGIN(SRAM) + LENGTH(SRAM) - ${STACK_SIZE}"
++
++DATA_SEGMENT_END="__heap_start__ = ALIGN(8);
++  . = ${STACK_ADDR};
++  __heap_end__ = .;"
+diff -Nrup binutils-2.17/ld/emulparams/avr32elf.sh binutils-2.17-atmel/ld/emulparams/avr32elf.sh
+--- binutils-2.17/ld/emulparams/avr32elf.sh    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/ld/emulparams/avr32elf.sh      2006-08-04 14:51:23.000000000 +0200
+@@ -0,0 +1,24 @@
++MACHINE=
++SCRIPT_NAME=elf
++TEMPLATE_NAME=elf32
++OUTPUT_FORMAT="elf32-avr32"
++TEXT_START_ADDR=0xa0000000
++ARCH=avr32
++MAXPAGESIZE=0x4
++ENTRY=_start
++EMBEDDED=yes
++NOP=0xd703d703
++INITIAL_READONLY_SECTIONS=".reset : AT(0x0) {  *(.reset) }
++    . = . & 0x1fffffff;"
++DATA_START_SYMBOLS="__data_init_start__ = .;
++    __data_init_end__ = .;
++    __data_start__ = .;"
++
++OTHER_BSS_SYMBOLS='__bss_start__ = .;'
++OTHER_BSS_END_SYMBOLS="_bss_end__ = . ; __bss_end__ = . ; __end__ = . ;
++    . = ALIGN(16);
++    __heap_start__ = .;
++    __heap_end__ = 0x82000000;"
++
++STACK_ADDR=0x82000000
++
+diff -Nrup binutils-2.17/ld/emulparams/avr32elf_uc3a0512.sh binutils-2.17-atmel/ld/emulparams/avr32elf_uc3a0512.sh
+--- binutils-2.17/ld/emulparams/avr32elf_uc3a0512.sh   1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/ld/emulparams/avr32elf_uc3a0512.sh     2006-11-10 15:11:19.000000000 +0100
+@@ -0,0 +1,34 @@
++MACHINE=uc
++SCRIPT_NAME=elf_xip
++TEMPLATE_NAME=elf32
++OUTPUT_FORMAT="elf32-avr32"
++ARCH=avr32
++MAXPAGESIZE=4096
++ENTRY=_start
++EMBEDDED=yes
++NO_SMALL_DATA=yes
++NOP=0xd703d703
++
++TEXT_START_ADDR=0x80000000
++DATA_SEGMENT_ALIGN=8
++BSS_ALIGNMENT=8
++
++INITIAL_READONLY_SECTIONS=".reset : {  *(.reset) } >FLASH AT>FLASH
++    . = . & 0x1fffffff;"
++
++MEMORY="MEMORY
++  {
++    FLASH (rxai) : ORIGIN = 0x80000000, LENGTH = 0x80000
++    INTRAM (rwxa) : ORIGIN = 0x00000000, LENGTH = 0x10000
++  }"
++RO_LMA_REGION="FLASH"
++RO_VMA_REGION="FLASH"
++RW_LMA_REGION="FLASH"
++RW_VMA_REGION="INTRAM"
++
++STACK_SIZE=0x1000
++STACK_ADDR="ORIGIN(INTRAM) + LENGTH(INTRAM) - ${STACK_SIZE}"
++
++DATA_SEGMENT_END="__heap_start__ = ALIGN(8);
++  . = ${STACK_ADDR};
++  __heap_end__ = .;"
+diff -Nrup binutils-2.17/ld/emulparams/avr32linux.sh binutils-2.17-atmel/ld/emulparams/avr32linux.sh
+--- binutils-2.17/ld/emulparams/avr32linux.sh  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/ld/emulparams/avr32linux.sh    2006-08-04 14:51:23.000000000 +0200
+@@ -0,0 +1,13 @@
++ARCH=avr32
++SCRIPT_NAME=elf
++TEMPLATE_NAME=elf32
++OUTPUT_FORMAT="elf32-avr32"
++GENERATE_SHLIB_SCRIPT=yes
++MAXPAGESIZE=0x1000
++TEXT_START_ADDR=0x00001000
++NOP=0xd703d703
++
++# This appears to place the GOT before the data section, which is
++# essential for uClinux.  We don't use those .s* sections on AVR32
++# anyway, so it shouldn't hurt for regular Linux either...
++NO_SMALL_DATA=yes
+diff -Nrup binutils-2.17/ld/Makefile.am binutils-2.17-atmel/ld/Makefile.am
+--- binutils-2.17/ld/Makefile.am       2006-06-03 06:45:50.000000000 +0200
++++ binutils-2.17-atmel/ld/Makefile.am 2007-02-12 15:37:09.000000000 +0100
+@@ -133,6 +133,9 @@ ALL_EMULATIONS = \
+       eavr3.o \
+       eavr4.o \
+       eavr5.o \
++      eavr32elf_ap7000.o \
++      eavr32elf_uc3a0512.o \
++      eavr32linux.o \
+       ecoff_i860.o \
+       ecoff_sparc.o \
+       ecrisaout.o \
+@@ -595,6 +598,15 @@ eavr5.c: $(srcdir)/emulparams/avr5.sh \
+   $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/avr.sc \
+   ${GEN_DEPENDS}
+       ${GENSCRIPTS} avr5 "$(tdir_avr2)"
++eavr32elf_ap7000.c: $(srcdir)/emulparams/avr32elf_ap7000.sh \
++  $(srcdir)/emultempl/elf32.em $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}
++      ${GENSCRIPTS} avr32elf_ap7000 "$(tdir_avr32)"
++eavr32elf_uc3a0512.c: $(srcdir)/emulparams/avr32elf_uc3a0512.sh \
++  $(srcdir)/emultempl/elf32.em $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}
++      ${GENSCRIPTS} avr32elf_uc3a0512 "$(tdir_avr32)"
++eavr32linux.c: $(srcdir)/emulparams/avr32linux.sh \
++  $(srcdir)/emultempl/elf32.em $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS}
++      ${GENSCRIPTS} avr32linux "$(tdir_avr32)"
+ ecoff_i860.c: $(srcdir)/emulparams/coff_i860.sh \
+   $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/i860coff.sc ${GEN_DEPENDS}
+       ${GENSCRIPTS} coff_i860 "$(tdir_coff_i860)"
+@@ -1800,7 +1812,9 @@ install-exec-local: ld-new$(EXEEXT)
+         || $(LIBTOOL) --mode=install $(INSTALL_PROGRAM) ld-new$(EXEEXT) $(DESTDIR)$(tooldir)/bin/ld$(EXEEXT); \
+       fi
+-install-data-local:
++# We want install to imply install-info as per GNU standards, despite the
++# cygnus option.
++install-data-local: install-info
+       $(mkinstalldirs) $(DESTDIR)$(scriptdir)/ldscripts
+       for f in ldscripts/*; do \
+         $(INSTALL_DATA) $$f $(DESTDIR)$(scriptdir)/$$f ; \
+diff -Nrup binutils-2.17/ld/Makefile.in binutils-2.17-atmel/ld/Makefile.in
+--- binutils-2.17/ld/Makefile.in       2006-06-03 06:45:50.000000000 +0200
++++ binutils-2.17-atmel/ld/Makefile.in 2007-02-20 16:07:38.000000000 +0100
+@@ -145,6 +145,7 @@ EMUL_EXTRA_OFILES = @EMUL_EXTRA_OFILES@
+ EXEEXT = @EXEEXT@
+ GMOFILES = @GMOFILES@
+ GMSGFMT = @GMSGFMT@
++GREP = @GREP@
+ GT_NO = @GT_NO@
+ GT_YES = @GT_YES@
+ HDEFINES = @HDEFINES@
+@@ -213,9 +214,8 @@ VERSION = @VERSION@
+ WARN_CFLAGS = @WARN_CFLAGS@
+ XGETTEXT = @XGETTEXT@
+ YACC = `if [ -f ../bison/bison ]; then echo ../bison/bison -y -L$(srcdir)/../bison/; else echo @YACC@; fi`
++YFLAGS = -d
+ ac_ct_CC = @ac_ct_CC@
+-ac_ct_RANLIB = @ac_ct_RANLIB@
+-ac_ct_STRIP = @ac_ct_STRIP@
+ am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+ am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+ am__include = @am__include@
+@@ -232,6 +232,7 @@ build_vendor = @build_vendor@
+ datadir = @datadir@
+ datarootdir = @datarootdir@
+ docdir = @docdir@
++dvidir = @dvidir@
+ exec_prefix = @exec_prefix@
+ host = @host@
+ host_alias = @host_alias@
+@@ -245,12 +246,15 @@ install_sh = @install_sh@
+ l = @l@
+ libdir = @libdir@
+ libexecdir = @libexecdir@
++localedir = @localedir@
+ localstatedir = @localstatedir@
+ mandir = @mandir@
+ mkdir_p = @mkdir_p@
+ oldincludedir = @oldincludedir@
++pdfdir = @pdfdir@
+ prefix = @prefix@
+ program_transform_name = @program_transform_name@
++psdir = @psdir@
+ sbindir = @sbindir@
+ sharedstatedir = @sharedstatedir@
+ sysconfdir = @sysconfdir@
+@@ -263,7 +267,6 @@ use_sysroot = @use_sysroot@
+ AUTOMAKE_OPTIONS = cygnus dejagnu
+ SUBDIRS = po
+ tooldir = $(exec_prefix)/$(target_alias)
+-YFLAGS = -d
+ AM_CFLAGS = $(WARN_CFLAGS)
+ # We put the scripts in the directory $(scriptdir)/ldscripts.
+@@ -357,6 +360,9 @@ ALL_EMULATIONS = \
+       eavr3.o \
+       eavr4.o \
+       eavr5.o \
++      eavr32elf_ap7000.o \
++      eavr32elf_uc3a0512.o \
++      eavr32linux.o \
+       ecoff_i860.o \
+       ecoff_sparc.o \
+       ecrisaout.o \
+@@ -878,10 +884,13 @@ dist-info: $(INFO_DEPS)
+           $(srcdir)/*) base=`echo "$$base" | sed "s|^$$srcdirstrip/||"`;; \
+         esac; \
+         if test -f $$base; then d=.; else d=$(srcdir); fi; \
+-        for file in $$d/$$base*; do \
+-          relfile=`expr "$$file" : "$$d/\(.*\)"`; \
+-          test -f $(distdir)/$$relfile || \
+-            cp -p $$file $(distdir)/$$relfile; \
++        base_i=`echo "$$base" | sed 's|\.info$$||;s|$$|.i|'`; \
++        for file in $$d/$$base $$d/$$base-[0-9] $$d/$$base-[0-9][0-9] $$d/$$base_i[0-9] $$d/$$base_i[0-9][0-9]; do \
++          if test -f $$file; then \
++            relfile=`expr "$$file" : "$$d/\(.*\)"`; \
++            test -f $(distdir)/$$relfile || \
++              cp -p $$file $(distdir)/$$relfile; \
++          else :; fi; \
+         done; \
+       done
+@@ -1406,6 +1415,15 @@ eavr5.c: $(srcdir)/emulparams/avr5.sh \
+   $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/avr.sc \
+   ${GEN_DEPENDS}
+       ${GENSCRIPTS} avr5 "$(tdir_avr2)"
++eavr32elf_ap7000.c: $(srcdir)/emulparams/avr32elf_ap7000.sh \
++  $(srcdir)/emultempl/elf32.em $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}
++      ${GENSCRIPTS} avr32elf_ap7000 "$(tdir_avr32)"
++eavr32elf_uc3a0512.c: $(srcdir)/emulparams/avr32elf_uc3a0512.sh \
++  $(srcdir)/emultempl/elf32.em $(srcdir)/scripttempl/elf_xip.sc ${GEN_DEPENDS}
++      ${GENSCRIPTS} avr32elf_uc3a0512 "$(tdir_avr32)"
++eavr32linux.c: $(srcdir)/emulparams/avr32linux.sh \
++  $(srcdir)/emultempl/elf32.em $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS}
++      ${GENSCRIPTS} avr32linux "$(tdir_avr32)"
+ ecoff_i860.c: $(srcdir)/emulparams/coff_i860.sh \
+   $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/i860coff.sc ${GEN_DEPENDS}
+       ${GENSCRIPTS} coff_i860 "$(tdir_coff_i860)"
+@@ -2587,7 +2605,9 @@ install-exec-local: ld-new$(EXEEXT)
+         || $(LIBTOOL) --mode=install $(INSTALL_PROGRAM) ld-new$(EXEEXT) $(DESTDIR)$(tooldir)/bin/ld$(EXEEXT); \
+       fi
+-install-data-local:
++# We want install to imply install-info as per GNU standards, despite the
++# cygnus option.
++install-data-local: install-info
+       $(mkinstalldirs) $(DESTDIR)$(scriptdir)/ldscripts
+       for f in ldscripts/*; do \
+         $(INSTALL_DATA) $$f $(DESTDIR)$(scriptdir)/$$f ; \
+diff -Nrup binutils-2.17/ld/scripttempl/elf_xip.sc binutils-2.17-atmel/ld/scripttempl/elf_xip.sc
+--- binutils-2.17/ld/scripttempl/elf_xip.sc    1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/ld/scripttempl/elf_xip.sc      2006-08-04 14:51:49.000000000 +0200
+@@ -0,0 +1,456 @@
++#
++# Unusual variables checked by this code:
++#     NOP - four byte opcode for no-op (defaults to 0)
++#     NO_SMALL_DATA - no .sbss/.sbss2/.sdata/.sdata2 sections if not
++#             empty.
++#     SMALL_DATA_CTOR - .ctors contains small data.
++#     SMALL_DATA_DTOR - .dtors contains small data.
++#     DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
++#     INITIAL_READONLY_SECTIONS - at start of text segment
++#     OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
++#             (e.g., .PARISC.milli)
++#     OTHER_TEXT_SECTIONS - these get put in .text when relocating
++#     OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
++#             (e.g., .PARISC.global)
++#     OTHER_RELRO_SECTIONS - other than .data.rel.ro ...
++#             (e.g. PPC32 .fixup, .got[12])
++#     OTHER_BSS_SECTIONS - other than .bss .sbss ...
++#     OTHER_SECTIONS - at the end
++#     EXECUTABLE_SYMBOLS - symbols that must be defined for an
++#             executable (e.g., _DYNAMIC_LINK)
++#       TEXT_START_ADDR - the first byte of the text segment, after any
++#               headers.
++#       TEXT_BASE_ADDRESS - the first byte of the text segment.
++#     TEXT_START_SYMBOLS - symbols that appear at the start of the
++#             .text section.
++#     DATA_START_SYMBOLS - symbols that appear at the start of the
++#             .data section.
++#     OTHER_GOT_SYMBOLS - symbols defined just before .got.
++#     OTHER_GOT_SECTIONS - sections just after .got.
++#     OTHER_SDATA_SECTIONS - sections just after .sdata.
++#     OTHER_BSS_SYMBOLS - symbols that appear at the start of the
++#             .bss section besides __bss_start.
++#     DATA_PLT - .plt should be in data segment, not text segment.
++#     PLT_BEFORE_GOT - .plt just before .got when .plt is in data segement.
++#     BSS_PLT - .plt should be in bss segment
++#     TEXT_DYNAMIC - .dynamic in text segment, not data segment.
++#     EMBEDDED - whether this is for an embedded system.
++#     SHLIB_TEXT_START_ADDR - if set, add to SIZEOF_HEADERS to set
++#             start address of shared library.
++#     INPUT_FILES - INPUT command of files to always include
++#     WRITABLE_RODATA - if set, the .rodata section should be writable
++#     INIT_START, INIT_END -  statements just before and just after
++#     combination of .init sections.
++#     FINI_START, FINI_END - statements just before and just after
++#     combination of .fini sections.
++#     STACK_ADDR - start of a .stack section.
++#     OTHER_END_SYMBOLS - symbols to place right at the end of the script.
++#     SEPARATE_GOTPLT - if set, .got.plt should be separate output section,
++#             so that .got can be in the RELRO area.  It should be set to
++#             the number of bytes in the beginning of .got.plt which can be
++#             in the RELRO area as well.
++#
++# When adding sections, do note that the names of some sections are used
++# when specifying the start address of the next.
++#
++
++#  Many sections come in three flavours.  There is the 'real' section,
++#  like ".data".  Then there are the per-procedure or per-variable
++#  sections, generated by -ffunction-sections and -fdata-sections in GCC,
++#  and useful for --gc-sections, which for a variable "foo" might be
++#  ".data.foo".  Then there are the linkonce sections, for which the linker
++#  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".
++#  The exact correspondences are:
++#
++#  Section    Linkonce section
++#  .text      .gnu.linkonce.t.foo
++#  .rodata    .gnu.linkonce.r.foo
++#  .data      .gnu.linkonce.d.foo
++#  .bss               .gnu.linkonce.b.foo
++#  .sdata     .gnu.linkonce.s.foo
++#  .sbss      .gnu.linkonce.sb.foo
++#  .sdata2    .gnu.linkonce.s2.foo
++#  .sbss2     .gnu.linkonce.sb2.foo
++#  .debug_info        .gnu.linkonce.wi.foo
++#  .tdata     .gnu.linkonce.td.foo
++#  .tbss      .gnu.linkonce.tb.foo
++#
++#  Each of these can also have corresponding .rel.* and .rela.* sections.
++
++test -z "$ENTRY" && ENTRY=_start
++test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
++test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
++if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
++test -z "${ELFSIZE}" && ELFSIZE=32
++test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
++test "$LD_FLAG" = "N" && DATA_ADDR=.
++test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
++test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
++test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
++if test -n "$RELOCATING"; then
++  RO_REGION="${RO_VMA_REGION+ >}${RO_VMA_REGION}${RO_LMA_REGION+ AT>}${RO_LMA_REGION}"
++  RW_REGION="${RW_VMA_REGION+ >}${RW_VMA_REGION}${RW_LMA_REGION+ AT>}${RW_LMA_REGION}"
++else
++  RO_REGION=""
++  RW_REGION=""
++fi
++INTERP=".interp       ${RELOCATING-0} : { *(.interp) }${RO_REGION}"
++PLT=".plt          ${RELOCATING-0} : { *(.plt) }"
++if test -z "$GOT"; then
++  if test -z "$SEPARATE_GOTPLT"; then
++    GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.got) }"
++  else
++    GOT=".got          ${RELOCATING-0} : { *(.got) }"
++    GOTPLT="${RELOCATING+${DATA_SEGMENT_RELRO_GOTPLT_END}}
++  .got.plt      ${RELOCATING-0} : { *(.got.plt) }"
++  fi
++fi
++DALIGN=".dalign       : { . = ALIGN(${DATA_SEGMENT_ALIGN}); PROVIDE(_data_lma = .); }${RO_REGION}"
++BALIGN=".balign       : { . = ALIGN(${BSS_ALIGNMENT}); _edata = .; }${RW_REGION}"
++DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
++RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
++DATARELRO=".data.rel.ro : { *(.data.rel.ro.local) *(.data.rel.ro*) }${RW_REGION}"
++STACKNOTE="/DISCARD/ : { *(.note.GNU-stack) }"
++if test -z "${NO_SMALL_DATA}"; then
++  SBSS=".sbss         ${RELOCATING-0} :
++  {
++    ${RELOCATING+PROVIDE (__sbss_start = .);}
++    ${RELOCATING+PROVIDE (___sbss_start = .);}
++    ${CREATE_SHLIB+*(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)}
++    *(.dynsbss)
++    *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})
++    *(.scommon)
++    ${RELOCATING+PROVIDE (__sbss_end = .);}
++    ${RELOCATING+PROVIDE (___sbss_end = .);}
++  }${RW_REGION}"
++  SBSS2=".sbss2        ${RELOCATING-0} : { *(.sbss2${RELOCATING+ .sbss2.* .gnu.linkonce.sb2.*}) }${RW_REGION}"
++  SDATA="/* We want the small data sections together, so single-instruction offsets
++     can access them all, and initialized data all before uninitialized, so
++     we can shorten the on-disk segment size.  */
++  .sdata        ${RELOCATING-0} :
++  {
++    ${RELOCATING+${SDATA_START_SYMBOLS}}
++    ${CREATE_SHLIB+*(.sdata2 .sdata2.* .gnu.linkonce.s2.*)}
++    *(.sdata${RELOCATING+ .sdata.* .gnu.linkonce.s.*})
++  }${RW_REGION}"
++  SDATA2=".sdata2       ${RELOCATING-0} : { *(.sdata2${RELOCATING+ .sdata2.* .gnu.linkonce.s2.*}) }${RW_REGION}"
++  REL_SDATA=".rel.sdata    ${RELOCATING-0} : { *(.rel.sdata${RELOCATING+ .rel.sdata.* .rel.gnu.linkonce.s.*}) }${RO_REGION}
++  .rela.sdata   ${RELOCATING-0} : { *(.rela.sdata${RELOCATING+ .rela.sdata.* .rela.gnu.linkonce.s.*}) }"
++  REL_SBSS=".rel.sbss     ${RELOCATING-0} : { *(.rel.sbss${RELOCATING+ .rel.sbss.* .rel.gnu.linkonce.sb.*}) }${RO_REGION}
++  .rela.sbss    ${RELOCATING-0} : { *(.rela.sbss${RELOCATING+ .rela.sbss.* .rela.gnu.linkonce.sb.*}) }${RO_REGION}"
++  REL_SDATA2=".rel.sdata2   ${RELOCATING-0} : { *(.rel.sdata2${RELOCATING+ .rel.sdata2.* .rel.gnu.linkonce.s2.*}) }${RO_REGION}
++  .rela.sdata2  ${RELOCATING-0} : { *(.rela.sdata2${RELOCATING+ .rela.sdata2.* .rela.gnu.linkonce.s2.*}) }${RO_REGION}"
++  REL_SBSS2=".rel.sbss2    ${RELOCATING-0} : { *(.rel.sbss2${RELOCATING+ .rel.sbss2.* .rel.gnu.linkonce.sb2.*}) }${RO_REGION}
++  .rela.sbss2   ${RELOCATING-0} : { *(.rela.sbss2${RELOCATING+ .rela.sbss2.* .rela.gnu.linkonce.sb2.*}) }${RO_REGION}"
++else
++  NO_SMALL_DATA=" "
++fi
++test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
++CTOR=".ctors        ${CONSTRUCTING-0} :
++  {
++    ${CONSTRUCTING+${CTOR_START}}
++    /* gcc uses crtbegin.o to find the start of
++       the constructors, so we make sure it is
++       first.  Because this is a wildcard, it
++       doesn't matter if the user does not
++       actually link against crtbegin.o; the
++       linker won't look for a file to match a
++       wildcard.  The wildcard also means that it
++       doesn't matter which directory crtbegin.o
++       is in.  */
++
++    KEEP (*crtbegin*.o(.ctors))
++
++    /* We don't want to include the .ctor section from
++       from the crtend.o file until after the sorted ctors.
++       The .ctor section from the crtend file contains the
++       end of ctors marker and it must be last */
++
++    KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .ctors))
++    KEEP (*(SORT(.ctors.*)))
++    KEEP (*(.ctors))
++    ${CONSTRUCTING+${CTOR_END}}
++  }"
++DTOR=".dtors        ${CONSTRUCTING-0} :
++  {
++    ${CONSTRUCTING+${DTOR_START}}
++    KEEP (*crtbegin*.o(.dtors))
++    KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .dtors))
++    KEEP (*(SORT(.dtors.*)))
++    KEEP (*(.dtors))
++    ${CONSTRUCTING+${DTOR_END}}
++  }"
++STACK=".stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
++  {
++    ${RELOCATING+_stack = .;}
++    *(.stack)
++    ${RELOCATING+${STACK_SIZE+. = ${STACK_SIZE};}}
++    ${RELOCATING+_estack = .;}
++  }${RW_REGION}"
++
++# if this is for an embedded system, don't add SIZEOF_HEADERS.
++if [ -z "$EMBEDDED" ]; then
++   test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
++else
++   test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
++fi
++
++cat <<EOF
++OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
++            "${LITTLE_OUTPUT_FORMAT}")
++OUTPUT_ARCH(${OUTPUT_ARCH})
++ENTRY(${ENTRY})
++
++${RELOCATING+${LIB_SEARCH_DIRS}}
++${RELOCATING+/* Do we need any of these for elf?
++   __DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}}  */}
++${RELOCATING+${EXECUTABLE_SYMBOLS}}
++${RELOCATING+${INPUT_FILES}}
++${RELOCATING- /* For some reason, the Solaris linker makes bad executables
++  if gld -r is used and the intermediate file has sections starting
++  at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
++  bug.  But for now assigning the zero vmas works.  */}
++
++${RELOCATING+${MEMORY}}
++
++SECTIONS
++{
++  /* Read-only sections, merged into text segment: */
++  ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
++  ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
++  ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
++  ${CREATE_SHLIB-${INTERP}}
++  ${INITIAL_READONLY_SECTIONS}
++  ${TEXT_DYNAMIC+${DYNAMIC}${RO_REGION}}
++  .hash         ${RELOCATING-0} : { *(.hash) }${RO_REGION}
++  .dynsym       ${RELOCATING-0} : { *(.dynsym) }${RO_REGION}
++  .dynstr       ${RELOCATING-0} : { *(.dynstr) }${RO_REGION}
++  .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }${RO_REGION}
++  .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }${RO_REGION}
++  .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }${RO_REGION}
++
++EOF
++if [ "x$COMBRELOC" = x ]; then
++  COMBRELOCCAT=cat
++else
++  COMBRELOCCAT="cat > $COMBRELOC"
++fi
++eval $COMBRELOCCAT <<EOF
++  .rel.init     ${RELOCATING-0} : { *(.rel.init) }${RO_REGION}
++  .rela.init    ${RELOCATING-0} : { *(.rela.init) }${RO_REGION}
++  .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }${RO_REGION}
++  .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }${RO_REGION}
++  .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }${RO_REGION}
++  .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }${RO_REGION}
++  .rel.rodata   ${RELOCATING-0} : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }${RO_REGION}
++  .rela.rodata  ${RELOCATING-0} : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }${RO_REGION}
++  ${OTHER_READONLY_RELOC_SECTIONS}
++  .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+*}) }${RO_REGION}
++  .rela.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+*}) }${RO_REGION}
++  .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }${RO_REGION}
++  .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }${RO_REGION}
++  .rel.tdata  ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }${RO_REGION}
++  .rela.tdata ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }${RO_REGION}
++  .rel.tbss   ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }${RO_REGION}
++  .rela.tbss  ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }${RO_REGION}
++  .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }${RO_REGION}
++  .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }${RO_REGION}
++  .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }${RO_REGION}
++  .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }${RO_REGION}
++  .rel.got      ${RELOCATING-0} : { *(.rel.got) }${RO_REGION}
++  .rela.got     ${RELOCATING-0} : { *(.rela.got) }${RO_REGION}
++  ${OTHER_GOT_RELOC_SECTIONS}
++  ${REL_SDATA}
++  ${REL_SBSS}
++  ${REL_SDATA2}
++  ${REL_SBSS2}
++  .rel.bss      ${RELOCATING-0} : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }${RO_REGION}
++  .rela.bss     ${RELOCATING-0} : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }${RO_REGION}
++EOF
++if [ -n "$COMBRELOC" ]; then
++cat <<EOF
++  .rel.dyn      ${RELOCATING-0} :
++    {
++EOF
++sed -e '/^[   ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC
++cat <<EOF
++    }${RO_REGION}
++  .rela.dyn     ${RELOCATING-0} :
++    {
++EOF
++sed -e '/^[   ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC
++cat <<EOF
++    }${RO_REGION}
++EOF
++fi
++cat <<EOF
++  .rel.plt      ${RELOCATING-0} : { *(.rel.plt) }${RO_REGION}
++  .rela.plt     ${RELOCATING-0} : { *(.rela.plt) }${RO_REGION}
++  ${OTHER_PLT_RELOC_SECTIONS}
++
++  .init         ${RELOCATING-0} :
++  {
++    ${RELOCATING+${INIT_START}}
++    KEEP (*(.init))
++    ${RELOCATING+${INIT_END}}
++  }${RO_REGION} =${NOP-0}
++
++  ${DATA_PLT-${BSS_PLT-${PLT}${RO_REGION}}}
++  .text         ${RELOCATING-0} :
++  {
++    ${RELOCATING+${TEXT_START_SYMBOLS}}
++    *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
++    KEEP (*(.text.*personality*))
++    /* .gnu.warning sections are handled specially by elf32.em.  */
++    *(.gnu.warning)
++    ${RELOCATING+${OTHER_TEXT_SECTIONS}}
++  }${RO_REGION} =${NOP-0}
++  .fini         ${RELOCATING-0} :
++  {
++    ${RELOCATING+${FINI_START}}
++    KEEP (*(.fini))
++    ${RELOCATING+${FINI_END}}
++  }${RO_REGION} =${NOP-0}
++  ${RELOCATING+PROVIDE (__etext = .);}
++  ${RELOCATING+PROVIDE (_etext = .);}
++  ${RELOCATING+PROVIDE (etext = .);}
++  ${WRITABLE_RODATA-${RODATA}${RO_REGION}}
++  .rodata1      ${RELOCATING-0} : { *(.rodata1) }${RO_REGION}
++  ${CREATE_SHLIB-${SDATA2}}
++  ${CREATE_SHLIB-${SBSS2}}
++  ${OTHER_READONLY_SECTIONS}
++  .eh_frame_hdr : { *(.eh_frame_hdr) }${RO_REGION}
++  .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }${RO_REGION}
++  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }${RO_REGION}
++
++  ${RELOCATING+${DALIGN}}
++  ${RELOCATING+PROVIDE (_data = ORIGIN(${RW_VMA_REGION}));}
++  . = ORIGIN(${RW_VMA_REGION});
++  /* Exception handling  */
++  .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }${RW_REGION}
++  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }${RW_REGION}
++
++  /* Thread Local Storage sections  */
++  .tdata      ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }${RW_REGION}
++  .tbss               ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }${RW_REGION}
++
++  /* Ensure the __preinit_array_start label is properly aligned.  We
++     could instead move the label definition inside the section, but
++     the linker would then create the section even if it turns out to
++     be empty, which isn't pretty.  */
++  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_start = ALIGN(${ALIGNMENT}));}}
++  .preinit_array   ${RELOCATING-0} : { KEEP (*(.preinit_array)) }${RW_REGION}
++  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_end = .);}}
++
++  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_start = .);}}
++  .init_array   ${RELOCATING-0} : { KEEP (*(.init_array)) }${RW_REGION}
++  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_end = .);}}
++
++  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_start = .);}}
++  .fini_array   ${RELOCATING-0} : { KEEP (*(.fini_array)) }${RW_REGION}
++  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_end = .);}}
++
++  ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}${RW_REGION}}}
++  ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}${RW_REGION}}}
++  .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }${RW_REGION}
++
++  ${RELOCATING+${DATARELRO}}
++  ${OTHER_RELRO_SECTIONS}
++  ${TEXT_DYNAMIC-${DYNAMIC}${RW_REGION}}
++  ${NO_SMALL_DATA+${RELRO_NOW+${GOT}${RW_REGION}}}
++  ${NO_SMALL_DATA+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}${RW_REGION}}}}
++  ${NO_SMALL_DATA+${RELRO_NOW-${SEPARATE_GOTPLT+${GOTPLT}${RW_REGION}}}}
++  ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
++  ${NO_SMALL_DATA+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}${RW_REGION}}}}
++
++  ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}${RW_REGION}}}
++
++  .data         ${RELOCATING-0} :
++  {
++    ${RELOCATING+${DATA_START_SYMBOLS}}
++    *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
++    KEEP (*(.gnu.linkonce.d.*personality*))
++    ${CONSTRUCTING+SORT(CONSTRUCTORS)}
++  }${RW_REGION}
++  .data1        ${RELOCATING-0} : { *(.data1) }${RW_REGION}
++  ${WRITABLE_RODATA+${RODATA}${RW_REGION}}
++  ${OTHER_READWRITE_SECTIONS}
++  ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}${RW_REGION}}}
++  ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}${RW_REGION}}}
++  ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}${RW_REGION}}}
++  ${RELOCATING+${OTHER_GOT_SYMBOLS}}
++  ${NO_SMALL_DATA-${GOT}${RW_REGION}}
++  ${OTHER_GOT_SECTIONS}
++  ${SDATA}
++  ${OTHER_SDATA_SECTIONS}
++  ${RELOCATING+${BALIGN}}
++  ${RELOCATING+_edata = .;}
++  ${RELOCATING+PROVIDE (edata = .);}
++  ${RELOCATING+__bss_start = .;}
++  ${RELOCATING+${OTHER_BSS_SYMBOLS}}
++  ${SBSS}
++  ${BSS_PLT+${PLT}${RW_REGION}}
++  .bss          ${RELOCATING-0} :
++  {
++   *(.dynbss)
++   *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
++   *(COMMON)
++   /* Align here to ensure that the .bss section occupies space up to
++      _end.  Align after .bss to ensure correct alignment even if the
++      .bss section disappears because there are no input sections.  */
++   ${RELOCATING+. = ALIGN(${BSS_ALIGNMENT});}
++  }${RW_REGION}
++  ${OTHER_BSS_SECTIONS}
++  ${RELOCATING+. = ALIGN(${BSS_ALIGNMENT});}
++  ${RELOCATING+_end = .;}
++  ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
++  ${RELOCATING+PROVIDE (end = .);}
++  ${RELOCATING+${DATA_SEGMENT_END}}
++
++  /* Stabs debugging sections.  */
++  .stab          0 : { *(.stab) }
++  .stabstr       0 : { *(.stabstr) }
++  .stab.excl     0 : { *(.stab.excl) }
++  .stab.exclstr  0 : { *(.stab.exclstr) }
++  .stab.index    0 : { *(.stab.index) }
++  .stab.indexstr 0 : { *(.stab.indexstr) }
++
++  .comment       0 : { *(.comment) }
++
++  /* DWARF debug sections.
++     Symbols in the DWARF debugging sections are relative to the beginning
++     of the section so we begin them at 0.  */
++
++  /* DWARF 1 */
++  .debug          0 : { *(.debug) }
++  .line           0 : { *(.line) }
++
++  /* GNU DWARF 1 extensions */
++  .debug_srcinfo  0 : { *(.debug_srcinfo) }
++  .debug_sfnames  0 : { *(.debug_sfnames) }
++
++  /* DWARF 1.1 and DWARF 2 */
++  .debug_aranges  0 : { *(.debug_aranges) }
++  .debug_pubnames 0 : { *(.debug_pubnames) }
++
++  /* DWARF 2 */
++  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
++  .debug_abbrev   0 : { *(.debug_abbrev) }
++  .debug_line     0 : { *(.debug_line) }
++  .debug_frame    0 : { *(.debug_frame) }
++  .debug_str      0 : { *(.debug_str) }
++  .debug_loc      0 : { *(.debug_loc) }
++  .debug_macinfo  0 : { *(.debug_macinfo) }
++
++  /* SGI/MIPS DWARF 2 extensions */
++  .debug_weaknames 0 : { *(.debug_weaknames) }
++  .debug_funcnames 0 : { *(.debug_funcnames) }
++  .debug_typenames 0 : { *(.debug_typenames) }
++  .debug_varnames  0 : { *(.debug_varnames) }
++
++  ${STACK_ADDR+${STACK}}
++  ${OTHER_SECTIONS}
++  ${RELOCATING+${OTHER_END_SYMBOLS}}
++  ${RELOCATING+${STACKNOTE}}
++}
++EOF
+diff -Nrup binutils-2.17/ld/testsuite/ld-auto-import/client.c binutils-2.17-atmel/ld/testsuite/ld-auto-import/client.c
+--- binutils-2.17/ld/testsuite/ld-auto-import/client.c 2002-12-18 17:05:10.000000000 +0100
++++ binutils-2.17-atmel/ld/testsuite/ld-auto-import/client.c   2006-08-04 14:21:01.000000000 +0200
+@@ -1,55 +1,55 @@
+-#include <stdio.h>\r
+-\r
+-extern int var;\r
+-extern void (*func_ptr)(void);\r
+-extern void print_var (void);\r
+-extern void print_foo (void);\r
+-extern int foo;\r
+-extern int var2[2];\r
+-\r
+-typedef struct\r
+-{\r
+-  int *   var;\r
+-  void (* func_ptr)(void);\r
+-}\r
+-TEST;\r
+-\r
+-TEST xyz = { &var, print_var };\r
+-\r
+-int\r
+-main (void)\r
+-{\r
+-  print_var ();\r
+-\r
+-  printf ("We see var = %d\n", var);\r
+-  printf ("Setting var = 456\n");\r
+-\r
+-  var = 456;\r
+-\r
+-  print_var ();\r
+-  printf ("We see var = %d\n\n", var);\r
+-\r
+-  var = 90;\r
+-  print_var ();\r
+-  printf ("We see var = %d\n\n", var);\r
+-\r
+-  print_foo ();\r
+-  printf ("We see foo = %d\n", foo);\r
+-  printf ("Setting foo = 19\n");\r
+-  foo = 19;\r
+-  print_foo ();\r
+-  printf ("We see foo = %d\n\n", foo);\r
+-  fflush (stdout);\r
+-\r
+-  printf ("Calling dllimported function pointer\n");\r
+-  func_ptr ();\r
+-\r
+-  printf ("Calling functions using global structure\n"); \r
+-  xyz.func_ptr ();\r
+-  * xyz.var = 40;\r
+-  xyz.func_ptr ();\r
+-\r
+-  printf ("We see var2[0] = %d\n\n", var2[0]);\r
+-\r
+-  return 0;\r
+-}\r
++#include <stdio.h>
++
++extern int var;
++extern void (*func_ptr)(void);
++extern void print_var (void);
++extern void print_foo (void);
++extern int foo;
++extern int var2[2];
++
++typedef struct
++{
++  int *   var;
++  void (* func_ptr)(void);
++}
++TEST;
++
++TEST xyz = { &var, print_var };
++
++int
++main (void)
++{
++  print_var ();
++
++  printf ("We see var = %d\n", var);
++  printf ("Setting var = 456\n");
++
++  var = 456;
++
++  print_var ();
++  printf ("We see var = %d\n\n", var);
++
++  var = 90;
++  print_var ();
++  printf ("We see var = %d\n\n", var);
++
++  print_foo ();
++  printf ("We see foo = %d\n", foo);
++  printf ("Setting foo = 19\n");
++  foo = 19;
++  print_foo ();
++  printf ("We see foo = %d\n\n", foo);
++  fflush (stdout);
++
++  printf ("Calling dllimported function pointer\n");
++  func_ptr ();
++
++  printf ("Calling functions using global structure\n"); 
++  xyz.func_ptr ();
++  * xyz.var = 40;
++  xyz.func_ptr ();
++
++  printf ("We see var2[0] = %d\n\n", var2[0]);
++
++  return 0;
++}
+diff -Nrup binutils-2.17/ld/testsuite/ld-auto-import/dll.c binutils-2.17-atmel/ld/testsuite/ld-auto-import/dll.c
+--- binutils-2.17/ld/testsuite/ld-auto-import/dll.c    2002-12-18 17:05:10.000000000 +0100
++++ binutils-2.17-atmel/ld/testsuite/ld-auto-import/dll.c      2006-08-04 14:21:01.000000000 +0200
+@@ -1,20 +1,20 @@
+-int var = 123;\r
+-int foo = 121;\r
+-\r
+-int var2[2]= { 123, 456 };\r
+-\r
+-#include <stdio.h>\r
+-\r
+-void\r
+-print_var (void)\r
+-{\r
+-  printf ("DLL sees var = %d\n", var);\r
+-}\r
+-\r
+-void\r
+-print_foo (void)\r
+-{\r
+-  printf ("DLL sees foo = %d\n", foo);\r
+-}\r
+-\r
+-void (* func_ptr)(void) = print_foo;\r
++int var = 123;
++int foo = 121;
++
++int var2[2]= { 123, 456 };
++
++#include <stdio.h>
++
++void
++print_var (void)
++{
++  printf ("DLL sees var = %d\n", var);
++}
++
++void
++print_foo (void)
++{
++  printf ("DLL sees foo = %d\n", foo);
++}
++
++void (* func_ptr)(void) = print_foo;
+diff -Nrup binutils-2.17/ld/testsuite/ld-avr32/avr32.exp binutils-2.17-atmel/ld/testsuite/ld-avr32/avr32.exp
+--- binutils-2.17/ld/testsuite/ld-avr32/avr32.exp      1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/ld/testsuite/ld-avr32/avr32.exp        2006-08-04 14:51:39.000000000 +0200
+@@ -0,0 +1,25 @@
++# Expect script for AVR32 ELF linker tests.
++#   Copyright 2004-2006 Atmel Corporation.
++#
++# This file is free software; you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation; either version 2 of the License, or
++# (at your option) any later version.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++#
++# Written by Haavard Skinnemoen (hskinnemoen@atmel.com)
++#
++
++if ![istarget avr32-*-*] {
++    return
++}
++
++run_dump_test "pcrel"
+diff -Nrup binutils-2.17/ld/testsuite/ld-avr32/pcrel.d binutils-2.17-atmel/ld/testsuite/ld-avr32/pcrel.d
+--- binutils-2.17/ld/testsuite/ld-avr32/pcrel.d        1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/ld/testsuite/ld-avr32/pcrel.d  2006-08-04 14:51:39.000000000 +0200
+@@ -0,0 +1,74 @@
++#name: AVR32 ELF PC-relative external relocs
++#source: symbols.s
++#source: ../../../gas/testsuite/gas/avr32/pcrel.s
++#ld: -T $srcdir/$subdir/pcrel.ld
++#objdump: -d
++
++.*:     file format elf.*avr32.*
++
++Disassembly of section .text:
++
++a0000000 <_start>:
++a0000000:     d7 03           nop
++a0000002:     d7 03           nop
++
++a0000004 <test_rjmp>:
++a0000004:     d7 03           nop
++a0000006:     c0 28           rjmp a000000a <test_rjmp\+0x6>
++a0000008:     d7 03           nop
++a000000a:     e0 8f 01 fb     bral a0000400 <extsym10>
++
++a000000e <test_rcall>:
++a000000e:     d7 03           nop
++a0000010 <test_rcall2>:
++a0000010:     c0 2c           rcall a0000014 <test_rcall2\+0x4>
++a0000012:     d7 03           nop
++a0000014:     ee b0 ff f6     rcall a0200000 <extsym21>
++
++a0000018 <test_branch>:
++a0000018:     c0 31           brne a000001e <test_branch\+0x6>
++a000001a:     fe 9f ff ff     bral a0000018 <test_branch>
++a000001e:     ee 90 ff f1     breq a0200000 <extsym21>
++
++a0000022 <test_lddpc>:
++a0000022:     48 30           lddpc r0,a000002c <sym1>
++a0000024:     48 20           lddpc r0,a000002c <sym1>
++a0000026:     fe f0 7f da     ld.w r0,pc\[32730\]
++      ...
++
++a000002c <sym1>:
++a000002c:     d7 03           nop
++a000002e:     d7 03           nop
++
++a0000030 <test_local>:
++a0000030:     48 20           lddpc r0,a0000038 <test_local\+0x8>
++a0000032:     48 30           lddpc r0,a000003c <test_local\+0xc>
++a0000034:     48 20           lddpc r0,a000003c <test_local\+0xc>
++a0000036:     00 00           add r0,r0
++a0000038:     d7 03           nop
++a000003a:     d7 03           nop
++a000003c:     d7 03           nop
++a000003e:     d7 03           nop
++
++Disassembly of section \.text\.init:
++a0000040 <test_inter_section>:
++a0000040:     fe b0 ff e7     rcall a000000e <test_rcall>
++a0000044:     d7 03           nop
++a0000046:     fe b0 ff e4     rcall a000000e <test_rcall>
++a000004a:     fe b0 ff e3     rcall a0000010 <test_rcall2>
++a000004e:     d7 03           nop
++a0000050:     fe b0 ff e0     rcall a0000010 <test_rcall2>
++
++Disassembly of section \.text\.pcrel10:
++
++a0000400 <extsym10>:
++a0000400:     d7 03           nop
++
++Disassembly of section \.text\.pcrel16:
++
++a0008000 <extsym16>:
++a0008000:     d7 03           nop
++
++Disassembly of section \.text\.pcrel21:
++a0200000 <extsym21>:
++a0200000:     d7 03           nop
+diff -Nrup binutils-2.17/ld/testsuite/ld-avr32/pcrel.ld binutils-2.17-atmel/ld/testsuite/ld-avr32/pcrel.ld
+--- binutils-2.17/ld/testsuite/ld-avr32/pcrel.ld       1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/ld/testsuite/ld-avr32/pcrel.ld 2006-08-04 14:51:39.000000000 +0200
+@@ -0,0 +1,23 @@
++ENTRY(_start)
++SECTIONS
++{
++      .text 0xa0000000:
++      {
++              *(.text)
++      }
++
++      .text.pcrel10 0xa0000400:
++      {
++              *(.text.pcrel10)
++      }
++
++      .text.pcrel16 0xa0008000:
++      {
++              *(.text.pcrel16)
++      }
++
++      .text.pcrel21 0xa0200000:
++      {
++              *(.text.pcrel21)
++      }
++}
+diff -Nrup binutils-2.17/ld/testsuite/ld-avr32/symbols.s binutils-2.17-atmel/ld/testsuite/ld-avr32/symbols.s
+--- binutils-2.17/ld/testsuite/ld-avr32/symbols.s      1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/ld/testsuite/ld-avr32/symbols.s        2006-08-04 14:51:39.000000000 +0200
+@@ -0,0 +1,20 @@
++      .text
++      .global _start
++_start:
++      nop
++      nop
++
++      .section .text.pcrel10,"ax"
++      .global extsym10
++extsym10:
++      nop
++
++      .section .text.pcrel16,"ax"
++      .global extsym16
++extsym16:
++      nop
++
++      .section .text.pcrel21,"ax"
++      .global extsym21
++extsym21:
++      nop
+diff -Nrup binutils-2.17/opcodes/aclocal.m4 binutils-2.17-atmel/opcodes/aclocal.m4
+--- binutils-2.17/opcodes/aclocal.m4   2005-09-30 20:05:59.000000000 +0200
++++ binutils-2.17-atmel/opcodes/aclocal.m4     2007-02-20 16:07:44.000000000 +0100
+@@ -1,4 +1,4 @@
+-# generated automatically by aclocal 1.9.5 -*- Autoconf -*-
++# generated automatically by aclocal 1.9.6 -*- Autoconf -*-
+ # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ # 2005  Free Software Foundation, Inc.
+@@ -28,7 +28,7 @@ AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api
+ # Call AM_AUTOMAKE_VERSION so it can be traced.
+ # This function is AC_REQUIREd by AC_INIT_AUTOMAKE.
+ AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
+-       [AM_AUTOMAKE_VERSION([1.9.5])])
++       [AM_AUTOMAKE_VERSION([1.9.6])])
+ # AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
+diff -Nrup binutils-2.17/opcodes/avr32-asm.c binutils-2.17-atmel/opcodes/avr32-asm.c
+--- binutils-2.17/opcodes/avr32-asm.c  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/opcodes/avr32-asm.c    2006-10-03 17:19:02.000000000 +0200
+@@ -0,0 +1,264 @@
++/* Assembler interface for AVR32.
++   Copyright 2005, 2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   This file is part of libopcodes.
++
++   This program is free software; you can redistribute it and/or
++   modify it under the terms of the GNU General Public License as
++   published by the Free Software Foundation; either version 2 of the
++   License, or (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful, but
++   WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++   General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++   02111-1307, USA.  */
++
++#include <string.h>
++
++#include "avr32-opc.h"
++#include "avr32-asm.h"
++
++/* Structure for a register hash table entry.  */
++struct reg_entry
++{
++  const char  *name;
++  int         number;
++};
++
++/* Integer Registers.  */
++static const struct reg_entry reg_table[] =
++  {
++    /* Primary names (used by the disassembler) */
++    { "r0",   0 }, { "r1",   1 }, { "r2",   2 }, { "r3",   3 },
++    { "r4",   4 }, { "r5",   5 }, { "r6",   6 }, { "r7",   7 },
++    { "r8",   8 }, { "r9",   9 }, { "r10", 10 }, { "r11", 11 },
++    { "r12", 12 }, { "sp",  13 }, { "lr",  14 }, { "pc",  15 },
++    /* Alternatives to sp, lr and pc.  */
++    { "r13", 13 }, { "r14", 14 }, { "r15", 15 },
++  };
++#define AVR32_NR_INTREGS (sizeof(reg_table)/sizeof(reg_table[0]))
++
++/* Coprocessor Registers.  */
++static const struct reg_entry cr_table[] =
++  {
++    { "cr0",   0 }, { "cr1",   1 }, { "cr2",   2 }, { "cr3",   3 },
++    { "cr4",   4 }, { "cr5",   5 }, { "cr6",   6 }, { "cr7",   7 },
++    { "cr8",   8 }, { "cr9",   9 }, { "cr10", 10 }, { "cr11", 11 },
++    { "cr12", 12 }, { "cr13", 13 }, { "cr14", 14 }, { "cr15", 15 },
++  };
++#define AVR32_NR_CPREGS (sizeof(cr_table)/sizeof(cr_table[0]))
++
++/* Floating-point Registers.  */
++static const struct reg_entry fr_table[] =
++  {
++    { "fr0",   0 }, { "fr1",   1 }, { "fr2",   2 }, { "fr3",   3 },
++    { "fr4",   4 }, { "fr5",   5 }, { "fr6",   6 }, { "fr7",   7 },
++    { "fr8",   8 }, { "fr9",   9 }, { "fr10", 10 }, { "fr11", 11 },
++    { "fr12", 12 }, { "fr13", 13 }, { "fr14", 14 }, { "fr15", 15 },
++  };
++#define AVR32_NR_FPREGS (sizeof(fr_table)/sizeof(fr_table[0]))
++
++/* PiCo Registers.  */
++static const struct reg_entry pico_table[] =
++  {
++    { "inpix2",    0 }, { "inpix1",    1 }, { "inpix0",    2 },
++    { "outpix2",   3 }, { "outpix1",   4 }, { "outpix0",   5 },
++    { "coeff0_a",  6 }, { "coeff0_b",  7 }, { "coeff1_a",  8 },
++    { "coeff1_b",  9 }, { "coeff2_a", 10 }, { "coeff2_b", 11 },
++    { "vmu0_out", 12 }, { "vmu1_out", 13 }, { "vmu2_out", 14 },
++    { "config",   15 },
++  };
++#define AVR32_NR_PICOREGS (sizeof(pico_table)/sizeof(pico_table[0]))
++
++int
++avr32_parse_intreg(const char *str)
++{
++  unsigned int i;
++
++  for (i = 0; i < AVR32_NR_INTREGS; i++)
++    {
++      if (strcasecmp(reg_table[i].name, str) == 0)
++      return reg_table[i].number;
++    }
++
++  return -1;
++}
++
++int
++avr32_parse_cpreg(const char *str)
++{
++  unsigned int i;
++
++  for (i = 0; i < AVR32_NR_CPREGS; i++)
++    {
++      if (strcasecmp(cr_table[i].name, str) == 0)
++      return cr_table[i].number;
++    }
++
++  return -1;
++}
++
++int avr32_parse_fpreg(const char *str)
++{
++  unsigned int i;
++
++  for (i = 0; i < AVR32_NR_FPREGS; i++)
++    {
++      if (strcasecmp(fr_table[i].name, str) == 0)
++      return fr_table[i].number;
++    }
++
++  return -1;
++}
++
++int avr32_parse_picoreg(const char *str)
++{
++  unsigned int i;
++
++  for (i = 0; i < AVR32_NR_PICOREGS; i++)
++    {
++      if (strcasecmp(pico_table[i].name, str) == 0)
++      return pico_table[i].number;
++    }
++
++  return -1;
++}
++
++static unsigned long
++parse_reglist(char *str, char **endptr, int (*parse_reg)(const char *))
++{
++  int reg_from, reg_to;
++  unsigned long result = 0;
++  char *p1, *p2, c;
++
++  while (*str)
++    {
++      for (p1 = str; *p1; p1++)
++      if (*p1 == ',' || *p1 == '-')
++        break;
++
++      c = *p1, *p1 = 0;
++      reg_from = parse_reg(str);
++      *p1 = c;
++
++      if (reg_from < 0)
++      break;
++
++      if (*p1 == '-')
++      {
++        for (p2 = ++p1; *p2; p2++)
++          if (*p2 == ',')
++            break;
++
++        c = *p2, *p2 = 0;
++        /* printf("going to parse reg_to from `%s'\n", p1); */
++        reg_to = parse_reg(p1);
++        *p2 = c;
++
++        if (reg_to < 0)
++          break;
++
++        while (reg_from <= reg_to)
++          result |= (1 << reg_from++);
++        p1 = p2;
++      }
++      else
++      result |= (1 << reg_from);
++
++      str = p1;
++      if (*str) ++str;
++    }
++
++  if (endptr)
++    *endptr = str;
++
++  return result;
++}
++
++unsigned long
++avr32_parse_reglist(char *str, char **endptr)
++{
++  return parse_reglist(str, endptr, avr32_parse_intreg);
++}
++
++unsigned long
++avr32_parse_cpreglist(char *str, char **endptr)
++{
++  return parse_reglist(str, endptr, avr32_parse_cpreg);
++}
++
++unsigned long
++avr32_parse_pico_reglist(char *str, char **endptr)
++{
++  return parse_reglist(str, endptr, avr32_parse_picoreg);
++}
++
++int
++avr32_make_regmask8(unsigned long regmask16, unsigned long *regmask8)
++{
++  unsigned long result = 0;
++
++  /* printf("convert regmask16 0x%04lx\n", regmask16); */
++
++  if (regmask16 & 0xf)
++    {
++      if ((regmask16 & 0xf) == 0xf)
++      result |= 1 << 0;
++      else
++      return -1;
++    }
++  if (regmask16 & 0xf0)
++    {
++      if ((regmask16 & 0xf0) == 0xf0)
++      result |= 1 << 1;
++      else
++      return -1;
++    }
++  if (regmask16 & 0x300)
++    {
++      if ((regmask16 & 0x300) == 0x300)
++      result |= 1 << 2;
++      else
++      return -1;
++    }
++  if (regmask16 & (1 << 13))
++    return -1;
++
++  if (regmask16 & (1 << 10))
++    result |= 1 << 3;
++  if (regmask16 & (1 << 11))
++    result |= 1 << 4;
++  if (regmask16 & (1 << 12))
++    result |= 1 << 5;
++  if (regmask16 & (1 << 14))
++    result |= 1 << 6;
++  if (regmask16 & (1 << 15))
++    result |= 1 << 7;
++
++  *regmask8 = result;
++
++  return 0;
++}
++
++#if 0
++struct reg_map
++{
++  const struct reg_entry      *names;
++  int                         nr_regs;
++  struct hash_control         *htab;
++  const char                  *errmsg;
++};
++
++struct reg_map all_reg_maps[] =
++  {
++    { reg_table, AVR32_NR_INTREGS, NULL, N_("integral register expected") },
++    { cr_table,  AVR32_NR_CPREGS,  NULL, N_("coprocessor register expected") },
++  };
++#endif
+diff -Nrup binutils-2.17/opcodes/avr32-asm.h binutils-2.17-atmel/opcodes/avr32-asm.h
+--- binutils-2.17/opcodes/avr32-asm.h  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/opcodes/avr32-asm.h    2006-10-03 17:19:02.000000000 +0200
+@@ -0,0 +1,42 @@
++/* Assembler interface for AVR32.
++   Copyright 2005, 2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   This file is part of libopcodes.
++
++   This program is free software; you can redistribute it and/or
++   modify it under the terms of the GNU General Public License as
++   published by the Free Software Foundation; either version 2 of the
++   License, or (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful, but
++   WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++   General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++   02111-1307, USA.  */
++#ifndef __OPCODES_AVR32_ASM_H
++#define __OPCODES_AVR32_ASM_H
++
++extern int
++avr32_parse_intreg(const char *str);
++extern int
++avr32_parse_cpreg(const char *str);
++extern int
++avr32_parse_fpreg(const char *str);
++extern int
++avr32_parse_picoreg(const char *str);
++extern unsigned long
++avr32_parse_reglist(char *str, char **endptr);
++extern unsigned long
++avr32_parse_cpreglist(char *str, char **endptr);
++extern unsigned long
++avr32_parse_pico_reglist(char *str, char **endptr);
++extern int
++avr32_make_regmask8(unsigned long regmask16, unsigned long *regmask8);
++
++#endif /* __OPCODES_AVR32_ASM_H */
+diff -Nrup binutils-2.17/opcodes/avr32-dis.c binutils-2.17-atmel/opcodes/avr32-dis.c
+--- binutils-2.17/opcodes/avr32-dis.c  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/opcodes/avr32-dis.c    2006-08-04 14:50:49.000000000 +0200
+@@ -0,0 +1,891 @@
++/* Print AVR32 instructions for GDB and objdump.
++   Copyright 2005, 2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   This file is part of libopcodes.
++
++   This program is free software; you can redistribute it and/or
++   modify it under the terms of the GNU General Public License as
++   published by the Free Software Foundation; either version 2 of the
++   License, or (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful, but
++   WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++   General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++   02111-1307, USA.  */
++
++#include "sysdep.h"
++#include "dis-asm.h"
++#include "avr32-opc.h"
++#include "opintl.h"
++#include "safe-ctype.h"
++
++/* TODO: Share this with -asm */
++
++/* Structure for a register hash table entry.  */
++struct reg_entry
++{
++  const char  *name;
++  int         number;
++};
++
++#ifndef strneq
++#define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
++#endif
++
++
++static const struct reg_entry reg_table[] =
++  {
++    /* Primary names (used by the disassembler) */
++    { "r0",   0 }, { "r1",   1 }, { "r2",   2 }, { "r3",   3 },
++    { "r4",   4 }, { "r5",   5 }, { "r6",   6 }, { "r7",   7 },
++    { "r8",   8 }, { "r9",   9 }, { "r10", 10 }, { "r11", 11 },
++    { "r12", 12 }, { "sp",  13 }, { "lr",  14 }, { "pc",  15 },
++    /* Alternatives to sp, lr and pc.  */
++    { "r13", 13 }, { "r14", 14 }, { "r15", 15 },
++  };
++#define AVR32_NR_INTREGS (sizeof(reg_table)/sizeof(reg_table[0]))
++
++/* Coprocessor Registers.  */
++static const struct reg_entry cr_table[] =
++  {
++    { "cr0",   0 }, { "cr1",   1 }, { "cr2",   2 }, { "cr3",   3 },
++    { "cr4",   4 }, { "cr5",   5 }, { "cr6",   6 }, { "cr7",   7 },
++    { "cr8",   8 }, { "cr9",   9 }, { "cr10", 10 }, { "cr11", 11 },
++    { "cr12", 12 }, { "cr13", 13 }, { "cr14", 14 }, { "cr15", 15 },
++  };
++#define AVR32_NR_CPREGS (sizeof(cr_table)/sizeof(cr_table[0]))
++
++static const char bparts[4] = { 'b', 'l', 'u', 't' };
++static bfd_vma current_pc;
++
++struct avr32_field_value
++{
++  const struct avr32_ifield *ifield;
++  unsigned long value;
++};
++
++struct avr32_operand
++{
++  int id;
++  int is_pcrel;
++  int align_order;
++  int (*print)(struct avr32_operand *op, struct disassemble_info *info,
++             struct avr32_field_value *ifields);
++};
++
++static signed long
++get_signed_value(const struct avr32_field_value *fv)
++{
++  signed long value = fv->value;
++
++  if (fv->value & (1 << (fv->ifield->bitsize - 1)))
++    value |= (~0UL << fv->ifield->bitsize);
++
++  return value;
++}
++
++static void
++print_reglist_range(unsigned int first, unsigned int last,
++                  const struct reg_entry *reg_names,
++                  int need_comma,
++                  struct disassemble_info *info)
++{
++  if (need_comma)
++    info->fprintf_func(info->stream, ",");
++
++  if (first == last)
++    info->fprintf_func(info->stream, "%s",
++                     reg_names[first].name);
++  else
++    info->fprintf_func(info->stream, "%s-%s",
++                     reg_names[first].name, reg_names[last].name);
++}
++
++static int
++print_intreg(struct avr32_operand *op,
++           struct disassemble_info *info,
++           struct avr32_field_value *ifields)
++{
++  unsigned long regid = ifields[0].value << op->align_order;
++
++  info->fprintf_func(info->stream, "%s",
++                   reg_table[regid].name);
++  return 1;
++}
++
++static int
++print_intreg_predec(struct avr32_operand *op ATTRIBUTE_UNUSED,
++                  struct disassemble_info *info,
++                  struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "--%s",
++                   reg_table[ifields[0].value].name);
++  return 1;
++}
++
++static int
++print_intreg_postinc(struct avr32_operand *op ATTRIBUTE_UNUSED,
++                   struct disassemble_info *info,
++                   struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "%s++",
++                   reg_table[ifields[0].value].name);
++  return 1;
++}
++
++static int
++print_intreg_lsl(struct avr32_operand *op ATTRIBUTE_UNUSED,
++               struct disassemble_info *info,
++               struct avr32_field_value *ifields)
++{
++  const char *rp = reg_table[ifields[0].value].name;
++  unsigned long sa = ifields[1].value;
++
++  if (sa)
++    info->fprintf_func(info->stream, "%s<<0x%lx", rp, sa);
++  else
++    info->fprintf_func(info->stream, "%s", rp);
++
++  return 2;
++}
++
++static int
++print_intreg_lsr(struct avr32_operand *op ATTRIBUTE_UNUSED,
++               struct disassemble_info *info,
++               struct avr32_field_value *ifields)
++{
++  const char *rp = reg_table[ifields[0].value].name;
++  unsigned long sa = ifields[1].value;
++
++  if (sa)
++    info->fprintf_func(info->stream, "%s>>0x%lx", rp, sa);
++  else
++    info->fprintf_func(info->stream, "%s", rp);
++
++  return 2;
++}
++
++static int
++print_intreg_bpart(struct avr32_operand *op ATTRIBUTE_UNUSED,
++                 struct disassemble_info *info,
++                 struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "%s:%c",
++                   reg_table[ifields[0].value].name,
++                   bparts[ifields[1].value]);
++  return 2;
++}
++
++static int
++print_intreg_hpart(struct avr32_operand *op ATTRIBUTE_UNUSED,
++                 struct disassemble_info *info,
++                 struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "%s:%c",
++                   reg_table[ifields[0].value].name,
++                   ifields[1].value ? 't' : 'b');
++  return 2;
++}
++
++static int
++print_intreg_sdisp(struct avr32_operand *op,
++                struct disassemble_info *info,
++                struct avr32_field_value *ifields)
++{
++  signed long disp;
++
++  disp = get_signed_value(&ifields[1]) << op->align_order;
++
++  info->fprintf_func(info->stream, "%s[%ld]",
++                   reg_table[ifields[0].value].name, disp);
++  return 2;
++}
++
++static int
++print_intreg_udisp(struct avr32_operand *op,
++                 struct disassemble_info *info,
++                 struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "%s[0x%lx]",
++                   reg_table[ifields[0].value].name,
++                   ifields[1].value << op->align_order);
++  return 2;
++}
++
++static int
++print_intreg_index(struct avr32_operand *op ATTRIBUTE_UNUSED,
++                 struct disassemble_info *info,
++                 struct avr32_field_value *ifields)
++{
++  const char *rb, *ri;
++  unsigned long sa = ifields[2].value;
++
++  rb = reg_table[ifields[0].value].name;
++  ri = reg_table[ifields[1].value].name;
++
++  if (sa)
++    info->fprintf_func(info->stream, "%s[%s<<0x%lx]", rb, ri, sa);
++  else
++    info->fprintf_func(info->stream, "%s[%s]", rb, ri);
++
++  return 3;
++}
++
++static int
++print_intreg_xindex(struct avr32_operand *op ATTRIBUTE_UNUSED,
++                  struct disassemble_info *info,
++                  struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "%s[%s:%c<<2]",
++                   reg_table[ifields[0].value].name,
++                   reg_table[ifields[1].value].name,
++                   bparts[ifields[2].value]);
++  return 3;
++}
++
++static int
++print_jmplabel(struct avr32_operand *op,
++             struct disassemble_info *info,
++             struct avr32_field_value *ifields)
++{
++  bfd_vma address, offset;
++
++  offset = get_signed_value(ifields) << op->align_order;
++  address = (current_pc & (~0UL << op->align_order)) + offset;
++
++  info->print_address_func(address, info);
++
++  return 1;
++}
++
++static int
++print_pc_disp(struct avr32_operand *op,
++            struct disassemble_info *info,
++            struct avr32_field_value *ifields)
++{
++  bfd_vma address, offset;
++
++  offset = ifields[0].value << op->align_order;
++  address = (current_pc & (~0UL << op->align_order)) + offset;
++
++  info->print_address_func(address, info);
++
++  return 1;
++}
++
++static int
++print_sp(struct avr32_operand *op ATTRIBUTE_UNUSED,
++       struct disassemble_info *info,
++       struct avr32_field_value *ifields ATTRIBUTE_UNUSED)
++{
++  info->fprintf_func(info->stream, "sp");
++  return 1;
++}
++
++static int
++print_sp_disp(struct avr32_operand *op,
++            struct disassemble_info *info,
++            struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "sp[0x%lx]",
++                   ifields[0].value << op->align_order);
++  return 1;
++}
++
++static int
++print_cpno(struct avr32_operand *op ATTRIBUTE_UNUSED,
++         struct disassemble_info *info,
++         struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "cp%lu", ifields[0].value);
++  return 1;
++}
++
++static int
++print_cpreg(struct avr32_operand *op,
++          struct disassemble_info *info,
++          struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "cr%lu",
++                   ifields[0].value << op->align_order);
++  return 1;
++}
++
++static int
++print_uconst(struct avr32_operand *op,
++           struct disassemble_info *info,
++           struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "0x%lx",
++                   ifields[0].value << op->align_order);
++  return 1;
++}
++
++static int
++print_sconst(struct avr32_operand *op,
++           struct disassemble_info *info,
++           struct avr32_field_value *ifields)
++{
++  info->fprintf_func(info->stream, "%ld",
++                   get_signed_value(ifields) << op->align_order);
++  return 1;
++}
++
++static int
++print_reglist8_head(unsigned long regmask, int *commap,
++                  struct disassemble_info *info)
++{
++  int first = -1, last, i = 0;
++  int need_comma = 0;
++
++  while (i < 12)
++    {
++      if (first == -1 && (regmask & 1))
++      {
++        first = i;
++      }
++      else if (first != -1 && !(regmask & 1))
++      {
++        last = i - 1;
++
++        print_reglist_range(first, last, reg_table, need_comma, info);
++        need_comma = 1;
++        first = -1;
++      }
++
++      if (i < 8)
++      i += 4;
++      else if (i < 10)
++      i += 2;
++      else
++      i++;
++      regmask >>= 1;
++    }
++
++  *commap = need_comma;
++  return first;
++}
++
++static void
++print_reglist8_tail(unsigned long regmask, int first, int need_comma,
++                  struct disassemble_info *info)
++{
++  int last = 11;
++
++  if (regmask & 0x20)
++    {
++      if (first == -1)
++      first = 12;
++      last = 12;
++    }
++
++  if (first != -1)
++    {
++      print_reglist_range(first, last, reg_table, need_comma, info);
++      need_comma = 1;
++      first = -1;
++    }
++
++  if (regmask & 0x40)
++    {
++      if (first == -1)
++      first = 14;
++      last = 14;
++    }
++
++  if (regmask & 0x80)
++    {
++      if (first == -1)
++      first = 15;
++      last = 15;
++    }
++
++  if (first != -1)
++    print_reglist_range(first, last, reg_table, need_comma, info);
++}
++
++static int
++print_reglist8(struct avr32_operand *op ATTRIBUTE_UNUSED,
++             struct disassemble_info *info,
++             struct avr32_field_value *ifields)
++{
++  unsigned long regmask = ifields[0].value;
++  int first, need_comma;
++
++  first = print_reglist8_head(regmask, &need_comma, info);
++  print_reglist8_tail(regmask, first, need_comma, info);
++
++  return 1;
++}
++
++static int
++print_reglist9(struct avr32_operand *op ATTRIBUTE_UNUSED,
++             struct disassemble_info *info,
++             struct avr32_field_value *ifields)
++{
++  unsigned long regmask = ifields[0].value >> 1;
++  int first, last, need_comma;
++
++  first = print_reglist8_head(regmask, &need_comma, info);
++
++  if ((ifields[0].value & 0x101) == 0x101)
++    {
++      if (first != -1)
++      {
++        last = 11;
++
++        print_reglist_range(first, last, reg_table, need_comma, info);
++        need_comma = 1;
++        first = -1;
++      }
++
++      print_reglist_range(15, 15, reg_table, need_comma, info);
++
++      regmask >>= 5;
++
++      if ((regmask & 3) == 0)
++      info->fprintf_func(info->stream, ",r12=0");
++      else if ((regmask & 3) == 1)
++      info->fprintf_func(info->stream, ",r12=1");
++      else
++      info->fprintf_func(info->stream, ",r12=-1");
++    }
++  else
++      print_reglist8_tail(regmask, first, need_comma, info);
++
++  return 1;
++}
++
++static int
++print_reglist16(struct avr32_operand *op ATTRIBUTE_UNUSED,
++              struct disassemble_info *info,
++              struct avr32_field_value *ifields)
++{
++  unsigned long regmask = ifields[0].value;
++  unsigned int i = 0, first, last;
++  int need_comma = 0;
++
++  while (i < 16)
++    {
++      if (regmask & 1)
++      {
++        first = i;
++        while (i < 16)
++          {
++            i++;
++            regmask >>= 1;
++            if (!(regmask & 1))
++              break;
++          }
++        last = i - 1;
++        print_reglist_range(first, last, reg_table, need_comma, info);
++        need_comma = 1;
++      }
++      else
++      {
++        i++;
++        regmask >>= 1;
++      }
++    }
++
++  return 1;
++}
++
++static int
++print_reglist_ldm(struct avr32_operand *op,
++                struct disassemble_info *info,
++                struct avr32_field_value *ifields)
++{
++  int rp, w_bit;
++  int i, first, last;
++  unsigned long regmask;
++
++  rp = ifields[0].value;
++  w_bit = ifields[1].value;
++  regmask = ifields[2].value;
++
++  if (regmask & (1 << AVR32_REG_PC) && rp == AVR32_REG_PC)
++    {
++      if (w_bit)
++      info->fprintf_func(info->stream, "sp++");
++      else
++      info->fprintf_func(info->stream, "sp");
++
++      for (i = 0; i < 12; )
++      {
++        if (regmask & (1 << i))
++          {
++            first = i;
++            while (i < 12)
++              {
++                i++;
++                if (!(regmask & (1 << i)))
++                  break;
++              }
++            last = i - 1;
++            print_reglist_range(first, last, reg_table, 1, info);
++          }
++        else
++          i++;
++      }
++
++      info->fprintf_func(info->stream, ",pc");
++      if (regmask & (1 << AVR32_REG_LR))
++      info->fprintf_func(info->stream, ",r12=-1");
++      else if (regmask & (1 << AVR32_REG_R12))
++      info->fprintf_func(info->stream, ",r12=1");
++      else
++      info->fprintf_func(info->stream, ",r12=0");
++    }
++  else
++    {
++      if (w_bit)
++      info->fprintf_func(info->stream, "%s++,", reg_table[rp].name);
++      else
++      info->fprintf_func(info->stream, "%s,", reg_table[rp].name);
++
++      print_reglist16(op, info, ifields + 2);
++    }
++
++  return 3;
++}
++
++static int
++print_reglist_cp8(struct avr32_operand *op ATTRIBUTE_UNUSED,
++                struct disassemble_info *info,
++                struct avr32_field_value *ifields)
++{
++  unsigned long regmask = ifields[0].value;
++  unsigned int i = 0, first, last, offset = 0;
++  int need_comma = 0;
++
++  if (ifields[1].value)
++    offset = 8;
++
++  while (i < 8)
++    {
++      if (regmask & 1)
++      {
++        first = i;
++        while (i < 8)
++          {
++            i++;
++            regmask >>= 1;
++            if (!(regmask & 1))
++              break;
++          }
++        last = i - 1;
++        print_reglist_range(offset + first, offset + last,
++                            cr_table, need_comma, info);
++        need_comma = 1;
++      }
++      else
++      {
++        i++;
++        regmask >>= 1;
++      }
++    }
++
++  return 2;
++}
++
++static int
++print_reglist_cpd8(struct avr32_operand *op ATTRIBUTE_UNUSED,
++                 struct disassemble_info *info,
++                 struct avr32_field_value *ifields)
++{
++  unsigned long regmask = ifields[0].value;
++  unsigned int i = 0, first, last;
++  int need_comma = 0;
++
++  while (i < 8)
++    {
++      if (regmask & 1)
++      {
++        first = 2 * i;
++        while (i < 8)
++          {
++            i++;
++            regmask >>= 1;
++            if (!(regmask & 1))
++              break;
++          }
++        last = 2 * (i - 1) + 1;
++        print_reglist_range(first, last, cr_table, need_comma, info);
++        need_comma = 1;
++      }
++      else
++      {
++        i++;
++        regmask >>= 1;
++      }
++    }
++
++  return 1;
++}
++
++static int
++print_retval(struct avr32_operand *op ATTRIBUTE_UNUSED,
++           struct disassemble_info *info,
++           struct avr32_field_value *ifields)
++{
++  unsigned long regid = ifields[0].value;
++  const char *retval;
++
++  if (regid < AVR32_REG_SP)
++    retval = reg_table[regid].name;
++  else if (regid == AVR32_REG_SP)
++    retval = "0";
++  else if (regid == AVR32_REG_LR)
++    retval = "-1";
++  else
++    retval = "1";
++
++  info->fprintf_func(info->stream, "%s", retval);
++
++  return 1;
++}
++
++static int
++print_mcall(struct avr32_operand *op,
++          struct disassemble_info *info,
++          struct avr32_field_value *ifields)
++{
++  unsigned long regid = ifields[0].value;
++
++  if (regid == AVR32_REG_PC)
++    print_jmplabel(op, info, ifields + 1);
++  else
++    print_intreg_sdisp(op, info, ifields);
++
++  return 2;
++}
++
++static int
++print_jospinc(struct avr32_operand *op ATTRIBUTE_UNUSED,
++            struct disassemble_info *info,
++            struct avr32_field_value *ifields)
++{
++  signed long value = ifields[0].value;
++
++  if (value >= 4)
++    value -= 8;
++  else
++    value += 1;
++
++  info->fprintf_func(info->stream, "%ld", value);
++
++  return 1;
++}
++
++static int
++print_coh(struct avr32_operand *op ATTRIBUTE_UNUSED,
++        struct disassemble_info *info,
++        struct avr32_field_value *ifields ATTRIBUTE_UNUSED)
++{
++  info->fprintf_func(info->stream, "COH");
++  return 0;
++}
++
++#define OP(name, sgn, pcrel, align, func) \
++  { AVR32_OPERAND_##name, pcrel, align, print_##func }
++
++struct avr32_operand operand[AVR32_NR_OPERANDS] =
++  {
++    OP(INTREG, 0, 0, 0, intreg),
++    OP(INTREG_PREDEC, 0, 0, 0, intreg_predec),
++    OP(INTREG_POSTINC, 0, 0, 0, intreg_postinc),
++    OP(INTREG_LSL, 0, 0, 0, intreg_lsl),
++    OP(INTREG_LSR, 0, 0, 0, intreg_lsr),
++    OP(INTREG_BSEL, 0, 0, 0, intreg_bpart),
++    OP(INTREG_HSEL, 0, 0, 1, intreg_hpart),
++    OP(INTREG_SDISP, 1, 0, 0, intreg_sdisp),
++    OP(INTREG_SDISP_H, 1, 0, 1, intreg_sdisp),
++    OP(INTREG_SDISP_W, 1, 0, 2, intreg_sdisp),
++    OP(INTREG_UDISP, 0, 0, 0, intreg_udisp),
++    OP(INTREG_UDISP_H, 0, 0, 1, intreg_udisp),
++    OP(INTREG_UDISP_W, 0, 0, 2, intreg_udisp),
++    OP(INTREG_INDEX, 0, 0, 0, intreg_index),
++    OP(INTREG_XINDEX, 0, 0, 0, intreg_xindex),
++    OP(DWREG, 0, 0, 1, intreg),
++    OP(PC_UDISP_W, 0, 1, 2, pc_disp),
++    OP(SP, 0, 0, 0, sp),
++    OP(SP_UDISP_W, 0, 0, 2, sp_disp),
++    OP(CPNO, 0, 0, 0, cpno),
++    OP(CPREG, 0, 0, 0, cpreg),
++    OP(CPREG_D, 0, 0, 1, cpreg),
++    OP(UNSIGNED_CONST, 0, 0, 0, uconst),
++    OP(UNSIGNED_CONST_W, 0, 0, 2, uconst),
++    OP(SIGNED_CONST, 1, 0, 0, sconst),
++    OP(SIGNED_CONST_W, 1, 0, 2, sconst),
++    OP(JMPLABEL, 1, 1, 1, jmplabel),
++    OP(UNSIGNED_NUMBER, 0, 0, 0, uconst),
++    OP(UNSIGNED_NUMBER_W, 0, 0, 2, uconst),
++    OP(REGLIST8, 0, 0, 0, reglist8),
++    OP(REGLIST9, 0, 0, 0, reglist9),
++    OP(REGLIST16, 0, 0, 0, reglist16),
++    OP(REGLIST_LDM, 0, 0, 0, reglist_ldm),
++    OP(REGLIST_CP8, 0, 0, 0, reglist_cp8),
++    OP(REGLIST_CPD8, 0, 0, 0, reglist_cpd8),
++    OP(RETVAL, 0, 0, 0, retval),
++    OP(MCALL, 1, 0, 2, mcall),
++    OP(JOSPINC, 0, 0, 0, jospinc),
++    OP(COH, 0, 0, 0, coh),
++  };
++
++static void
++print_opcode(bfd_vma insn_word, const struct avr32_opcode *opc,
++           bfd_vma pc, struct disassemble_info *info)
++{
++  const struct avr32_syntax *syntax = opc->syntax;
++  struct avr32_field_value fields[AVR32_MAX_FIELDS];
++  unsigned int i, next_field = 0, nr_operands;
++
++  for (i = 0; i < opc->nr_fields; i++)
++    {
++      opc->fields[i]->extract(opc->fields[i], &insn_word, &fields[i].value);
++      fields[i].ifield = opc->fields[i];
++    }
++
++  current_pc = pc;
++  info->fprintf_func(info->stream, "%s", syntax->mnemonic->name);
++
++  if (syntax->nr_operands < 0)
++    nr_operands = (unsigned int) -syntax->nr_operands;
++  else
++    nr_operands = (unsigned int) syntax->nr_operands;
++
++  for (i = 0; i < nr_operands; i++)
++    {
++      struct avr32_operand *op = &operand[syntax->operand[i]];
++
++      if (i)
++      info->fprintf_func(info->stream, ",");
++      else
++      info->fprintf_func(info->stream, " ");
++      next_field += op->print(op, info, &fields[next_field]);
++    }
++}
++
++static const struct avr32_opcode *
++find_opcode(bfd_vma insn_word)
++{
++  int i;
++
++  for (i = 0; i < AVR32_NR_OPCODES; i++)
++    {
++      const struct avr32_opcode *opc = &avr32_opc_table[i];
++
++      if ((insn_word & opc->mask) == opc->value)
++      return opc;
++    }
++
++  return NULL;
++}
++
++static int
++read_insn_word(bfd_vma pc, bfd_vma *valuep,
++             struct disassemble_info *info)
++{
++  bfd_byte b[4];
++  int status;
++
++  status = info->read_memory_func(pc, b, 4, info);
++  if (status)
++    {
++      status = info->read_memory_func(pc, b, 2, info);
++      if (status)
++      {
++        info->memory_error_func(status, pc, info);
++        return -1;
++      }
++      b[3] = b[2] = 0;
++    }
++
++  *valuep =  (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
++  return 0;
++}
++
++/* Parse an individual disassembler option.  */
++
++void
++parse_avr32_disassembler_option (option)
++     char * option;
++{
++  if (option == NULL)
++    return;
++
++  /* XXX - should break 'option' at following delimiter.  */
++  fprintf (stderr, _("Unrecognised disassembler option: %s\n"), option);
++
++  return;
++}
++
++/* Parse the string of disassembler options, spliting it at whitespaces
++   or commas.  (Whitespace separators supported for backwards compatibility).  */
++
++static void
++parse_disassembler_options (char *options)
++{
++  if (options == NULL)
++    return;
++
++  while (*options)
++    {
++      parse_avr32_disassembler_option (options);
++
++      /* Skip forward to next seperator.  */
++      while ((*options) && (! ISSPACE (*options)) && (*options != ','))
++      ++ options;
++      /* Skip forward past seperators.  */
++      while (ISSPACE (*options) || (*options == ','))
++      ++ options;
++    }
++}
++
++int
++print_insn_avr32(bfd_vma pc, struct disassemble_info *info)
++{
++  bfd_vma insn_word;
++  const struct avr32_opcode *opc;
++
++  if (info->disassembler_options)
++    {
++      parse_disassembler_options (info->disassembler_options);
++
++      /* To avoid repeated parsing of these options, we remove them here.  */
++      info->disassembler_options = NULL;
++    }
++
++  info->bytes_per_chunk = 1;
++  info->display_endian = BFD_ENDIAN_BIG;
++
++  if (read_insn_word(pc, &insn_word, info))
++    return -1;
++
++  opc = find_opcode(insn_word);
++  if (opc)
++    {
++      print_opcode(insn_word, opc, pc, info);
++      return opc->size;
++    }
++  else
++    {
++      info->fprintf_func(info->stream, _("*unknown*"));
++      return 2;
++    }
++
++}
++
++void
++print_avr32_disassembler_options (FILE *stream ATTRIBUTE_UNUSED)
++{
++
++}
+diff -Nrup binutils-2.17/opcodes/avr32-opc.c binutils-2.17-atmel/opcodes/avr32-opc.c
+--- binutils-2.17/opcodes/avr32-opc.c  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/opcodes/avr32-opc.c    2007-01-29 12:21:57.000000000 +0100
+@@ -0,0 +1,6140 @@
++/* Opcode tables for AVR32.
++   Copyright 2005, 2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   This file is part of libopcodes.
++
++   This program is free software; you can redistribute it and/or
++   modify it under the terms of the GNU General Public License as
++   published by the Free Software Foundation; either version 2 of the
++   License, or (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful, but
++   WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++   General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++   02111-1307, USA.  */
++
++#include <stdlib.h>
++#include <assert.h>
++
++#include "avr32-opc.h"
++
++#define PICO_CPNO     1
++
++void
++avr32_insert_simple(const struct avr32_ifield *field,
++                  void *buf, unsigned long value)
++{
++  bfd_vma word;
++
++  word = bfd_getb32(buf);
++  word &= ~field->mask;
++  word |= (value << field->shift) & field->mask;
++  bfd_putb32(word, buf);
++}
++
++void
++avr32_insert_bit5c(const struct avr32_ifield *field ATTRIBUTE_UNUSED,
++                 void *buf, unsigned long value)
++{
++  char *opcode = buf;
++
++  opcode[0] = (opcode[0] & 0xe1) | (value & 0x1e);
++  opcode[1] = (opcode[1] & 0xef) | ((value & 1) << 4);
++}
++
++void
++avr32_insert_k10(const struct avr32_ifield *field ATTRIBUTE_UNUSED,
++               void *buf, unsigned long value)
++{
++  char *opcode = buf;
++
++  opcode[0] = (opcode[0] & 0xf0) | ((value & 0xf0) >> 4);
++  opcode[1] = ((opcode[1] & 0x0c) | ((value & 0x0f) << 4)
++             | ((value & 0x300) >> 8));
++}
++
++void
++avr32_insert_k21(const struct avr32_ifield *field,
++               void *buf, unsigned long value)
++{
++  bfd_vma word;
++  bfd_vma k21;
++
++  word = bfd_getb32(buf);
++  word &= ~field->mask;
++  k21 = ((value & 0xffff) | ((value & 0x10000) << 4)
++       | ((value & 0x1e0000) << 8));
++  assert(!(k21 & ~field->mask));
++  word |= k21;
++  bfd_putb32(word, buf);
++}
++
++void
++avr32_insert_cpop(const struct avr32_ifield *field,
++                void *buf, unsigned long value)
++{
++  bfd_vma word;
++
++  word = bfd_getb32(buf);
++  word &= ~field->mask;
++  word |= (((value & 0x1e) << 15) | ((value & 0x60) << 20)
++         | ((value & 0x01) << 12));
++  bfd_putb32(word, buf);
++}
++
++void
++avr32_insert_k12cp(const struct avr32_ifield *field,
++                 void *buf, unsigned long value)
++{
++  bfd_vma word;
++
++  word = bfd_getb32(buf);
++  word &= ~field->mask;
++  word |= ((value & 0xf00) << 4) | (value & 0xff);
++  bfd_putb32(word, buf);
++}
++
++void avr32_extract_simple(const struct avr32_ifield *field,
++                        void *buf, unsigned long *value)
++{
++  /* XXX: The disassembler has done any necessary byteswapping already */
++  bfd_vma word = *(bfd_vma *)buf;
++
++  *value = (word & field->mask) >> field->shift;
++}
++
++void avr32_extract_bit5c(const struct avr32_ifield *field ATTRIBUTE_UNUSED,
++                       void *buf, unsigned long *value)
++{
++  bfd_vma word = *(bfd_vma *)buf;
++
++  *value = ((word >> 20) & 1) | ((word >> 24) & 0x1e);
++}
++
++void avr32_extract_k10(const struct avr32_ifield *field ATTRIBUTE_UNUSED,
++                     void *buf, unsigned long *value)
++{
++  bfd_vma word = *(bfd_vma *)buf;
++
++  *value = ((word >> 8) & 0x300) | ((word >> 20) & 0xff);
++}
++
++void avr32_extract_k21(const struct avr32_ifield *field ATTRIBUTE_UNUSED,
++                     void *buf, unsigned long *value)
++{
++  bfd_vma word = *(bfd_vma *)buf;
++
++  *value = ((word & 0xffff) | ((word >> 4) & 0x10000)
++          | ((word >> 8) & 0x1e0000));
++}
++
++void avr32_extract_cpop(const struct avr32_ifield *field ATTRIBUTE_UNUSED,
++                      void *buf, unsigned long *value)
++{
++  bfd_vma word = *(bfd_vma *)buf;
++
++  *value = (((word >> 12) & 1) | ((word >> 15) & 0x1e)
++          | ((word >> 20) & 0x60));
++}
++
++void avr32_extract_k12cp(const struct avr32_ifield *field ATTRIBUTE_UNUSED,
++                       void *buf, unsigned long *value)
++{
++  bfd_vma word = *(bfd_vma *)buf;
++
++  *value = ((word >> 4) & 0xf00) | (word & 0xff);
++}
++
++#define IFLD(id, bitsz, shift, mask, func) \
++  { AVR32_IFIELD_##id, bitsz, shift, mask, \
++    avr32_insert_##func, avr32_extract_##func }
++
++const struct avr32_ifield avr32_ifield_table[] =
++  {
++    IFLD(RX, 4, 25, 0x1e000000, simple),
++    IFLD(RY, 4, 16, 0x000f0000, simple),
++    IFLD(COND4C, 4, 20, 0x00f00000, simple),
++    IFLD(K8C, 8, 20, 0x0ff00000, simple),
++    IFLD(K7C, 7, 20, 0x07f00000, simple),
++    IFLD(K5C, 5, 20, 0x01f00000, simple),
++    IFLD(K3, 3, 20, 0x00700000, simple),
++    IFLD(RY_DW, 3, 17, 0x000e0000, simple),
++    IFLD(COND4E, 4, 8, 0x00000f00, simple),
++    IFLD(K8E, 8, 0, 0x000000ff, simple),
++    IFLD(BIT5C, 5, 20, 0x1e100000, bit5c),
++    IFLD(COND3, 3, 16, 0x00070000, simple),
++    IFLD(K10, 10, 16, 0x0ff30000, k10),
++    IFLD(POPM, 9, 19, 0x0ff80000, simple),
++    IFLD(K2, 2, 4, 0x00000030, simple),
++    IFLD(RD_E, 4, 0, 0x0000000f, simple),
++    IFLD(RD_DW, 3, 1, 0x0000000e, simple),
++    IFLD(X, 1, 5, 0x00000020, simple),
++    IFLD(Y, 1, 4, 0x00000010, simple),
++    IFLD(X2, 1, 13, 0x00002000, simple),
++    IFLD(Y2, 1, 12, 0x00001000, simple),
++    IFLD(K5E, 5, 0, 0x0000001f, simple),
++    IFLD(PART2, 2, 0, 0x00000003, simple),
++    IFLD(PART1, 1, 0, 0x00000001, simple),
++    IFLD(K16, 16, 0, 0x0000ffff, simple),
++    IFLD(CACHEOP, 5, 11, 0x0000f800, simple),
++    IFLD(K11, 11, 0, 0x000007ff, simple),
++    IFLD(K21, 21, 0, 0x1e10ffff, k21),
++    IFLD(CPOP, 7, 12, 0x060f1000, cpop),
++    IFLD(CPNO, 3, 13, 0x0000e000, simple),
++    IFLD(CRD_RI, 4, 8, 0x00000f00, simple),
++    IFLD(CRX, 4, 4, 0x000000f0, simple),
++    IFLD(CRY, 4, 0, 0x0000000f, simple),
++    IFLD(K7E, 7, 0, 0x0000007f, simple),
++    IFLD(CRD_DW, 3, 9, 0x00000e00, simple),
++    IFLD(PART1_K12, 1, 12, 0x00001000, simple),
++    IFLD(PART2_K12, 2, 12, 0x00003000, simple),
++    IFLD(K12, 12, 0, 0x00000fff, simple),
++    IFLD(S5, 5, 5, 0x000003e0, simple),
++    IFLD(K5E2, 5, 4, 0x000001f0, simple),
++    IFLD(K4, 4, 20, 0x00f00000, simple),
++    IFLD(COND4E2, 4, 4, 0x000000f0, simple),
++    IFLD(K8E2, 8, 4, 0x00000ff0, simple),
++    IFLD(K6, 6, 20, 0x03f00000, simple),
++    IFLD(MEM15, 15, 0, 0x00007fff, simple),
++    IFLD(MEMB5, 5, 15, 0x000f8000, simple),
++    IFLD(W, 1, 25, 0x02000000, simple),
++    /* Coprocessor Multiple High/Low */
++    IFLD(CM_HL, 1, 8, 0x00000100, simple),
++    IFLD(K12CP, 12 ,0, 0x0000f0ff, k12cp),
++  };
++#undef IFLD
++
++
++struct avr32_opcode avr32_opc_table[] =
++  {
++    {
++      AVR32_OPC_ABS, 2, 0x5c400000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ABS],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_ACALL, 2, 0xd0000000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_ACALL],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_ACR, 2, 0x5c000000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ACR],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ADC, 4, 0xe0000040, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_ADC],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ADD1, 2, 0x00000000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ADD1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_ADD2, 4, 0xe0000000, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_ADD2],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_ADDABS, 4, 0xe0000e40, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_ADDABS],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ADDHH_W, 4, 0xe0000e00, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_ADDHH_W],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_AND1, 2, 0x00600000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_AND1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_AND2, 4, 0xe1e00000, 0xe1f0fe00,
++      &avr32_syntax_table[AVR32_SYNTAX_AND2],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E2],
++      },
++    },
++    {
++      AVR32_OPC_AND3, 4, 0xe1e00200, 0xe1f0fe00,
++      &avr32_syntax_table[AVR32_SYNTAX_AND3],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E2],
++      },
++    },
++    {
++      AVR32_OPC_ANDH, 4, 0xe4100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ANDH],
++      BFD_RELOC_AVR32_16U, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_ANDH_COH, 4, 0xe6100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ANDH_COH],
++      BFD_RELOC_AVR32_16U, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_ANDL, 4, 0xe0100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ANDL],
++      BFD_RELOC_AVR32_16U, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_ANDL_COH, 4, 0xe2100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ANDL_COH],
++      BFD_RELOC_AVR32_16U, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_ANDN, 2, 0x00800000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ANDN],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_ASR1, 4, 0xe0000840, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_ASR1],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ASR3, 4, 0xe0001400, 0xe1f0ffe0,
++      &avr32_syntax_table[AVR32_SYNTAX_ASR3],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      },
++    },
++    {
++      AVR32_OPC_ASR2, 2, 0xa1400000, 0xe1e00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ASR2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_BIT5C],
++      },
++    },
++    {
++      AVR32_OPC_BLD, 4, 0xedb00000, 0xfff0ffe0,
++      &avr32_syntax_table[AVR32_SYNTAX_BLD],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      },
++    },
++    {
++      AVR32_OPC_BREQ1, 2, 0xc0000000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BREQ1],
++      BFD_RELOC_AVR32_9H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_BRNE1, 2, 0xc0010000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRNE1],
++      BFD_RELOC_AVR32_9H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_BRCC1, 2, 0xc0020000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRCC1],
++      BFD_RELOC_AVR32_9H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_BRCS1, 2, 0xc0030000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRCS1],
++      BFD_RELOC_AVR32_9H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_BRGE1, 2, 0xc0040000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRGE1],
++      BFD_RELOC_AVR32_9H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_BRLT1, 2, 0xc0050000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRLT1],
++      BFD_RELOC_AVR32_9H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_BRMI1, 2, 0xc0060000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRMI1],
++      BFD_RELOC_AVR32_9H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_BRPL1, 2, 0xc0070000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRPL1],
++      BFD_RELOC_AVR32_9H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_BREQ2, 4, 0xe0800000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BREQ2],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRNE2, 4, 0xe0810000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRNE2],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRCC2, 4, 0xe0820000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRHS2],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRCS2, 4, 0xe0830000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRLO2],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRGE2, 4, 0xe0840000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRGE2],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRLT2, 4, 0xe0850000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRLT2],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRMI2, 4, 0xe0860000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRMI2],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRPL2, 4, 0xe0870000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRPL2],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRLS, 4, 0xe0880000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRLS],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRGT, 4, 0xe0890000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRGT],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRLE, 4, 0xe08a0000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRLE],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRHI, 4, 0xe08b0000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRHI],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRVS, 4, 0xe08c0000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRVS],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRVC, 4, 0xe08d0000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRVC],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRQS, 4, 0xe08e0000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRQS],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BRAL, 4, 0xe08f0000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BRAL],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_BREAKPOINT, 2, 0xd6730000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_BREAKPOINT],
++      BFD_RELOC_UNUSED, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_BREV, 2, 0x5c900000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_BREV],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_BST, 4, 0xefb00000, 0xfff0ffe0,
++      &avr32_syntax_table[AVR32_SYNTAX_BST],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      },
++    },
++    {
++      AVR32_OPC_CACHE, 4, 0xf4100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_CACHE],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K11],
++      &avr32_ifield_table[AVR32_IFIELD_CACHEOP],
++      },
++    },
++    {
++      AVR32_OPC_CASTS_B, 2, 0x5c600000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_CASTS_B],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_CASTS_H, 2, 0x5c800000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_CASTS_H],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_CASTU_B, 2, 0x5c500000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_CASTU_B],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_CASTU_H, 2, 0x5c700000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_CASTU_H],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_CBR, 2, 0xa1c00000, 0xe1e00000,
++      &avr32_syntax_table[AVR32_SYNTAX_CBR],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_BIT5C],
++      },
++    },
++    {
++      AVR32_OPC_CLZ, 4, 0xe0001200, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_CLZ],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_COM, 2, 0x5cd00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_COM],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_COP, 4, 0xe1a00000, 0xf9f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_COP],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      &avr32_ifield_table[AVR32_IFIELD_CRX],
++      &avr32_ifield_table[AVR32_IFIELD_CRY],
++      &avr32_ifield_table[AVR32_IFIELD_CPOP],
++      },
++    },
++    {
++      AVR32_OPC_CP_B, 4, 0xe0001800, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_CP_B],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_CP_H, 4, 0xe0001900, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_CP_H],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_CP_W1, 2, 0x00300000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_CP_W1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_CP_W2, 2, 0x58000000, 0xfc000000,
++      &avr32_syntax_table[AVR32_SYNTAX_CP_W2],
++      BFD_RELOC_AVR32_6S, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K6],
++      },
++    },
++    {
++      AVR32_OPC_CP_W3, 4, 0xe0400000, 0xe1e00000,
++      &avr32_syntax_table[AVR32_SYNTAX_CP_W3],
++      BFD_RELOC_AVR32_21S, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_CPC1, 4, 0xe0001300, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_CPC1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_CPC2, 2, 0x5c200000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_CPC2],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_CSRF, 2, 0xd4030000, 0xfe0f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_CSRF],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K5C],
++      },
++    },
++    {
++      AVR32_OPC_CSRFCZ, 2, 0xd0030000, 0xfe0f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_CSRFCZ],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K5C],
++      },
++    },
++    {
++      AVR32_OPC_DIVS, 4, 0xe0000c00, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_DIVS],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_DIVU, 4, 0xe0000d00, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_DIVU],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_EOR1, 2, 0x00500000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_EOR1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_EOR2, 4, 0xe1e02000, 0xe1f0fe00,
++      &avr32_syntax_table[AVR32_SYNTAX_EOR2],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E2],
++      }
++    },
++    {
++      AVR32_OPC_EOR3, 4, 0xe1e02200, 0xe1f0fe00,
++      &avr32_syntax_table[AVR32_SYNTAX_EOR3],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E2],
++      }
++    },
++    {
++      AVR32_OPC_EORL, 4, 0xec100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_EORL],
++      BFD_RELOC_AVR32_16U, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_EORH, 4, 0xee100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_EORH],
++      BFD_RELOC_AVR32_16U, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_FRS, 2, 0xd7430000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_FRS],
++      BFD_RELOC_UNUSED, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_ICALL, 2, 0x5d100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ICALL],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_INCJOSP, 2, 0xd6830000, 0xff8f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_INCJOSP],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K3],
++      },
++    },
++    {
++      AVR32_OPC_LD_D1, 2, 0xa1010000, 0xe1f10000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_D1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_D2, 2, 0xa1100000, 0xe1f10000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_D2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_D3, 2, 0xa1000000, 0xe1f10000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_D3],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_D5, 4, 0xe0000200, 0xe1f0ffc1,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_D5],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_LD_D4, 4, 0xe0e00000, 0xe1f10000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_D4],
++      BFD_RELOC_AVR32_16S, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LD_SB2, 4, 0xe0000600, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_SB2],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_LD_SB1, 4, 0xe1200000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_SB1],
++      BFD_RELOC_AVR32_16S, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LD_UB1, 2, 0x01300000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UB1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_UB2, 2, 0x01700000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UB2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_UB5, 4, 0xe0000700, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UB5],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_LD_UB3, 2, 0x01800000, 0xe1800000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UB3],
++      BFD_RELOC_AVR32_3U, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K3],
++      },
++    },
++    {
++      AVR32_OPC_LD_UB4, 4, 0xe1300000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UB4],
++      BFD_RELOC_AVR32_16S, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LD_SH1, 2, 0x01100000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_SH1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_SH2, 2, 0x01500000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_SH2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_SH5, 4, 0xe0000400, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_SH5],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_LD_SH3, 2, 0x80000000, 0xe1800000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_SH3],
++      BFD_RELOC_AVR32_4UH, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K3],
++      },
++    },
++    {
++      AVR32_OPC_LD_SH4, 4, 0xe1000000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_SH4],
++      BFD_RELOC_AVR32_16S, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LD_UH1, 2, 0x01200000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UH1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_UH2, 2, 0x01600000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UH2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_UH5, 4, 0xe0000500, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UH5],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_LD_UH3, 2, 0x80800000, 0xe1800000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UH3],
++      BFD_RELOC_AVR32_4UH, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K3],
++      },
++    },
++    {
++      AVR32_OPC_LD_UH4, 4, 0xe1100000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_UH4],
++      BFD_RELOC_AVR32_16S, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LD_W1, 2, 0x01000000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_W1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_W2, 2, 0x01400000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_W2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_LD_W5, 4, 0xe0000300, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_W5],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_LD_W6, 4, 0xe0000f80, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_W6],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_LD_W3, 2, 0x60000000, 0xe0000000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_W3],
++      BFD_RELOC_AVR32_7UW, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K5C],
++      },
++    },
++    {
++      AVR32_OPC_LD_W4, 4, 0xe0f00000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LD_W4],
++      BFD_RELOC_AVR32_16S, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LDC_D1, 4, 0xe9a01000, 0xfff01100,
++      &avr32_syntax_table[AVR32_SYNTAX_LDC_D1],
++      BFD_RELOC_AVR32_10UW, 4, 3,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_LDC_D2, 4, 0xefa00050, 0xfff011ff,
++      &avr32_syntax_table[AVR32_SYNTAX_LDC_D2],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_LDC_D3, 4, 0xefa01040, 0xfff011c0,
++      &avr32_syntax_table[AVR32_SYNTAX_LDC_D3],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_LDC_W1, 4, 0xe9a00000, 0xfff01000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDC_W1],
++      BFD_RELOC_AVR32_10UW, 4, 3,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_LDC_W2, 4, 0xefa00040, 0xfff010ff,
++      &avr32_syntax_table[AVR32_SYNTAX_LDC_W2],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_LDC_W3, 4, 0xefa01000, 0xfff010c0,
++      &avr32_syntax_table[AVR32_SYNTAX_LDC_W3],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_LDC0_D, 4, 0xf3a00000, 0xfff00100,
++      &avr32_syntax_table[AVR32_SYNTAX_LDC0_D],
++      BFD_RELOC_AVR32_14UW, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K12CP],
++      },
++    },
++    {
++      AVR32_OPC_LDC0_W, 4, 0xf1a00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDC0_W],
++      BFD_RELOC_AVR32_14UW, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K12CP],
++      },
++    },
++    {
++      AVR32_OPC_LDCM_D, 4, 0xeda00400, 0xfff01f00,
++      &avr32_syntax_table[AVR32_SYNTAX_LDCM_D],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_LDCM_D_PU, 4, 0xeda01400, 0xfff01f00,
++      &avr32_syntax_table[AVR32_SYNTAX_LDCM_D_PU],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_LDCM_W, 4, 0xeda00000, 0xfff01e00,
++      &avr32_syntax_table[AVR32_SYNTAX_LDCM_W],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      &avr32_ifield_table[AVR32_IFIELD_CM_HL],
++      },
++    },
++    {
++      AVR32_OPC_LDCM_W_PU, 4, 0xeda01000, 0xfff01e00,
++      &avr32_syntax_table[AVR32_SYNTAX_LDCM_W_PU],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      &avr32_ifield_table[AVR32_IFIELD_CM_HL],
++      },
++    },
++    {
++      AVR32_OPC_LDDPC, 2, 0x48000000, 0xf8000000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDDPC],
++      BFD_RELOC_AVR32_9UW_PCREL, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K7C],
++      },
++    },
++    {
++      AVR32_OPC_LDDPC_EXT, 4, 0xfef00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDDPC_EXT],
++      BFD_RELOC_AVR32_16B_PCREL, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LDDSP, 2, 0x40000000, 0xf8000000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDDSP],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K7C],
++      },
++    },
++    {
++      AVR32_OPC_LDINS_B, 4, 0xe1d04000, 0xe1f0c000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDINS_B],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_PART2_K12],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K12],
++      },
++    },
++    {
++      AVR32_OPC_LDINS_H, 4, 0xe1d00000, 0xe1f0e000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDINS_H],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_PART1_K12],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K12],
++      },
++    },
++    {
++      AVR32_OPC_LDM, 4, 0xe1c00000, 0xfdf00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDM],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_W],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LDMTS, 4, 0xe5c00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDMTS],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LDMTS_PU, 4, 0xe7c00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDMTS_PU],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_LDSWP_SH, 4, 0xe1d02000, 0xe1f0f000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDSWP_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K12],
++      },
++    },
++    {
++      AVR32_OPC_LDSWP_UH, 4, 0xe1d03000, 0xe1f0f000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDSWP_UH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K12],
++      },
++    },
++    {
++      AVR32_OPC_LDSWP_W, 4, 0xe1d08000, 0xe1f0f000,
++      &avr32_syntax_table[AVR32_SYNTAX_LDSWP_W],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K12],
++      },
++    },
++    {
++      AVR32_OPC_LSL1, 4, 0xe0000940, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_LSL1],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_LSL3, 4, 0xe0001500, 0xe1f0ffe0,
++      &avr32_syntax_table[AVR32_SYNTAX_LSL3],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      },
++    },
++    {
++      AVR32_OPC_LSL2, 2, 0xa1600000, 0xe1e00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LSL2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_BIT5C],
++      },
++    },
++    {
++      AVR32_OPC_LSR1, 4, 0xe0000a40, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_LSR1],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_LSR3, 4, 0xe0001600, 0xe1f0ffe0,
++      &avr32_syntax_table[AVR32_SYNTAX_LSR3],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      },
++    },
++    {
++      AVR32_OPC_LSR2, 2, 0xa1800000, 0xe1e00000,
++      &avr32_syntax_table[AVR32_SYNTAX_LSR2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_BIT5C],
++      },
++    },
++    {
++      AVR32_OPC_MAC, 4, 0xe0000340, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_MAC],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MACHH_D, 4, 0xe0000580, 0xe1f0ffc1,
++      &avr32_syntax_table[AVR32_SYNTAX_MACHH_D],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MACHH_W, 4, 0xe0000480, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_MACHH_W],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MACS_D, 4, 0xe0000540, 0xe1f0fff1,
++      &avr32_syntax_table[AVR32_SYNTAX_MACS_D],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MACSATHH_W, 4, 0xe0000680, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_MACSATHH_W],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MACUD, 4, 0xe0000740, 0xe1f0fff1,
++      &avr32_syntax_table[AVR32_SYNTAX_MACUD],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MACWH_D, 4, 0xe0000c80, 0xe1f0ffe1,
++      &avr32_syntax_table[AVR32_SYNTAX_MACWH_D],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MAX, 4, 0xe0000c40, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_MAX],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MCALL, 4, 0xf0100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_MCALL],
++      BFD_RELOC_AVR32_18W_PCREL, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_MFDR, 4, 0xe5b00000, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MFDR],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MFSR, 4, 0xe1b00000, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MFSR],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MIN, 4, 0xe0000d40, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_MIN],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MOV3, 2, 0x00900000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_MOV3],
++      BFD_RELOC_NONE, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOV1, 2, 0x30000000, 0xf0000000,
++      &avr32_syntax_table[AVR32_SYNTAX_MOV1],
++      BFD_RELOC_AVR32_8S, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_MOV2, 4, 0xe0600000, 0xe1e00000,
++      &avr32_syntax_table[AVR32_SYNTAX_MOV2],
++      BFD_RELOC_AVR32_21S, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_MOVEQ1, 4, 0xe0001700, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVEQ1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVNE1, 4, 0xe0001710, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVNE1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVCC1, 4, 0xe0001720, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVHS1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVCS1, 4, 0xe0001730, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVLO1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVGE1, 4, 0xe0001740, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVGE1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVLT1, 4, 0xe0001750, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVLT1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVMI1, 4, 0xe0001760, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVMI1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVPL1, 4, 0xe0001770, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVPL1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVLS1, 4, 0xe0001780, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVLS1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVGT1, 4, 0xe0001790, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVGT1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVLE1, 4, 0xe00017a0, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVLE1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVHI1, 4, 0xe00017b0, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVHI1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVVS1, 4, 0xe00017c0, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVVS1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVVC1, 4, 0xe00017d0, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVVC1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVQS1, 4, 0xe00017e0, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVQS1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVAL1, 4, 0xe00017f0, 0xe1f0ffff,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVAL1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MOVEQ2, 4, 0xf9b00000, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVEQ2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVNE2, 4, 0xf9b00100, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVNE2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVCC2, 4, 0xf9b00200, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVHS2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVCS2, 4, 0xf9b00300, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVLO2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVGE2, 4, 0xf9b00400, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVGE2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVLT2, 4, 0xf9b00500, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVLT2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVMI2, 4, 0xf9b00600, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVMI2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVPL2, 4, 0xf9b00700, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVPL2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVLS2, 4, 0xf9b00800, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVLS2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVGT2, 4, 0xf9b00900, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVGT2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVLE2, 4, 0xf9b00a00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVLE2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVHI2, 4, 0xf9b00b00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVHI2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVVS2, 4, 0xf9b00c00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVVS2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVVC2, 4, 0xf9b00d00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVVC2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVQS2, 4, 0xf9b00e00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVQS2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MOVAL2, 4, 0xf9b00f00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MOVAL2],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MTDR, 4, 0xe7b00000, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MTDR],
++      BFD_RELOC_AVR32_8S_EXT, 2, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MTSR, 4, 0xe3b00000, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MTSR],
++      BFD_RELOC_AVR32_8S_EXT, 2, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MUL1, 2, 0xa1300000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_MUL1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_MUL2, 4, 0xe0000240, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_MUL2],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MUL3, 4, 0xe0001000, 0xe1f0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_MUL3],
++      BFD_RELOC_AVR32_8S_EXT, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_MULHH_W, 4, 0xe0000780, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_MULHH_W],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MULNHH_W, 4, 0xe0000180, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_MULNHH_W],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MULNWH_D, 4, 0xe0000280, 0xe1f0ffe1,
++      &avr32_syntax_table[AVR32_SYNTAX_MULNWH_D],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MULSD, 4, 0xe0000440, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_MULSD],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MULSATHH_H, 4, 0xe0000880, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_MULSATHH_H],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MULSATHH_W, 4, 0xe0000980, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_MULSATHH_W],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MULSATRNDHH_H, 4, 0xe0000a80, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_MULSATRNDHH_H],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MULSATRNDWH_W, 4, 0xe0000b80, 0xe1f0ffe0,
++      &avr32_syntax_table[AVR32_SYNTAX_MULSATRNDWH_W],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MULSATWH_W, 4, 0xe0000e80, 0xe1f0ffe0,
++      &avr32_syntax_table[AVR32_SYNTAX_MULSATWH_W],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MULU_D, 4, 0xe0000640, 0xe1f0fff1,
++      &avr32_syntax_table[AVR32_SYNTAX_MULU_D],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MULWH_D, 4, 0xe0000d80, 0xe1f0ffe1,
++      &avr32_syntax_table[AVR32_SYNTAX_MULWH_D],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_MUSFR, 2, 0x5d300000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_MUSFR],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_MUSTR, 2, 0x5d200000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_MUSTR],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_MVCR_D, 4, 0xefa00010, 0xfff111ff,
++      &avr32_syntax_table[AVR32_SYNTAX_MVCR_D],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      },
++    },
++    {
++      AVR32_OPC_MVCR_W, 4, 0xefa00000, 0xfff010ff,
++      &avr32_syntax_table[AVR32_SYNTAX_MVCR_W],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      },
++    },
++    {
++      AVR32_OPC_MVRC_D, 4, 0xefa00030, 0xfff111ff,
++      &avr32_syntax_table[AVR32_SYNTAX_MVRC_D],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      },
++    },
++    {
++      AVR32_OPC_MVRC_W, 4, 0xefa00020, 0xfff010ff,
++      &avr32_syntax_table[AVR32_SYNTAX_MVRC_W],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_NEG, 2, 0x5c300000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_NEG],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_NOP, 2, 0xd7030000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_NOP],
++      BFD_RELOC_UNUSED, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_OR1, 2, 0x00400000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_OR1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_OR2, 4, 0xe1e01000, 0xe1f0fe00,
++      &avr32_syntax_table[AVR32_SYNTAX_OR2],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E2],
++      },
++    },
++    {
++      AVR32_OPC_OR3, 4, 0xe1e01200, 0xe1f0fe00,
++      &avr32_syntax_table[AVR32_SYNTAX_OR3],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E2],
++      },
++    },
++    {
++      AVR32_OPC_ORH, 4, 0xea100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ORH],
++      BFD_RELOC_AVR32_16U, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_ORL, 4, 0xe8100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ORL],
++      BFD_RELOC_AVR32_16U, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_PABS_SB, 4, 0xe00023e0, 0xfff0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PABS_SB],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PABS_SH, 4, 0xe00023f0, 0xfff0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PABS_SH],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PACKSH_SB, 4, 0xe00024d0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PACKSH_SB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PACKSH_UB, 4, 0xe00024c0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PACKSH_UB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PACKW_SH, 4, 0xe0002470, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PACKW_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADD_B, 4, 0xe0002300, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADD_B],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADD_H, 4, 0xe0002000, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADD_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDH_SH, 4, 0xe00020c0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDH_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDH_UB, 4, 0xe0002360, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDH_UB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDS_SB, 4, 0xe0002320, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDS_SB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDS_SH, 4, 0xe0002040, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDS_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDS_UB, 4, 0xe0002340, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDS_UB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDS_UH, 4, 0xe0002080, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDS_UH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDSUB_H, 4, 0xe0002100, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDSUB_H],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PADDSUBH_SH, 4, 0xe0002280, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDSUBH_SH],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PADDSUBS_SH, 4, 0xe0002180, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDSUBS_SH],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PADDSUBS_UH, 4, 0xe0002200, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDSUBS_UH],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PADDX_H, 4, 0xe0002020, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDX_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDXH_SH, 4, 0xe00020e0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDXH_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDXS_SH, 4, 0xe0002060, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDXS_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PADDXS_UH, 4, 0xe00020a0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PADDXS_UH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PASR_B, 4, 0xe0002410, 0xe1f8fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PASR_B],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_COND3],
++      },
++    },
++    {
++      AVR32_OPC_PASR_H, 4, 0xe0002440, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PASR_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PAVG_SH, 4, 0xe00023d0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PAVG_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PAVG_UB, 4, 0xe00023c0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PAVG_UB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PLSL_B, 4, 0xe0002420, 0xe1f8fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PLSL_B],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_COND3],
++      },
++    },
++    {
++      AVR32_OPC_PLSL_H, 4, 0xe0002450, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PLSL_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PLSR_B, 4, 0xe0002430, 0xe1f8fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PLSR_B],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_COND3],
++      },
++    },
++    {
++      AVR32_OPC_PLSR_H, 4, 0xe0002460, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PLSR_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PMAX_SH, 4, 0xe0002390, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PMAX_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PMAX_UB, 4, 0xe0002380, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PMAX_UB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PMIN_SH, 4, 0xe00023b0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PMIN_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PMIN_UB, 4, 0xe00023a0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PMIN_UB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_POPJC, 2, 0xd7130000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_POPJC],
++      BFD_RELOC_UNUSED, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_POPM, 2, 0xd0020000, 0xf0070000,
++      &avr32_syntax_table[AVR32_SYNTAX_POPM],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_POPM],
++      },
++    },
++    {
++      AVR32_OPC_POPM_E, 4, 0xe3cd0000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_POPM_E],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_PREF, 4, 0xf2100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_PREF],
++      BFD_RELOC_AVR32_16S, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_PSAD, 4, 0xe0002400, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSAD],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUB_B, 4, 0xe0002310, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUB_B],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUB_H, 4, 0xe0002010, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUB_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBADD_H, 4, 0xe0002140, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBADD_H],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PSUBADDH_SH, 4, 0xe00022c0, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBADDH_SH],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PSUBADDS_SH, 4, 0xe00021c0, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBADDS_SH],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PSUBADDS_UH, 4, 0xe0002240, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBADDS_UH],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PSUBH_SH, 4, 0xe00020d0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBH_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBH_UB, 4, 0xe0002370, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBH_UB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBS_SB, 4, 0xe0002330, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBS_SB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBS_SH, 4, 0xe0002050, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBS_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBS_UB, 4, 0xe0002350, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBS_UB],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBS_UH, 4, 0xe0002090, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBS_UH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBX_H, 4, 0xe0002030, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBX_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBXH_SH, 4, 0xe00020f0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBXH_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBXS_SH, 4, 0xe0002070, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBXS_SH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PSUBXS_UH, 4, 0xe00020b0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_PSUBXS_UH],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_PUNPCKSB_H, 4, 0xe00024a0, 0xe1ffffe0,
++      &avr32_syntax_table[AVR32_SYNTAX_PUNPCKSB_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PUNPCKUB_H, 4, 0xe0002480, 0xe1ffffe0,
++      &avr32_syntax_table[AVR32_SYNTAX_PUNPCKUB_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_PUSHJC, 2, 0xd7230000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_PUSHJC],
++      BFD_RELOC_UNUSED, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_PUSHM, 2, 0xd0010000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_PUSHM],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_PUSHM_E, 4, 0xebcd0000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_PUSHM_E],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_RCALL1, 2, 0xc00c0000, 0xf00c0000,
++      &avr32_syntax_table[AVR32_SYNTAX_RCALL1],
++      BFD_RELOC_AVR32_11H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K10],
++      },
++    },
++    {
++      AVR32_OPC_RCALL2, 4, 0xe0a00000, 0xe1ef0000,
++      &avr32_syntax_table[AVR32_SYNTAX_RCALL2],
++      BFD_RELOC_AVR32_22H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_RETEQ, 2, 0x5e000000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETEQ],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETNE, 2, 0x5e100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETNE],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETCC, 2, 0x5e200000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETHS],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETCS, 2, 0x5e300000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETLO],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETGE, 2, 0x5e400000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETGE],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETLT, 2, 0x5e500000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETLT],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETMI, 2, 0x5e600000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETMI],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETPL, 2, 0x5e700000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETPL],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETLS, 2, 0x5e800000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETLS],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETGT, 2, 0x5e900000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETGT],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETLE, 2, 0x5ea00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETLE],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETHI, 2, 0x5eb00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETHI],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETVS, 2, 0x5ec00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETVS],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETVC, 2, 0x5ed00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETVC],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETQS, 2, 0x5ee00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETQS],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETAL, 2, 0x5ef00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETAL],
++      BFD_RELOC_NONE, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_RETD, 2, 0xd6230000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETD],
++      BFD_RELOC_NONE, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_RETE, 2, 0xd6030000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETE],
++      BFD_RELOC_NONE, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_RETJ, 2, 0xd6330000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETJ],
++      BFD_RELOC_NONE, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_RETS, 2, 0xd6130000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_RETS],
++      BFD_RELOC_NONE, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_RJMP, 2, 0xc0080000, 0xf00c0000,
++      &avr32_syntax_table[AVR32_SYNTAX_RJMP],
++      BFD_RELOC_AVR32_11H_PCREL, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K10],
++      },
++    },
++    {
++      AVR32_OPC_ROL, 2, 0x5cf00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ROL],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_ROR, 2, 0x5d000000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ROR],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_RSUB1, 2, 0x00200000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_RSUB1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_RSUB2, 4, 0xe0001100, 0xe1f0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_RSUB2],
++      BFD_RELOC_AVR32_8S_EXT, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SATADD_H, 4, 0xe00002c0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_SATADD_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SATADD_W, 4, 0xe00000c0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_SATADD_W],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SATRNDS, 4, 0xf3b00000, 0xfff0fc00,
++      &avr32_syntax_table[AVR32_SYNTAX_SATRNDS],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      &avr32_ifield_table[AVR32_IFIELD_S5],
++      },
++    },
++    {
++      AVR32_OPC_SATRNDU, 4, 0xf3b00400, 0xfff0fc00,
++      &avr32_syntax_table[AVR32_SYNTAX_SATRNDU],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      &avr32_ifield_table[AVR32_IFIELD_S5],
++      },
++    },
++    {
++      AVR32_OPC_SATS, 4, 0xf1b00000, 0xfff0fc00,
++      &avr32_syntax_table[AVR32_SYNTAX_SATS],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      &avr32_ifield_table[AVR32_IFIELD_S5],
++      },
++    },
++    {
++      AVR32_OPC_SATSUB_H, 4, 0xe00003c0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_SATSUB_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SATSUB_W1, 4, 0xe00001c0, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_SATSUB_W1],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SATSUB_W2, 4, 0xe0d00000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SATSUB_W2],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_SATU, 4, 0xf1b00400, 0xfff0fc00,
++      &avr32_syntax_table[AVR32_SYNTAX_SATU],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      &avr32_ifield_table[AVR32_IFIELD_S5],
++      },
++    },
++    {
++      AVR32_OPC_SBC, 4, 0xe0000140, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_SBC],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SBR, 2, 0xa1a00000, 0xe1e00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SBR],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_BIT5C],
++      },
++    },
++    {
++      AVR32_OPC_SCALL, 2, 0xd7330000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_SCALL],
++      BFD_RELOC_UNUSED, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_SCR, 2, 0x5c100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SCR],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SLEEP, 4, 0xe9b00000, 0xffffff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SLEEP],
++      BFD_RELOC_AVR32_8S_EXT, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SREQ, 2, 0x5f000000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SREQ],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRNE, 2, 0x5f100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRNE],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRCC, 2, 0x5f200000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRHS],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRCS, 2, 0x5f300000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRLO],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRGE, 2, 0x5f400000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRGE],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRLT, 2, 0x5f500000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRLT],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRMI, 2, 0x5f600000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRMI],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRPL, 2, 0x5f700000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRPL],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRLS, 2, 0x5f800000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRLS],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRGT, 2, 0x5f900000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRGT],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRLE, 2, 0x5fa00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRLE],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRHI, 2, 0x5fb00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRHI],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRVS, 2, 0x5fc00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRVS],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRVC, 2, 0x5fd00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRVC],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRQS, 2, 0x5fe00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRQS],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SRAL, 2, 0x5ff00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SRAL],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SSRF, 2, 0xd2030000, 0xfe0f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_SSRF],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K5C],
++      },
++    },
++    {
++      AVR32_OPC_ST_B1, 2, 0x00c00000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_B1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_B2, 2, 0x00f00000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_B2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_B5, 4, 0xe0000b00, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_B5],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      },
++    },
++    {
++      AVR32_OPC_ST_B3, 2, 0xa0800000, 0xe1800000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_B3],
++      BFD_RELOC_AVR32_3U, 3, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K3],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_B4, 4, 0xe1600000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_B4],
++      BFD_RELOC_AVR32_16S, 3, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_D1, 2, 0xa1200000, 0xe1f10000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_D1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      },
++    },
++    {
++      AVR32_OPC_ST_D2, 2, 0xa1210000, 0xe1f10000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_D2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      },
++    },
++    {
++      AVR32_OPC_ST_D3, 2, 0xa1110000, 0xe1f10000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_D3],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      },
++    },
++    {
++      AVR32_OPC_ST_D5, 4, 0xe0000800, 0xe1f0ffc1,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_D5],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      &avr32_ifield_table[AVR32_IFIELD_RD_DW],
++      },
++    },
++    {
++      AVR32_OPC_ST_D4, 4, 0xe0e10000, 0xe1f10000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_D4],
++      BFD_RELOC_AVR32_16S, 3, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      &avr32_ifield_table[AVR32_IFIELD_RY_DW],
++      },
++    },
++    {
++      AVR32_OPC_ST_H1, 2, 0x00b00000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_H1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_H2, 2, 0x00e00000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_H2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_H5, 4, 0xe0000a00, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_H5],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      },
++    },
++    {
++      AVR32_OPC_ST_H3, 2, 0xa0000000, 0xe1800000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_H3],
++      BFD_RELOC_AVR32_4UH, 3, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K3],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_H4, 4, 0xe1500000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_H4],
++      BFD_RELOC_AVR32_16S, 3, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_W1, 2, 0x00a00000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_W1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_W2, 2, 0x00d00000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_W2],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_W5, 4, 0xe0000900, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_W5],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      },
++    },
++    {
++      AVR32_OPC_ST_W3, 2, 0x81000000, 0xe1000000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_W3],
++      BFD_RELOC_AVR32_6UW, 3, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K4],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_ST_W4, 4, 0xe1400000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_ST_W4],
++      BFD_RELOC_AVR32_16S, 3, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_STC_D1, 4, 0xeba01000, 0xfff01100,
++      &avr32_syntax_table[AVR32_SYNTAX_STC_D1],
++      BFD_RELOC_AVR32_10UW, 4, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      },
++    },
++    {
++      AVR32_OPC_STC_D2, 4, 0xefa00070, 0xfff011f0,
++      &avr32_syntax_table[AVR32_SYNTAX_STC_D2],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      },
++    },
++    {
++      AVR32_OPC_STC_D3, 4, 0xefa010c0, 0xfff011c0,
++      &avr32_syntax_table[AVR32_SYNTAX_STC_D3],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      },
++    },
++    {
++      AVR32_OPC_STC_W1, 4, 0xeba00000, 0xfff01000,
++      &avr32_syntax_table[AVR32_SYNTAX_STC_W1],
++      BFD_RELOC_AVR32_10UW, 4, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      },
++    },
++    {
++      AVR32_OPC_STC_W2, 4, 0xefa00060, 0xfff010ff,
++      &avr32_syntax_table[AVR32_SYNTAX_STC_W2],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      },
++    },
++    {
++      AVR32_OPC_STC_W3, 4, 0xefa01080, 0xfff010c0,
++      &avr32_syntax_table[AVR32_SYNTAX_STC_W3],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      },
++    },
++    {
++      AVR32_OPC_STC0_D, 4, 0xf7a00000, 0xfff00100,
++      &avr32_syntax_table[AVR32_SYNTAX_STC0_D],
++      BFD_RELOC_AVR32_14UW, 3, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K12CP],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_DW],
++      },
++    },
++    {
++      AVR32_OPC_STC0_W, 4, 0xf5a00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_STC0_W],
++      BFD_RELOC_AVR32_14UW, 3, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K12CP],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      },
++    },
++    {
++      AVR32_OPC_STCM_D, 4, 0xeda00500, 0xfff01f00,
++      &avr32_syntax_table[AVR32_SYNTAX_STCM_D],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_STCM_D_PU, 4, 0xeda01500, 0xfff01f00,
++      &avr32_syntax_table[AVR32_SYNTAX_STCM_D_PU],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_STCM_W, 4, 0xeda00200, 0xfff01e00,
++      &avr32_syntax_table[AVR32_SYNTAX_STCM_W],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      &avr32_ifield_table[AVR32_IFIELD_CM_HL],
++      },
++    },
++    {
++      AVR32_OPC_STCM_W_PU, 4, 0xeda01200, 0xfff01e00,
++      &avr32_syntax_table[AVR32_SYNTAX_STCM_W_PU],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_CPNO],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      &avr32_ifield_table[AVR32_IFIELD_CM_HL],
++      },
++    },
++    {
++      AVR32_OPC_STCOND, 4, 0xe1700000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_STCOND],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_STDSP, 2, 0x50000000, 0xf8000000,
++      &avr32_syntax_table[AVR32_SYNTAX_STDSP],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K7C],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_STHH_W2, 4, 0xe1e08000, 0xe1f0c0c0,
++      &avr32_syntax_table[AVR32_SYNTAX_STHH_W2],
++      BFD_RELOC_UNUSED, 7, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_CRD_RI],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X2],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y2],
++      },
++    },
++    {
++      AVR32_OPC_STHH_W1, 4, 0xe1e0c000, 0xe1f0c000,
++      &avr32_syntax_table[AVR32_SYNTAX_STHH_W1],
++      BFD_RELOC_AVR32_STHH_W, 6, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_K8E2],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X2],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y2],
++      },
++    },
++    {
++      AVR32_OPC_STM, 4, 0xe9c00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_STM],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_STM_PU, 4, 0xebc00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_STM_PU],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_STMTS, 4, 0xedc00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_STMTS],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_STMTS_PU, 4, 0xefc00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_STMTS_PU],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_STSWP_H, 4, 0xe1d09000, 0xe1f0f000,
++      &avr32_syntax_table[AVR32_SYNTAX_STSWP_H],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K12],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_STSWP_W, 4, 0xe1d0a000, 0xe1f0f000,
++      &avr32_syntax_table[AVR32_SYNTAX_STSWP_W],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K12],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_SUB1, 2, 0x00100000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SUB1],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_SUB2, 4, 0xe0000100, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_SUB2],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K2],
++      },
++    },
++    {
++      AVR32_OPC_SUB5, 4, 0xe0c00000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SUB5],
++      BFD_RELOC_AVR32_SUB5, 3, 2,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_K16],
++      },
++    },
++    {
++      AVR32_OPC_SUB3_SP, 2, 0x200d0000, 0xf00f0000,
++      &avr32_syntax_table[AVR32_SYNTAX_SUB3_SP],
++      BFD_RELOC_AVR32_10SW, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_SUB3, 2, 0x20000000, 0xf0000000,
++      &avr32_syntax_table[AVR32_SYNTAX_SUB3],
++      BFD_RELOC_AVR32_8S, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8C],
++      },
++    },
++    {
++      AVR32_OPC_SUB4, 4, 0xe0200000, 0xe1e00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SUB4],
++      BFD_RELOC_AVR32_21S, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K21],
++      },
++    },
++    {
++      AVR32_OPC_SUBEQ, 4, 0xf7b00000, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBEQ],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBNE, 4, 0xf7b00100, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBNE],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBCC, 4, 0xf7b00200, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBHS],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBCS, 4, 0xf7b00300, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBLO],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBGE, 4, 0xf7b00400, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBGE],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBLT, 4, 0xf7b00500, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBLT],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBMI, 4, 0xf7b00600, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBMI],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBPL, 4, 0xf7b00700, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBPL],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBLS, 4, 0xf7b00800, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBLS],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBGT, 4, 0xf7b00900, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBGT],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBLE, 4, 0xf7b00a00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBLE],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBHI, 4, 0xf7b00b00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBHI],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBVS, 4, 0xf7b00c00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBVS],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBVC, 4, 0xf7b00d00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBVC],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBQS, 4, 0xf7b00e00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBQS],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBAL, 4, 0xf7b00f00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBAL],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFEQ, 4, 0xf5b00000, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFEQ],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFNE, 4, 0xf5b00100, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFNE],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFCC, 4, 0xf5b00200, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFHS],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFCS, 4, 0xf5b00300, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFLO],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFGE, 4, 0xf5b00400, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFGE],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFLT, 4, 0xf5b00500, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFLT],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFMI, 4, 0xf5b00600, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFMI],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFPL, 4, 0xf5b00700, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFPL],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFLS, 4, 0xf5b00800, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFLS],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFGT, 4, 0xf5b00900, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFGT],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFLE, 4, 0xf5b00a00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFLE],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFHI, 4, 0xf5b00b00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFHI],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFVS, 4, 0xf5b00c00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFVS],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFVC, 4, 0xf5b00d00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFVC],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFQS, 4, 0xf5b00e00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFQS],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBFAL, 4, 0xf5b00f00, 0xfff0ff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBFAL],
++      BFD_RELOC_AVR32_8S_EXT, 2, 1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      },
++    },
++    {
++      AVR32_OPC_SUBHH_W, 4, 0xe0000f00, 0xe1f0ffc0,
++      &avr32_syntax_table[AVR32_SYNTAX_SUBHH_W],
++      BFD_RELOC_UNUSED, 5, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_X],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_Y],
++      },
++    },
++    {
++      AVR32_OPC_SWAP_B, 2, 0x5cb00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SWAP_B],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_SWAP_BH, 2, 0x5cc00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SWAP_BH],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_SWAP_H, 2, 0x5ca00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_SWAP_H],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_SYNC, 4, 0xebb00000, 0xffffff00,
++      &avr32_syntax_table[AVR32_SYNTAX_SYNC],
++      BFD_RELOC_AVR32_8S_EXT, 1, 0,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_K8E],
++      }
++    },
++    {
++      AVR32_OPC_TLBR, 2, 0xd6430000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_TLBR],
++      BFD_RELOC_UNUSED, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_TLBS, 2, 0xd6530000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_TLBS],
++      BFD_RELOC_UNUSED, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_TLBW, 2, 0xd6630000, 0xffff0000,
++      &avr32_syntax_table[AVR32_SYNTAX_TLBW],
++      BFD_RELOC_UNUSED, 0, -1, { NULL },
++    },
++    {
++      AVR32_OPC_TNBZ, 2, 0x5ce00000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_TNBZ],
++      BFD_RELOC_UNUSED, 1, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      }
++    },
++    {
++      AVR32_OPC_TST, 2, 0x00700000, 0xe1f00000,
++      &avr32_syntax_table[AVR32_SYNTAX_TST],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      },
++    },
++    {
++      AVR32_OPC_XCHG, 4, 0xe0000b40, 0xe1f0fff0,
++      &avr32_syntax_table[AVR32_SYNTAX_XCHG],
++      BFD_RELOC_UNUSED, 3, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RD_E],
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      },
++    },
++    {
++      AVR32_OPC_MEMC, 4, 0xf6100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_MEMC],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_MEM15],
++      &avr32_ifield_table[AVR32_IFIELD_MEMB5],
++      },
++    },
++    {
++      AVR32_OPC_MEMS, 4, 0xf8100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_MEMS],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_MEM15],
++      &avr32_ifield_table[AVR32_IFIELD_MEMB5],
++      },
++    },
++    {
++      AVR32_OPC_MEMT, 4, 0xfa100000, 0xfff00000,
++      &avr32_syntax_table[AVR32_SYNTAX_MEMT],
++      BFD_RELOC_UNUSED, 2, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_MEM15],
++      &avr32_ifield_table[AVR32_IFIELD_MEMB5],
++      },
++    },
++    {
++      AVR32_OPC_BFEXTS, 4, 0xe1d0b000, 0xe1f0fc00,
++      &avr32_syntax_table[AVR32_SYNTAX_BFEXTS],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_S5],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      },
++    },
++    {
++      AVR32_OPC_BFEXTU, 4, 0xe1d0c000, 0xe1f0fc00,
++      &avr32_syntax_table[AVR32_SYNTAX_BFEXTU],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_S5],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      },
++    },
++    {
++      AVR32_OPC_BFINS, 4, 0xe1d0d000, 0xe1f0fc00,
++      &avr32_syntax_table[AVR32_SYNTAX_BFINS],
++      BFD_RELOC_UNUSED, 4, -1,
++      {
++      &avr32_ifield_table[AVR32_IFIELD_RX],
++      &avr32_ifield_table[AVR32_IFIELD_RY],
++      &avr32_ifield_table[AVR32_IFIELD_S5],
++      &avr32_ifield_table[AVR32_IFIELD_K5E],
++      },
++    },
++  };
++
++#define FPALIAS_DXY(name, opcode)                     \
++  {                                                   \
++    AVR32_ALIAS_##name##_S,                           \
++    &avr32_opc_table[AVR32_OPC_COP],                  \
++    {                                                 \
++      { 0, 0 },                                               \
++      { 1, 0 }, { 1, 1 }, { 1, 2 },                   \
++      { 0, opcode },                                  \
++    },                                                        \
++  }, {                                                        \
++    AVR32_ALIAS_##name##_D,                           \
++    &avr32_opc_table[AVR32_OPC_COP],                  \
++    {                                                 \
++      { 0, 0 },                                               \
++      { 1, 0 }, { 1, 1 }, { 1, 2 },                   \
++      { 0, (opcode) | 0x40 },                         \
++    },                                                        \
++  }
++#define FPALIAS_DX(name, opcode)                      \
++  {                                                   \
++    AVR32_ALIAS_##name##_S,                           \
++    &avr32_opc_table[AVR32_OPC_COP],                  \
++    {                                                 \
++      { 0, 0 },                                               \
++      { 1, 0 }, { 1, 1 }, { 0, 0 },                   \
++      { 0, opcode },                                  \
++    },                                                        \
++  }, {                                                        \
++    AVR32_ALIAS_##name##_D,                           \
++    &avr32_opc_table[AVR32_OPC_COP],                  \
++    {                                                 \
++      { 0, 0 },                                               \
++      { 1, 0 }, { 1, 1 }, { 0, 0 },                   \
++      { 0, (opcode) | 0x40 },                         \
++    },                                                        \
++  }
++#define FPALIAS_XY(name, opcode)                      \
++  {                                                   \
++    AVR32_ALIAS_##name##_S,                           \
++    &avr32_opc_table[AVR32_OPC_COP],                  \
++    {                                                 \
++      { 0, 0 },                                               \
++      { 0, 0 }, { 1, 0 }, { 1, 1 },                   \
++      { 0, opcode },                                  \
++    },                                                        \
++  }, {                                                        \
++    AVR32_ALIAS_##name##_D,                           \
++    &avr32_opc_table[AVR32_OPC_COP],                  \
++    {                                                 \
++      { 0, 0 },                                               \
++      { 0, 0 }, { 1, 0 }, { 1, 1 },                   \
++      { 0, (opcode) | 0x40 },                         \
++    },                                                        \
++  }
++
++const struct avr32_alias avr32_alias_table[] =
++  {
++    FPALIAS_DXY(FMAC, 0x00),
++    FPALIAS_DXY(FNMAC, 0x01),
++    FPALIAS_DXY(FMSC, 0x02),
++    FPALIAS_DXY(FNMSC, 0x03),
++    FPALIAS_DXY(FADD, 0x04),
++    FPALIAS_DXY(FSUB, 0x05),
++    FPALIAS_DXY(FMUL, 0x06),
++    FPALIAS_DXY(FNMUL, 0x07),
++    FPALIAS_DX(FNEG, 0x08),
++    FPALIAS_DX(FABS, 0x09),
++    FPALIAS_XY(FCMP, 0x0d),
++    FPALIAS_DX(FMOV1, 0x0a),
++    {
++      AVR32_ALIAS_FMOV2_S,
++      &avr32_opc_table[AVR32_OPC_MVCR_W],
++      { { 0, 0 }, { 1, 0 }, { 1, 1 }, },
++    },
++    {
++      AVR32_ALIAS_FMOV2_D,
++      &avr32_opc_table[AVR32_OPC_MVCR_D],
++      { { 0, 0 }, { 1, 0 }, { 1, 1 }, },
++    },
++    {
++      AVR32_ALIAS_FMOV3_S,
++      &avr32_opc_table[AVR32_OPC_MVRC_W],
++      { { 0, 0 }, { 1, 0 }, { 1, 1 }, },
++    },
++    {
++      AVR32_ALIAS_FMOV3_D,
++      &avr32_opc_table[AVR32_OPC_MVRC_D],
++      { { 0, 0 }, { 1, 0 }, { 1, 1 }, },
++    },
++    {
++      AVR32_ALIAS_FCASTS_D,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, 0 },
++      { 1, 0 }, { 1, 1 }, { 0, 0 },
++      { 0, 0x0f },
++      },
++    },
++    {
++      AVR32_ALIAS_FCASTD_S,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, 0 },
++      { 1, 0 }, { 1, 1 }, { 0, 0 },
++      { 0, 0x10 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSVMAC0,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x0c },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSVMAC1,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x0d },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSVMAC2,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x0e },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSVMAC3,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x0f },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSVMUL0,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x08 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSVMUL1,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x09 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSVMUL2,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x0a },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSVMUL3,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x0b },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOVMAC0,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x04 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOVMAC1,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x05 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOVMAC2,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x06 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOVMAC3,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x07 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOVMUL0,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x00 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOVMUL1,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x01 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOVMUL2,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x02 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOVMUL3,
++      &avr32_opc_table[AVR32_OPC_COP],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      { 0, 0x03 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLD_D1,
++      &avr32_opc_table[AVR32_OPC_LDC_D1],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLD_D2,
++      &avr32_opc_table[AVR32_OPC_LDC_D2],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLD_D3,
++      &avr32_opc_table[AVR32_OPC_LDC_D3],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLD_W1,
++      &avr32_opc_table[AVR32_OPC_LDC_W1],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLD_W2,
++      &avr32_opc_table[AVR32_OPC_LDC_W2],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLD_W3,
++      &avr32_opc_table[AVR32_OPC_LDC_W3],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLDM_D,
++      &avr32_opc_table[AVR32_OPC_LDCM_D],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLDM_D_PU,
++      &avr32_opc_table[AVR32_OPC_LDCM_D_PU],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLDM_W,
++      &avr32_opc_table[AVR32_OPC_LDCM_W],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOLDM_W_PU,
++      &avr32_opc_table[AVR32_OPC_LDCM_W_PU],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOMV_D1,
++      &avr32_opc_table[AVR32_OPC_MVCR_D],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOMV_D2,
++      &avr32_opc_table[AVR32_OPC_MVRC_D],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOMV_W1,
++      &avr32_opc_table[AVR32_OPC_MVCR_W],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOMV_W2,
++      &avr32_opc_table[AVR32_OPC_MVRC_W],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOST_D1,
++      &avr32_opc_table[AVR32_OPC_STC_D1],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOST_D2,
++      &avr32_opc_table[AVR32_OPC_STC_D2],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOST_D3,
++      &avr32_opc_table[AVR32_OPC_STC_D3],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOST_W1,
++      &avr32_opc_table[AVR32_OPC_STC_W1],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOST_W2,
++      &avr32_opc_table[AVR32_OPC_STC_W2],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOST_W3,
++      &avr32_opc_table[AVR32_OPC_STC_W3],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSTM_D,
++      &avr32_opc_table[AVR32_OPC_STCM_D],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSTM_D_PU,
++      &avr32_opc_table[AVR32_OPC_STCM_D_PU],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSTM_W,
++      &avr32_opc_table[AVR32_OPC_STCM_W],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      },
++    },
++    {
++      AVR32_ALIAS_PICOSTM_W_PU,
++      &avr32_opc_table[AVR32_OPC_STCM_W_PU],
++      {
++      { 0, PICO_CPNO },
++      { 1, 0 }, { 1, 1 }, { 1, 2 },
++      },
++    },
++  };
++
++
++#define SYNTAX_NORMAL0(id, mne, opc, arch)                    \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },           \
++    NULL, 0, { }                                      \
++  }
++#define SYNTAX_NORMAL1(id, mne, opc, op0, arch)               \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },           \
++    NULL, 1,                                          \
++    {                                                 \
++      AVR32_OPERAND_##op0,                            \
++    }                                                 \
++  }
++#define SYNTAX_NORMALM1(id, mne, opc, op0, arch)              \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    NULL, -1,                                         \
++    {                                                 \
++      AVR32_OPERAND_##op0,                            \
++    }                                                 \
++  }
++#define SYNTAX_NORMAL2(id, mne, opc, op0, op1, arch)          \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    NULL, 2,                                          \
++    {                                                 \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,               \
++    }                                                 \
++  }
++#define SYNTAX_NORMALM2(id, mne, opc, op0, op1, arch)         \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    NULL, -2,                                         \
++    {                                                 \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,               \
++    }                                                 \
++  }
++#define SYNTAX_NORMAL3(id, mne, opc, op0, op1, op2, arch)     \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    NULL, 3,                                          \
++    {                                                 \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,               \
++      AVR32_OPERAND_##op2,                            \
++    }                                                 \
++  }
++#define SYNTAX_NORMALM3(id, mne, opc, op0, op1, op2, arch)    \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    NULL, -3,                                         \
++    {                                                 \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,               \
++      AVR32_OPERAND_##op2,                            \
++    }                                                 \
++  }
++#define SYNTAX_NORMAL4(id, mne, opc, op0, op1, op2, op3, arch)\
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    NULL, 4,                                          \
++    {                                                 \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,               \
++      AVR32_OPERAND_##op2, AVR32_OPERAND_##op3,               \
++    }                                                 \
++  }
++#define SYNTAX_NORMAL5(id, mne, opc, op0, op1, op2, op3, op4, arch)   \
++  {                                                           \
++    AVR32_SYNTAX_##id, arch,                          \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],              \
++    AVR32_PARSER_NORMAL,                                              \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                           \
++    NULL, 5,                                                  \
++    {                                                         \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,                       \
++      AVR32_OPERAND_##op2, AVR32_OPERAND_##op3,                       \
++      AVR32_OPERAND_##op4,                                    \
++    }                                                         \
++  }
++
++#define SYNTAX_NORMAL_C1(id, mne, opc, nxt, op0, arch)        \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    &avr32_syntax_table[AVR32_SYNTAX_##nxt], 1,               \
++    {                                                 \
++      AVR32_OPERAND_##op0,                            \
++    }                                                 \
++  }
++#define SYNTAX_NORMAL_CM1(id, mne, opc, nxt, op0, arch)       \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    &avr32_syntax_table[AVR32_SYNTAX_##nxt], -1,      \
++    {                                                 \
++      AVR32_OPERAND_##op0,                            \
++    }                                                 \
++  }
++#define SYNTAX_NORMAL_C2(id, mne, opc, nxt, op0, op1, arch)   \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    &avr32_syntax_table[AVR32_SYNTAX_##nxt], 2,               \
++    {                                                 \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,               \
++    }                                                 \
++  }
++#define SYNTAX_NORMAL_CM2(id, mne, opc, nxt, op0, op1, arch)  \
++  {                                                   \
++    AVR32_SYNTAX_##id, arch,                  \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],      \
++    AVR32_PARSER_NORMAL,                                      \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                   \
++    &avr32_syntax_table[AVR32_SYNTAX_##nxt], -2,      \
++    {                                                 \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,               \
++    }                                                 \
++  }
++#define SYNTAX_NORMAL_C3(id, mne, opc, nxt, op0, op1, op2, arch)      \
++  {                                                           \
++    AVR32_SYNTAX_##id, arch,                          \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],              \
++    AVR32_PARSER_NORMAL,                                              \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                           \
++    &avr32_syntax_table[AVR32_SYNTAX_##nxt], 3,                       \
++    {                                                         \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,                       \
++      AVR32_OPERAND_##op2,                                    \
++    }                                                         \
++  }
++#define SYNTAX_NORMAL_CM3(id, mne, opc, nxt, op0, op1, op2, arch)     \
++  {                                                           \
++    AVR32_SYNTAX_##id, arch,                          \
++    &avr32_mnemonic_table[AVR32_MNEMONIC_##mne],              \
++    AVR32_PARSER_NORMAL,                                              \
++    { &avr32_opc_table[AVR32_OPC_##opc], },                           \
++    &avr32_syntax_table[AVR32_SYNTAX_##nxt], -3,              \
++    {                                                         \
++      AVR32_OPERAND_##op0, AVR32_OPERAND_##op1,                       \
++      AVR32_OPERAND_##op2,                                    \
++    }                                                         \
++  }
++
++#define SYNTAX_FP(name, nr_ops)                                       \
++    {                                                         \
++      AVR32_SYNTAX_##name##_S,                                        \
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,                     \
++      { .alias = &avr32_alias_table[AVR32_ALIAS_##name##_S] },        \
++      NULL, nr_ops,                                           \
++      {                                                               \
++      AVR32_OPERAND_FPREG_S,                                  \
++      AVR32_OPERAND_FPREG_S,                                  \
++      AVR32_OPERAND_FPREG_S,                                  \
++      },                                                      \
++    },                                                                \
++    {                                                         \
++      AVR32_SYNTAX_##name##_D,                                        \
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,                     \
++      { .alias = &avr32_alias_table[AVR32_ALIAS_##name##_D] },        \
++      NULL, nr_ops,                                           \
++      {                                                               \
++      AVR32_OPERAND_FPREG_D,                                  \
++      AVR32_OPERAND_FPREG_D,                                  \
++      AVR32_OPERAND_FPREG_D,                                  \
++      },                                                      \
++    }
++
++const struct avr32_syntax avr32_syntax_table[] =
++  {
++    SYNTAX_NORMAL1(ABS, ABS, ABS, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(ACALL, ACALL, ACALL, UNSIGNED_CONST_W, AVR32_V1),
++    SYNTAX_NORMAL1(ACR, ACR, ACR, INTREG,AVR32_V1),
++    SYNTAX_NORMAL3(ADC, ADC, ADC, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ADD1, ADD, ADD1, ADD2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(ADD2, ADD, ADD2, INTREG, INTREG, INTREG_LSL, AVR32_V1),
++    SYNTAX_NORMAL3(ADDABS, ADDABS, ADDABS, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(ADDHH_W, ADDHH_W, ADDHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL_C2(AND1, AND, AND1, AND2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(AND2, AND, AND2, AND3, INTREG, INTREG, INTREG_LSL, AVR32_V1),
++    SYNTAX_NORMAL3(AND3, AND, AND3, INTREG, INTREG, INTREG_LSR, AVR32_V1),
++    SYNTAX_NORMAL_C2(ANDH, ANDH, ANDH, ANDH_COH, INTREG, UNSIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL3(ANDH_COH, ANDH, ANDH_COH, INTREG, UNSIGNED_CONST, COH, AVR32_V1),
++    SYNTAX_NORMAL_C2(ANDL, ANDL, ANDL, ANDL_COH, INTREG, UNSIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL3(ANDL_COH, ANDL, ANDL_COH, INTREG, UNSIGNED_CONST, COH, AVR32_V1),
++    SYNTAX_NORMAL2(ANDN, ANDN, ANDN, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(ASR1, ASR, ASR1, ASR3, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(ASR3, ASR, ASR3, ASR2, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL2(ASR2, ASR, ASR2, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL4(BFEXTS, BFEXTS, BFEXTS, INTREG, INTREG, UNSIGNED_NUMBER, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL4(BFEXTU, BFEXTU, BFEXTU, INTREG, INTREG, UNSIGNED_NUMBER, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL4(BFINS, BFINS, BFINS, INTREG, INTREG, UNSIGNED_NUMBER, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL2(BLD, BLD, BLD, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL_C1(BREQ1, BREQ, BREQ1, BREQ2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL_C1(BRNE1, BRNE, BRNE1, BRNE2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL_C1(BRCC1, BRCC, BRCC1, BRCC2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL_C1(BRCS1, BRCS, BRCS1, BRCS2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL_C1(BRGE1, BRGE, BRGE1, BRGE2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL_C1(BRLT1, BRLT, BRLT1, BRLT2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL_C1(BRMI1, BRMI, BRMI1, BRMI2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL_C1(BRPL1, BRPL, BRPL1, BRPL2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL_C1(BRHS1, BRHS, BRCC1, BRHS2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL_C1(BRLO1, BRLO, BRCS1, BRLO2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BREQ2, BREQ, BREQ2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRNE2, BRNE, BRNE2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRCC2, BRCC, BRCC2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRCS2, BRCS, BRCS2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRGE2, BRGE, BRGE2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRLT2, BRLT, BRLT2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRMI2, BRMI, BRMI2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRPL2, BRPL, BRPL2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRLS, BRLS, BRLS, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRGT, BRGT, BRGT, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRLE, BRLE, BRLE, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRHI, BRHI, BRHI, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRVS, BRVS, BRVS, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRVC, BRVC, BRVC, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRQS, BRQS, BRQS, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRAL, BRAL, BRAL, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRHS2, BRHS, BRCC2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(BRLO2, BRLO, BRCS2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL0(BREAKPOINT, BREAKPOINT, BREAKPOINT, AVR32_V1),
++    SYNTAX_NORMAL1(BREV, BREV, BREV, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(BST, BST, BST, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL2(CACHE, CACHE, CACHE, INTREG_SDISP, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL1(CASTS_B, CASTS_B, CASTS_B, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(CASTS_H, CASTS_H, CASTS_H, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(CASTU_B, CASTU_B, CASTU_B, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(CASTU_H, CASTU_H, CASTU_H, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(CBR, CBR, CBR, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL2(CLZ, CLZ, CLZ, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(COM, COM, COM, INTREG, AVR32_V1),
++    SYNTAX_NORMAL5(COP, COP, COP, CPNO, CPREG, CPREG, CPREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL2(CP_B, CP_B, CP_B, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(CP_H, CP_H, CP_H, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(CP_W1, CP_W, CP_W1, CP_W2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(CP_W2, CP_W, CP_W2, CP_W3, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(CP_W3, CP_W, CP_W3, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL_C2(CPC1, CPC, CPC1, CPC2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(CPC2, CPC, CPC2, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(CSRF, CSRF, CSRF, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL1(CSRFCZ, CSRFCZ, CSRFCZ, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL3(DIVS, DIVS, DIVS, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(DIVU, DIVU, DIVU, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(EOR1, EOR, EOR1, EOR2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(EOR2, EOR, EOR2, EOR3, INTREG, INTREG, INTREG_LSL, AVR32_V1),
++    SYNTAX_NORMAL3(EOR3, EOR, EOR3, INTREG, INTREG, INTREG_LSR, AVR32_V1),
++    SYNTAX_NORMAL2(EORL, EORL, EORL, INTREG, UNSIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(EORH, EORH, EORH, INTREG, UNSIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL0(FRS, FRS, FRS, AVR32_V1),
++    SYNTAX_NORMAL1(ICALL, ICALL, ICALL, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(INCJOSP, INCJOSP, INCJOSP, JOSPINC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_D1, LD_D, LD_D1, LD_D2, DWREG, INTREG_POSTINC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_D2, LD_D, LD_D2, LD_D3, DWREG, INTREG_PREDEC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_D3, LD_D, LD_D3, LD_D5, DWREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_D5, LD_D, LD_D5, LD_D4, DWREG, INTREG_INDEX, AVR32_V1),
++    SYNTAX_NORMAL2(LD_D4, LD_D, LD_D4, DWREG, INTREG_SDISP, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_SB2, LD_SB, LD_SB2, LD_SB1, INTREG, INTREG_INDEX, AVR32_V1),
++    SYNTAX_NORMAL2(LD_SB1, LD_SB, LD_SB1, INTREG, INTREG_SDISP, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_UB1, LD_UB, LD_UB1, LD_UB2, INTREG, INTREG_POSTINC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_UB2, LD_UB, LD_UB2, LD_UB5, INTREG, INTREG_PREDEC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_UB5, LD_UB, LD_UB5, LD_UB3, INTREG, INTREG_INDEX, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_UB3, LD_UB, LD_UB3, LD_UB4, INTREG, INTREG_UDISP, AVR32_V1),
++    SYNTAX_NORMAL2(LD_UB4, LD_UB, LD_UB4, INTREG, INTREG_SDISP, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_SH1, LD_SH, LD_SH1, LD_SH2, INTREG, INTREG_POSTINC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_SH2, LD_SH, LD_SH2, LD_SH5, INTREG, INTREG_PREDEC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_SH5, LD_SH, LD_SH5, LD_SH3, INTREG, INTREG_INDEX, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_SH3, LD_SH, LD_SH3, LD_SH4, INTREG, INTREG_UDISP_H, AVR32_V1),
++    SYNTAX_NORMAL2(LD_SH4, LD_SH, LD_SH4, INTREG, INTREG_SDISP, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_UH1, LD_UH, LD_UH1, LD_UH2, INTREG, INTREG_POSTINC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_UH2, LD_UH, LD_UH2, LD_UH5, INTREG, INTREG_PREDEC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_UH5, LD_UH, LD_UH5, LD_UH3, INTREG, INTREG_INDEX, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_UH3, LD_UH, LD_UH3, LD_UH4, INTREG, INTREG_UDISP_H, AVR32_V1),
++    SYNTAX_NORMAL2(LD_UH4, LD_UH, LD_UH4, INTREG, INTREG_SDISP, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_W1, LD_W, LD_W1, LD_W2, INTREG, INTREG_POSTINC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_W2, LD_W, LD_W2, LD_W5, INTREG, INTREG_PREDEC, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_W5, LD_W, LD_W5, LD_W6, INTREG, INTREG_INDEX, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_W6, LD_W, LD_W6, LD_W3, INTREG, INTREG_XINDEX, AVR32_V1),
++    SYNTAX_NORMAL_C2(LD_W3, LD_W, LD_W3, LD_W4, INTREG, INTREG_UDISP_W, AVR32_V1),
++    SYNTAX_NORMAL2(LD_W4, LD_W, LD_W4, INTREG, INTREG_SDISP, AVR32_V1),
++    SYNTAX_NORMAL3(LDC_D1, LDC_D, LDC_D1, CPNO, CPREG_D, INTREG_UDISP_W, AVR32_V1),
++    SYNTAX_NORMAL_C3(LDC_D2, LDC_D, LDC_D2, LDC_D1, CPNO, CPREG_D, INTREG_PREDEC, AVR32_V1),
++    SYNTAX_NORMAL_C3(LDC_D3, LDC_D, LDC_D3, LDC_D2, CPNO, CPREG_D, INTREG_INDEX, AVR32_V1),
++    SYNTAX_NORMAL3(LDC_W1, LDC_W, LDC_W1, CPNO, CPREG, INTREG_UDISP_W, AVR32_V1),
++    SYNTAX_NORMAL_C3(LDC_W2, LDC_W, LDC_W2, LDC_W1, CPNO, CPREG, INTREG_PREDEC, AVR32_V1),
++    SYNTAX_NORMAL_C3(LDC_W3, LDC_W, LDC_W3, LDC_W2, CPNO, CPREG, INTREG_INDEX, AVR32_V1),
++    SYNTAX_NORMAL2(LDC0_D, LDC0_D, LDC0_D, CPREG_D, INTREG_UDISP_W, AVR32_V1),
++    SYNTAX_NORMAL2(LDC0_W, LDC0_W, LDC0_W, CPREG, INTREG_UDISP_W, AVR32_V1),
++    SYNTAX_NORMAL_CM3(LDCM_D, LDCM_D, LDCM_D, LDCM_D_PU, CPNO, INTREG, REGLIST_CPD8, AVR32_V1),
++    SYNTAX_NORMALM3(LDCM_D_PU, LDCM_D, LDCM_D_PU, CPNO, INTREG_POSTINC, REGLIST_CPD8, AVR32_V1),
++    SYNTAX_NORMAL_CM3(LDCM_W, LDCM_W, LDCM_W, LDCM_W_PU, CPNO, INTREG, REGLIST_CP8, AVR32_V1),
++    SYNTAX_NORMALM3(LDCM_W_PU, LDCM_W, LDCM_W_PU, CPNO, INTREG_POSTINC, REGLIST_CP8, AVR32_V1),
++    SYNTAX_NORMAL2(LDDPC, LDDPC, LDDPC, INTREG, PC_UDISP_W, AVR32_V1),
++    SYNTAX_NORMAL2(LDDPC_EXT, LDDPC, LDDPC_EXT, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(LDDSP, LDDSP, LDDSP, INTREG, SP_UDISP_W, AVR32_V1),
++    SYNTAX_NORMAL2(LDINS_B, LDINS_B, LDINS_B, INTREG_BSEL, INTREG_SDISP, AVR32_V1),
++    SYNTAX_NORMAL2(LDINS_H, LDINS_H, LDINS_H, INTREG_HSEL, INTREG_SDISP_H, AVR32_V1),
++    SYNTAX_NORMALM1(LDM, LDM, LDM, REGLIST_LDM, AVR32_V1),
++    SYNTAX_NORMAL_CM2(LDMTS, LDMTS, LDMTS, LDMTS_PU, INTREG, REGLIST16, AVR32_V1),
++    SYNTAX_NORMALM2(LDMTS_PU, LDMTS, LDMTS_PU, INTREG_POSTINC, REGLIST16, AVR32_V1),
++    SYNTAX_NORMAL2(LDSWP_SH, LDSWP_SH, LDSWP_SH, INTREG, INTREG_SDISP_H, AVR32_V1),
++    SYNTAX_NORMAL2(LDSWP_UH, LDSWP_UH, LDSWP_UH, INTREG, INTREG_SDISP_H, AVR32_V1),
++    SYNTAX_NORMAL2(LDSWP_W, LDSWP_W, LDSWP_W, INTREG, INTREG_SDISP_W, AVR32_V1),
++    SYNTAX_NORMAL_C3(LSL1, LSL, LSL1, LSL3, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(LSL3, LSL, LSL3, LSL2, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL2(LSL2, LSL, LSL2, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL_C3(LSR1, LSR, LSR1, LSR3, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(LSR3, LSR, LSR3, LSR2, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL2(LSR2, LSR, LSR2, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL3(MAC, MAC, MAC, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(MACHH_D, MACHH_D, MACHH_D, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MACHH_W, MACHH_W, MACHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MACS_D, MACS_D, MACS_D, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(MACSATHH_W, MACSATHH_W, MACSATHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MACUD, MACU_D, MACUD, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(MACWH_D, MACWH_D, MACWH_D, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MAX, MAX, MAX, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(MCALL, MCALL, MCALL, MCALL, AVR32_V1),
++    SYNTAX_NORMAL2(MFDR, MFDR, MFDR, INTREG, UNSIGNED_CONST_W, AVR32_V1),
++    SYNTAX_NORMAL2(MFSR, MFSR, MFSR, INTREG, UNSIGNED_CONST_W, AVR32_V1),
++    SYNTAX_NORMAL3(MIN, MIN, MIN, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOV3, MOV, MOV3, MOV1, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOV1, MOV, MOV1, MOV2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOV2, MOV, MOV2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVEQ1, MOVEQ, MOVEQ1, MOVEQ2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVNE1, MOVNE, MOVNE1, MOVNE2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVCC1, MOVCC, MOVCC1, MOVCC2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVCS1, MOVCS, MOVCS1, MOVCS2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVGE1, MOVGE, MOVGE1, MOVGE2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVLT1, MOVLT, MOVLT1, MOVLT2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVMI1, MOVMI, MOVMI1, MOVMI2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVPL1, MOVPL, MOVPL1, MOVPL2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVLS1, MOVLS, MOVLS1, MOVLS2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVGT1, MOVGT, MOVGT1, MOVGT2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVLE1, MOVLE, MOVLE1, MOVLE2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVHI1, MOVHI, MOVHI1, MOVHI2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVVS1, MOVVS, MOVVS1, MOVVS2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVVC1, MOVVC, MOVVC1, MOVVC2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVQS1, MOVQS, MOVQS1, MOVQS2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVAL1, MOVAL, MOVAL1, MOVAL2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVHS1, MOVHS, MOVCC1, MOVHS2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MOVLO1, MOVLO, MOVCS1, MOVLO2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(MOVEQ2, MOVEQ, MOVEQ2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVNE2, MOVNE, MOVNE2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVCC2, MOVCC, MOVCC2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVCS2, MOVCS, MOVCS2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVGE2, MOVGE, MOVGE2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVLT2, MOVLT, MOVLT2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVMI2, MOVMI, MOVMI2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVPL2, MOVPL, MOVPL2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVLS2, MOVLS, MOVLS2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVGT2, MOVGT, MOVGT2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVLE2, MOVLE, MOVLE2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVHI2, MOVHI, MOVHI2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVVS2, MOVVS, MOVVS2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVVC2, MOVVC, MOVVC2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVQS2, MOVQS, MOVQS2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVAL2, MOVAL, MOVAL2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVHS2, MOVHS, MOVCC2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MOVLO2, MOVLO, MOVCS2, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(MTDR, MTDR, MTDR, UNSIGNED_CONST_W, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(MTSR, MTSR, MTSR, UNSIGNED_CONST_W, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(MUL1, MUL, MUL1, MUL2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(MUL2, MUL, MUL2, MUL3, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(MUL3, MUL, MUL3, INTREG, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL3(MULHH_W, MULHH_W, MULHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MULNHH_W, MULNHH_W, MULNHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MULNWH_D, MULNWH_D, MULNWH_D, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MULSD, MULS_D, MULSD, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(MULSATHH_H, MULSATHH_H, MULSATHH_H, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MULSATHH_W, MULSATHH_W, MULSATHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MULSATRNDHH_H, MULSATRNDHH_H, MULSATRNDHH_H, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MULSATRNDWH_W, MULSATRNDWH_W, MULSATRNDWH_W, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MULSATWH_W, MULSATWH_W, MULSATWH_W, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL3(MULU_D, MULU_D, MULU_D, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(MULWH_D, MULWH_D, MULWH_D, INTREG, INTREG, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL1(MUSFR, MUSFR, MUSFR, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(MUSTR, MUSTR, MUSTR, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(MVCR_D, MVCR_D, MVCR_D, CPNO, DWREG, CPREG_D, AVR32_V1),
++    SYNTAX_NORMAL3(MVCR_W, MVCR_W, MVCR_W, CPNO, INTREG, CPREG, AVR32_V1),
++    SYNTAX_NORMAL3(MVRC_D, MVRC_D, MVRC_D, CPNO, CPREG_D, DWREG, AVR32_V1),
++    SYNTAX_NORMAL3(MVRC_W, MVRC_W, MVRC_W, CPNO, CPREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(NEG, NEG, NEG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL0(NOP, NOP, NOP, AVR32_V1),
++    SYNTAX_NORMAL_C2(OR1, OR, OR1, OR2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(OR2, OR, OR2, OR3, INTREG, INTREG, INTREG_LSL, AVR32_V1),
++    SYNTAX_NORMAL3(OR3, OR, OR3, INTREG, INTREG, INTREG_LSR, AVR32_V1),
++    SYNTAX_NORMAL2(ORH, ORH, ORH, INTREG, UNSIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(ORL, ORL, ORL, INTREG, UNSIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(PABS_SB, PABS_SB, PABS_SB, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL2(PABS_SH, PABS_SH, PABS_SH, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PACKSH_SB, PACKSH_SB, PACKSH_SB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PACKSH_UB, PACKSH_UB, PACKSH_UB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PACKW_SH, PACKW_SH, PACKW_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADD_B, PADD_B, PADD_B, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADD_H, PADD_H, PADD_H, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDH_SH, PADDH_SH, PADDH_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDH_UB, PADDH_UB, PADDH_UB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDS_SB, PADDS_SB, PADDS_SB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDS_SH, PADDS_SH, PADDS_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDS_UB, PADDS_UB, PADDS_UB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDS_UH, PADDS_UH, PADDS_UH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDSUB_H, PADDSUB_H, PADDSUB_H, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDSUBH_SH, PADDSUBH_SH, PADDSUBH_SH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDSUBS_SH, PADDSUBS_SH, PADDSUBS_SH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDSUBS_UH, PADDSUBS_UH, PADDSUBS_UH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDX_H, PADDX_H, PADDX_H, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDXH_SH, PADDXH_SH, PADDXH_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDXS_SH, PADDXS_SH, PADDXS_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PADDXS_UH, PADDXS_UH, PADDXS_UH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PASR_B, PASR_B, PASR_B, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),
++    SYNTAX_NORMAL3(PASR_H, PASR_H, PASR_H, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),
++    SYNTAX_NORMAL3(PAVG_SH, PAVG_SH, PAVG_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PAVG_UB, PAVG_UB, PAVG_UB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PLSL_B, PLSL_B, PLSL_B, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),
++    SYNTAX_NORMAL3(PLSL_H, PLSL_H, PLSL_H, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),
++    SYNTAX_NORMAL3(PLSR_B, PLSR_B, PLSR_B, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),
++    SYNTAX_NORMAL3(PLSR_H, PLSR_H, PLSR_H, INTREG, INTREG, UNSIGNED_NUMBER, AVR32_SIMD),
++    SYNTAX_NORMAL3(PMAX_SH, PMAX_SH, PMAX_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PMAX_UB, PMAX_UB, PMAX_UB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PMIN_SH, PMIN_SH, PMIN_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PMIN_UB, PMIN_UB, PMIN_UB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL0(POPJC, POPJC, POPJC, AVR32_V1),
++    SYNTAX_NORMAL_CM1(POPM, POPM, POPM, POPM_E, REGLIST9, AVR32_V1),
++    SYNTAX_NORMALM1(POPM_E, POPM, POPM_E, REGLIST16, AVR32_V1),
++    SYNTAX_NORMAL1(PREF, PREF, PREF, INTREG_SDISP, AVR32_V1),
++    SYNTAX_NORMAL3(PSAD, PSAD, PSAD, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUB_B, PSUB_B, PSUB_B, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUB_H, PSUB_H, PSUB_H, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBADD_H, PSUBADD_H, PSUBADD_H, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBADDH_SH, PSUBADDH_SH, PSUBADDH_SH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBADDS_SH, PSUBADDS_SH, PSUBADDS_SH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBADDS_UH, PSUBADDS_UH, PSUBADDS_UH, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBH_SH, PSUBH_SH, PSUBH_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBH_UB, PSUBH_UB, PSUBH_UB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBS_SB, PSUBS_SB, PSUBS_SB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBS_SH, PSUBS_SH, PSUBS_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBS_UB, PSUBS_UB, PSUBS_UB, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBS_UH, PSUBS_UH, PSUBS_UH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBX_H, PSUBX_H, PSUBX_H, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBXH_SH, PSUBXH_SH, PSUBXH_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBXS_SH, PSUBXS_SH, PSUBXS_SH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL3(PSUBXS_UH, PSUBXS_UH, PSUBXS_UH, INTREG, INTREG, INTREG, AVR32_SIMD),
++    SYNTAX_NORMAL2(PUNPCKSB_H, PUNPCKSB_H, PUNPCKSB_H, INTREG, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL2(PUNPCKUB_H, PUNPCKUB_H, PUNPCKUB_H, INTREG, INTREG_HSEL, AVR32_SIMD),
++    SYNTAX_NORMAL0(PUSHJC, PUSHJC, PUSHJC, AVR32_V1),
++    SYNTAX_NORMAL_CM1(PUSHM, PUSHM, PUSHM, PUSHM_E, REGLIST8, AVR32_V1),
++    SYNTAX_NORMALM1(PUSHM_E, PUSHM, PUSHM_E, REGLIST16, AVR32_V1),
++    SYNTAX_NORMAL_C1(RCALL1, RCALL, RCALL1, RCALL2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(RCALL2, RCALL, RCALL2, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(RETEQ, RETEQ, RETEQ, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETNE, RETNE, RETNE, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETCC, RETCC, RETCC, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETCS, RETCS, RETCS, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETGE, RETGE, RETGE, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETLT, RETLT, RETLT, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETMI, RETMI, RETMI, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETPL, RETPL, RETPL, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETLS, RETLS, RETLS, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETGT, RETGT, RETGT, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETLE, RETLE, RETLE, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETHI, RETHI, RETHI, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETVS, RETVS, RETVS, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETVC, RETVC, RETVC, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETQS, RETQS, RETQS, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETAL, RETAL, RETAL, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETHS, RETHS, RETCC, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL1(RETLO, RETLO, RETCS, RETVAL, AVR32_V1),
++    SYNTAX_NORMAL0(RETD, RETD, RETD, AVR32_V1),
++    SYNTAX_NORMAL0(RETE, RETE, RETE, AVR32_V1),
++    SYNTAX_NORMAL0(RETJ, RETJ, RETJ, AVR32_V1),
++    SYNTAX_NORMAL0(RETS, RETS, RETS, AVR32_V1),
++    SYNTAX_NORMAL1(RJMP, RJMP, RJMP, JMPLABEL, AVR32_V1),
++    SYNTAX_NORMAL1(ROL, ROL, ROL, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(ROR, ROR, ROR, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(RSUB1, RSUB, RSUB1, RSUB2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(RSUB2, RSUB, RSUB2, INTREG, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL3(SATADD_H, SATADD_H, SATADD_H, INTREG, INTREG, INTREG,  AVR32_DSP),
++    SYNTAX_NORMAL3(SATADD_W, SATADD_W, SATADD_W, INTREG, INTREG, INTREG, AVR32_DSP),
++    SYNTAX_NORMAL2(SATRNDS, SATRNDS, SATRNDS, INTREG_LSR, UNSIGNED_NUMBER, AVR32_DSP),
++    SYNTAX_NORMAL2(SATRNDU, SATRNDU, SATRNDU, INTREG_LSR, UNSIGNED_NUMBER, AVR32_DSP),
++    SYNTAX_NORMAL2(SATS, SATS, SATS, INTREG_LSR, UNSIGNED_NUMBER, AVR32_DSP),
++    SYNTAX_NORMAL3(SATSUB_H, SATSUB_H, SATSUB_H, INTREG, INTREG, INTREG, AVR32_DSP),
++    SYNTAX_NORMAL_C3(SATSUB_W1, SATSUB_W, SATSUB_W1, SATSUB_W2, INTREG, INTREG, INTREG, AVR32_DSP),
++    SYNTAX_NORMAL3(SATSUB_W2, SATSUB_W, SATSUB_W2, INTREG, INTREG, SIGNED_CONST, AVR32_DSP),
++    SYNTAX_NORMAL2(SATU, SATU, SATU, INTREG_LSR, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL3(SBC, SBC, SBC, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(SBR, SBR, SBR, INTREG, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL0(SCALL, SCALL, SCALL, AVR32_V1),
++    SYNTAX_NORMAL1(SCR, SCR, SCR, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SLEEP, SLEEP, SLEEP, UNSIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL1(SREQ, SREQ, SREQ, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRNE, SRNE, SRNE, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRCC, SRCC, SRCC, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRCS, SRCS, SRCS, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRGE, SRGE, SRGE, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRLT, SRLT, SRLT, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRMI, SRMI, SRMI, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRPL, SRPL, SRPL, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRLS, SRLS, SRLS, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRGT, SRGT, SRGT, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRLE, SRLE, SRLE, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRHI, SRHI, SRHI, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRVS, SRVS, SRVS, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRVC, SRVC, SRVC, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRQS, SRQS, SRQS, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRAL, SRAL, SRAL, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRHS, SRHS, SRCC, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SRLO, SRLO, SRCS, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SSRF, SSRF, SSRF, UNSIGNED_NUMBER, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_B1, ST_B, ST_B1, ST_B2, INTREG_POSTINC, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_B2, ST_B, ST_B2, ST_B5, INTREG_PREDEC, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_B5, ST_B, ST_B5, ST_B3, INTREG_INDEX, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_B3, ST_B, ST_B3, ST_B4, INTREG_UDISP, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(ST_B4, ST_B, ST_B4, INTREG_SDISP, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_D1, ST_D, ST_D1, ST_D2, INTREG_POSTINC, DWREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_D2, ST_D, ST_D2, ST_D3, INTREG_PREDEC, DWREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_D3, ST_D, ST_D3, ST_D5, INTREG, DWREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_D5, ST_D, ST_D5, ST_D4, INTREG_INDEX, DWREG, AVR32_V1),
++    SYNTAX_NORMAL2(ST_D4, ST_D, ST_D4, INTREG_SDISP, DWREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_H1, ST_H, ST_H1, ST_H2, INTREG_POSTINC, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_H2, ST_H, ST_H2, ST_H5, INTREG_PREDEC, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_H5, ST_H, ST_H5, ST_H3, INTREG_INDEX, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_H3, ST_H, ST_H3, ST_H4, INTREG_UDISP_H, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(ST_H4, ST_H, ST_H4, INTREG_SDISP, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_W1, ST_W, ST_W1, ST_W2, INTREG_POSTINC, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_W2, ST_W, ST_W2, ST_W5, INTREG_PREDEC, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_W5, ST_W, ST_W5, ST_W3, INTREG_INDEX, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(ST_W3, ST_W, ST_W3, ST_W4, INTREG_UDISP_W, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(ST_W4, ST_W, ST_W4, INTREG_SDISP, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(STC_D1, STC_D, STC_D1, CPNO, INTREG_UDISP_W, CPREG_D, AVR32_V1),
++    SYNTAX_NORMAL_C3(STC_D2, STC_D, STC_D2, STC_D1, CPNO, INTREG_POSTINC, CPREG_D, AVR32_V1),
++    SYNTAX_NORMAL_C3(STC_D3, STC_D, STC_D3, STC_D2, CPNO, INTREG_INDEX, CPREG_D, AVR32_V1),
++    SYNTAX_NORMAL3(STC_W1, STC_W, STC_W1, CPNO, INTREG_UDISP_W, CPREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(STC_W2, STC_W, STC_W2, STC_W1, CPNO, INTREG_POSTINC, CPREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(STC_W3, STC_W, STC_W3, STC_W2, CPNO, INTREG_INDEX, CPREG, AVR32_V1),
++    SYNTAX_NORMAL2(STC0_D, STC0_D, STC0_D, INTREG_UDISP_W, CPREG_D, AVR32_V1),
++    SYNTAX_NORMAL2(STC0_W, STC0_W, STC0_W, INTREG_UDISP_W, CPREG, AVR32_V1),
++    SYNTAX_NORMAL_CM3(STCM_D, STCM_D, STCM_D, STCM_D_PU, CPNO, INTREG, REGLIST_CPD8, AVR32_V1),
++    SYNTAX_NORMALM3(STCM_D_PU, STCM_D, STCM_D_PU, CPNO, INTREG_PREDEC, REGLIST_CPD8, AVR32_V1),
++    SYNTAX_NORMAL_CM3(STCM_W, STCM_W, STCM_W, STCM_W_PU, CPNO, INTREG, REGLIST_CP8, AVR32_V1),
++    SYNTAX_NORMALM3(STCM_W_PU, STCM_W, STCM_W_PU, CPNO, INTREG_PREDEC, REGLIST_CP8, AVR32_V1),
++    SYNTAX_NORMAL2(STCOND, STCOND, STCOND, INTREG_SDISP, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(STDSP, STDSP, STDSP, SP_UDISP_W, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(STHH_W2, STHH_W, STHH_W2, STHH_W1, INTREG_INDEX, INTREG_HSEL, INTREG_HSEL, AVR32_V1),
++    SYNTAX_NORMAL3(STHH_W1, STHH_W, STHH_W1, INTREG_UDISP_W, INTREG_HSEL, INTREG_HSEL, AVR32_V1),
++    SYNTAX_NORMAL_CM2(STM, STM, STM, STM_PU, INTREG, REGLIST16, AVR32_V1),
++    SYNTAX_NORMALM2(STM_PU, STM, STM_PU, INTREG_PREDEC, REGLIST16, AVR32_V1),
++    SYNTAX_NORMAL_CM2(STMTS, STMTS, STMTS, STMTS_PU, INTREG, REGLIST16, AVR32_V1),
++    SYNTAX_NORMALM2(STMTS_PU, STMTS, STMTS_PU, INTREG_PREDEC, REGLIST16, AVR32_V1),
++    SYNTAX_NORMAL2(STSWP_H, STSWP_H, STSWP_H, INTREG_SDISP_H, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(STSWP_W, STSWP_W, STSWP_W, INTREG_SDISP_W, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C2(SUB1, SUB, SUB1, SUB2, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL_C3(SUB2, SUB, SUB2, SUB5, INTREG, INTREG, INTREG_LSL, AVR32_V1),
++    SYNTAX_NORMAL_C3(SUB5, SUB, SUB5, SUB3_SP, INTREG, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL_C2(SUB3_SP, SUB, SUB3_SP, SUB3, SP, SIGNED_CONST_W, AVR32_V1),
++    SYNTAX_NORMAL_C2(SUB3, SUB, SUB3, SUB4, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUB4, SUB, SUB4, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBEQ, SUBEQ, SUBEQ, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBNE, SUBNE, SUBNE, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBCC, SUBCC, SUBCC, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBCS, SUBCS, SUBCS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBGE, SUBGE, SUBGE, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBLT, SUBLT, SUBLT, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBMI, SUBMI, SUBMI, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBPL, SUBPL, SUBPL, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBLS, SUBLS, SUBLS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBGT, SUBGT, SUBGT, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBLE, SUBLE, SUBLE, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBHI, SUBHI, SUBHI, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBVS, SUBVS, SUBVS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBVC, SUBVC, SUBVC, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBQS, SUBQS, SUBQS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBAL, SUBAL, SUBAL, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBHS, SUBHS, SUBCC, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBLO, SUBLO, SUBCS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFEQ, SUBFEQ, SUBFEQ, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFNE, SUBFNE, SUBFNE, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFCC, SUBFCC, SUBFCC, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFCS, SUBFCS, SUBFCS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFGE, SUBFGE, SUBFGE, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFLT, SUBFLT, SUBFLT, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFMI, SUBFMI, SUBFMI, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFPL, SUBFPL, SUBFPL, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFLS, SUBFLS, SUBFLS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFGT, SUBFGT, SUBFGT, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFLE, SUBFLE, SUBFLE, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFHI, SUBFHI, SUBFHI, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFVS, SUBFVS, SUBFVS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFVC, SUBFVC, SUBFVC, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFQS, SUBFQS, SUBFQS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFAL, SUBFAL, SUBFAL, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFHS, SUBFHS, SUBFCC, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL2(SUBFLO, SUBFLO, SUBFCS, INTREG, SIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL3(SUBHH_W, SUBHH_W, SUBHH_W, INTREG, INTREG_HSEL, INTREG_HSEL, AVR32_DSP),
++    SYNTAX_NORMAL1(SWAP_B, SWAP_B, SWAP_B, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SWAP_BH, SWAP_BH, SWAP_BH, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SWAP_H, SWAP_H, SWAP_H, INTREG, AVR32_V1),
++    SYNTAX_NORMAL1(SYNC, SYNC, SYNC, UNSIGNED_CONST, AVR32_V1),
++    SYNTAX_NORMAL0(TLBR, TLBR, TLBR, AVR32_V1),
++    SYNTAX_NORMAL0(TLBS, TLBS, TLBS, AVR32_V1),
++    SYNTAX_NORMAL0(TLBW, TLBW, TLBW, AVR32_V1),
++    SYNTAX_NORMAL1(TNBZ, TNBZ, TNBZ, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(TST, TST, TST, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL3(XCHG, XCHG, XCHG, INTREG, INTREG, INTREG, AVR32_V1),
++    SYNTAX_NORMAL2(MEMC, MEMC, MEMC, SIGNED_CONST_W, UNSIGNED_NUMBER, AVR32_RMW),
++    SYNTAX_NORMAL2(MEMS, MEMS, MEMS, SIGNED_CONST_W, UNSIGNED_NUMBER, AVR32_RMW),
++    SYNTAX_NORMAL2(MEMT, MEMT, MEMT, SIGNED_CONST_W, UNSIGNED_NUMBER, AVR32_RMW),
++    SYNTAX_FP(FADD, 3),
++    SYNTAX_FP(FSUB, 3),
++    SYNTAX_FP(FMAC, 3),
++    SYNTAX_FP(FNMAC, 3),
++    SYNTAX_FP(FMSC, 3),
++    SYNTAX_FP(FNMSC, 3),
++    SYNTAX_FP(FMUL, 3),
++    SYNTAX_FP(FNMUL, 3),
++    SYNTAX_FP(FNEG, 2),
++    SYNTAX_FP(FABS, 2),
++    SYNTAX_FP(FCMP, 2),
++    {
++      AVR32_SYNTAX_FMOV1_S,
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV1_S] },
++      &avr32_syntax_table[AVR32_SYNTAX_FMOV2_S],
++      2,
++      {
++      AVR32_OPERAND_FPREG_S,
++      AVR32_OPERAND_FPREG_S,
++      },
++    },
++    {
++      AVR32_SYNTAX_FMOV1_D,
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV1_D] },
++      &avr32_syntax_table[AVR32_SYNTAX_FMOV2_D],
++      2,
++      {
++      AVR32_OPERAND_FPREG_D,
++      AVR32_OPERAND_FPREG_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_FMOV2_S,
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV2_S] },
++      &avr32_syntax_table[AVR32_SYNTAX_FMOV3_S],
++      2,
++      {
++      AVR32_OPERAND_INTREG,
++      AVR32_OPERAND_FPREG_S,
++      },
++    },
++    {
++      AVR32_SYNTAX_FMOV2_D,
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV2_D] },
++      &avr32_syntax_table[AVR32_SYNTAX_FMOV3_D],
++      2,
++      {
++      AVR32_OPERAND_DWREG,
++      AVR32_OPERAND_FPREG_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_FMOV3_S,
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV3_S] }, NULL,
++      2,
++      {
++      AVR32_OPERAND_FPREG_S,
++      AVR32_OPERAND_INTREG,
++      },
++    },
++    {
++      AVR32_SYNTAX_FMOV3_D,
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_FMOV3_D] }, NULL,
++      2,
++      {
++      AVR32_OPERAND_FPREG_D,
++      AVR32_OPERAND_DWREG,
++      },
++    },
++    {
++      AVR32_SYNTAX_FCASTS_D,
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_FCASTS_D] }, NULL,
++      2,
++      {
++      AVR32_OPERAND_FPREG_S,
++      AVR32_OPERAND_FPREG_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_FCASTD_S,
++      AVR32_FP, NULL, AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_FCASTD_S] }, NULL,
++      2,
++      {
++      AVR32_OPERAND_FPREG_D,
++      AVR32_OPERAND_FPREG_S,
++      },
++    },
++    {
++      AVR32_SYNTAX_LDA_W,
++      AVR32_V1, NULL, AVR32_PARSER_LDA,
++      { NULL }, NULL,
++      2,
++      {
++      AVR32_OPERAND_INTREG,
++      AVR32_OPERAND_SIGNED_CONST,
++      },
++    },
++    {
++      AVR32_SYNTAX_CALL,
++      AVR32_V1, NULL, AVR32_PARSER_CALL,
++      { NULL }, NULL,
++      1,
++      {
++      AVR32_OPERAND_JMPLABEL,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSVMAC0,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMAC], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMAC0] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMAC1], 4,
++      {
++      AVR32_OPERAND_PICO_OUT0,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSVMAC1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMAC], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMAC1] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMAC2], 4,
++      {
++      AVR32_OPERAND_PICO_OUT1,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSVMAC2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMAC], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMAC2] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMAC3], 4,
++      {
++      AVR32_OPERAND_PICO_OUT2,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSVMAC3,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMAC], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMAC3] },
++      NULL, 4,
++      {
++      AVR32_OPERAND_PICO_OUT3,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSVMUL0,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMUL], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMUL0] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMUL1], 4,
++      {
++      AVR32_OPERAND_PICO_OUT0,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSVMUL1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMUL], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMUL1] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMUL2], 4,
++      {
++      AVR32_OPERAND_PICO_OUT1,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSVMUL2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMUL], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMUL2] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOSVMUL3], 4,
++      {
++      AVR32_OPERAND_PICO_OUT2,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSVMUL3,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSVMUL], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSVMUL3] },
++      NULL, 4,
++      {
++      AVR32_OPERAND_PICO_OUT3,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOVMAC0,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMAC], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMAC0] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOVMAC1], 4,
++      {
++      AVR32_OPERAND_PICO_OUT0,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOVMAC1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMAC], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMAC1] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOVMAC2], 4,
++      {
++      AVR32_OPERAND_PICO_OUT1,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOVMAC2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMAC], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMAC2] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOVMAC3], 4,
++      {
++      AVR32_OPERAND_PICO_OUT2,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOVMAC3,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMAC], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMAC3] },
++      NULL, 4,
++      {
++      AVR32_OPERAND_PICO_OUT3,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOVMUL0,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMUL], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMUL0] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOVMUL1], 4,
++      {
++      AVR32_OPERAND_PICO_OUT0,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOVMUL1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMUL], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMUL1] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOVMUL2], 4,
++      {
++      AVR32_OPERAND_PICO_OUT1,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOVMUL2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMUL], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMUL2] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOVMUL3], 4,
++      {
++      AVR32_OPERAND_PICO_OUT2,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOVMUL3,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOVMUL], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOVMUL3] },
++      NULL, 4,
++      {
++      AVR32_OPERAND_PICO_OUT3,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      AVR32_OPERAND_PICO_IN,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLD_D2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_D2] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOLD_D3], 2,
++      {
++      AVR32_OPERAND_PICO_REG_D,
++      AVR32_OPERAND_INTREG_PREDEC,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLD_D3,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_D3] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOLD_D1], 2,
++      {
++      AVR32_OPERAND_PICO_REG_D,
++      AVR32_OPERAND_INTREG_INDEX,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLD_D1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_D1] },
++      NULL, 2,
++      {
++      AVR32_OPERAND_PICO_REG_D,
++      AVR32_OPERAND_INTREG_UDISP_W,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLD_W2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_W2] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOLD_W3], 2,
++      {
++      AVR32_OPERAND_PICO_REG_W,
++      AVR32_OPERAND_INTREG_PREDEC,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLD_W3,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_W3] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOLD_W1], 2,
++      {
++      AVR32_OPERAND_PICO_REG_W,
++      AVR32_OPERAND_INTREG_INDEX,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLD_W1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLD_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLD_W1] },
++      NULL, 2,
++      {
++      AVR32_OPERAND_PICO_REG_W,
++      AVR32_OPERAND_INTREG_UDISP_W,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLDM_D,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLDM_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLDM_D] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOLDM_D_PU], -2,
++      {
++      AVR32_OPERAND_INTREG,
++      AVR32_OPERAND_PICO_REGLIST_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLDM_D_PU,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLDM_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLDM_D_PU] },
++      NULL, -2,
++      {
++      AVR32_OPERAND_INTREG_POSTINC,
++      AVR32_OPERAND_PICO_REGLIST_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLDM_W,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLDM_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLDM_W] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOLDM_W_PU], -2,
++      {
++      AVR32_OPERAND_INTREG,
++      AVR32_OPERAND_PICO_REGLIST_W,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOLDM_W_PU,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOLDM_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOLDM_W_PU] },
++      NULL, -2,
++      {
++      AVR32_OPERAND_INTREG_POSTINC,
++      AVR32_OPERAND_PICO_REGLIST_W,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOMV_D1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOMV_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOMV_D1] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOMV_D2], 2,
++      {
++      AVR32_OPERAND_DWREG,
++      AVR32_OPERAND_PICO_REG_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOMV_D2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOMV_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOMV_D2] },
++      NULL, 2,
++      {
++      AVR32_OPERAND_PICO_REG_D,
++      AVR32_OPERAND_DWREG,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOMV_W1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOMV_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOMV_W1] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOMV_W2], 2,
++      {
++      AVR32_OPERAND_INTREG,
++      AVR32_OPERAND_PICO_REG_W,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOMV_W2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOMV_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOMV_W2] },
++      NULL, 2,
++      {
++      AVR32_OPERAND_PICO_REG_W,
++      AVR32_OPERAND_INTREG,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOST_D2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_D2] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOST_D3], 2,
++      {
++      AVR32_OPERAND_INTREG_POSTINC,
++      AVR32_OPERAND_PICO_REG_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOST_D3,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_D3] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOST_D1], 2,
++      {
++      AVR32_OPERAND_INTREG_INDEX,
++      AVR32_OPERAND_PICO_REG_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOST_D1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_D1] },
++      NULL, 2,
++      {
++      AVR32_OPERAND_INTREG_UDISP_W,
++      AVR32_OPERAND_PICO_REG_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOST_W2,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_W2] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOST_W3], 2,
++      {
++      AVR32_OPERAND_INTREG_POSTINC,
++      AVR32_OPERAND_PICO_REG_W,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOST_W3,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_W3] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOST_W1], 2,
++      {
++      AVR32_OPERAND_INTREG_INDEX,
++      AVR32_OPERAND_PICO_REG_W,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOST_W1,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOST_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOST_W1] },
++      NULL, 2,
++      {
++      AVR32_OPERAND_INTREG_UDISP_W,
++      AVR32_OPERAND_PICO_REG_W,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSTM_D,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSTM_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSTM_D] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOSTM_D_PU], -2,
++      {
++      AVR32_OPERAND_INTREG,
++      AVR32_OPERAND_PICO_REGLIST_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSTM_D_PU,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSTM_D], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSTM_D_PU] },
++      NULL, -2,
++      {
++      AVR32_OPERAND_INTREG_PREDEC,
++      AVR32_OPERAND_PICO_REGLIST_D,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSTM_W,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSTM_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSTM_W] },
++      &avr32_syntax_table[AVR32_SYNTAX_PICOSTM_W_PU], -2,
++      {
++      AVR32_OPERAND_INTREG,
++      AVR32_OPERAND_PICO_REGLIST_W,
++      },
++    },
++    {
++      AVR32_SYNTAX_PICOSTM_W_PU,
++      AVR32_PICO, &avr32_mnemonic_table[AVR32_MNEMONIC_PICOSTM_W], AVR32_PARSER_ALIAS,
++      { .alias = &avr32_alias_table[AVR32_ALIAS_PICOSTM_W_PU] },
++      NULL, -2,
++      {
++      AVR32_OPERAND_INTREG_PREDEC,
++      AVR32_OPERAND_PICO_REGLIST_W,
++      },
++    },
++  };
++
++#define NORMAL_MNEMONIC(name, syntax, str)            \
++  {                                                   \
++    AVR32_MNEMONIC_##name, str,                               \
++    &avr32_syntax_table[AVR32_SYNTAX_##syntax],               \
++  }
++#define FP_MNEMONIC(name, syntax, str)                        \
++  NORMAL_MNEMONIC(name##_S, syntax##_S, str ".s"),    \
++  NORMAL_MNEMONIC(name##_D, syntax##_D, str ".d")
++
++const struct avr32_mnemonic avr32_mnemonic_table[] =
++  {
++    NORMAL_MNEMONIC(ABS, ABS, "abs"),
++    NORMAL_MNEMONIC(ACALL, ACALL, "acall"),
++    NORMAL_MNEMONIC(ACR, ACR, "acr"),
++    NORMAL_MNEMONIC(ADC, ADC, "adc"),
++    NORMAL_MNEMONIC(ADD, ADD1, "add"),
++    NORMAL_MNEMONIC(ADDABS, ADDABS, "addabs"),
++    NORMAL_MNEMONIC(ADDHH_W, ADDHH_W, "addhh.w"),
++    NORMAL_MNEMONIC(AND, AND1, "and"),
++    NORMAL_MNEMONIC(ANDH, ANDH, "andh"),
++    NORMAL_MNEMONIC(ANDL, ANDL, "andl"),
++    NORMAL_MNEMONIC(ANDN, ANDN, "andn"),
++    NORMAL_MNEMONIC(ASR, ASR1, "asr"),
++    NORMAL_MNEMONIC(BFEXTS, BFEXTS, "bfexts"),
++    NORMAL_MNEMONIC(BFEXTU, BFEXTU, "bfextu"),
++    NORMAL_MNEMONIC(BFINS, BFINS, "bfins"),
++    NORMAL_MNEMONIC(BLD, BLD, "bld"),
++    NORMAL_MNEMONIC(BREQ, BREQ1, "breq"),
++    NORMAL_MNEMONIC(BRNE, BRNE1, "brne"),
++    NORMAL_MNEMONIC(BRCC, BRCC1, "brcc"),
++    NORMAL_MNEMONIC(BRCS, BRCS1, "brcs"),
++    NORMAL_MNEMONIC(BRGE, BRGE1, "brge"),
++    NORMAL_MNEMONIC(BRLT, BRLT1, "brlt"),
++    NORMAL_MNEMONIC(BRMI, BRMI1, "brmi"),
++    NORMAL_MNEMONIC(BRPL, BRPL1, "brpl"),
++    NORMAL_MNEMONIC(BRHS, BRHS1, "brhs"),
++    NORMAL_MNEMONIC(BRLO, BRLO1, "brlo"),
++    NORMAL_MNEMONIC(BRLS, BRLS, "brls"),
++    NORMAL_MNEMONIC(BRGT, BRGT, "brgt"),
++    NORMAL_MNEMONIC(BRLE, BRLE, "brle"),
++    NORMAL_MNEMONIC(BRHI, BRHI, "brhi"),
++    NORMAL_MNEMONIC(BRVS, BRVS, "brvs"),
++    NORMAL_MNEMONIC(BRVC, BRVC, "brvc"),
++    NORMAL_MNEMONIC(BRQS, BRQS, "brqs"),
++    NORMAL_MNEMONIC(BRAL, BRAL, "bral"),
++    NORMAL_MNEMONIC(BREAKPOINT, BREAKPOINT, "breakpoint"),
++    NORMAL_MNEMONIC(BREV, BREV, "brev"),
++    NORMAL_MNEMONIC(BST, BST, "bst"),
++    NORMAL_MNEMONIC(CACHE, CACHE, "cache"),
++    NORMAL_MNEMONIC(CASTS_B, CASTS_B, "casts.b"),
++    NORMAL_MNEMONIC(CASTS_H, CASTS_H, "casts.h"),
++    NORMAL_MNEMONIC(CASTU_B, CASTU_B, "castu.b"),
++    NORMAL_MNEMONIC(CASTU_H, CASTU_H, "castu.h"),
++    NORMAL_MNEMONIC(CBR, CBR, "cbr"),
++    NORMAL_MNEMONIC(CLZ, CLZ, "clz"),
++    NORMAL_MNEMONIC(COM, COM, "com"),
++    NORMAL_MNEMONIC(COP, COP, "cop"),
++    NORMAL_MNEMONIC(CP_B, CP_B, "cp.b"),
++    NORMAL_MNEMONIC(CP_H, CP_H, "cp.h"),
++    NORMAL_MNEMONIC(CP_W, CP_W1, "cp.w"),
++    NORMAL_MNEMONIC(CP, CP_W1, "cp"),
++    NORMAL_MNEMONIC(CPC, CPC1, "cpc"),
++    NORMAL_MNEMONIC(CSRF, CSRF, "csrf"),
++    NORMAL_MNEMONIC(CSRFCZ, CSRFCZ, "csrfcz"),
++    NORMAL_MNEMONIC(DIVS, DIVS, "divs"),
++    NORMAL_MNEMONIC(DIVU, DIVU, "divu"),
++    NORMAL_MNEMONIC(EOR, EOR1, "eor"),
++    NORMAL_MNEMONIC(EORL, EORL, "eorl"),
++    NORMAL_MNEMONIC(EORH, EORH, "eorh"),
++    NORMAL_MNEMONIC(FRS, FRS, "frs"),
++    NORMAL_MNEMONIC(ICALL, ICALL, "icall"),
++    NORMAL_MNEMONIC(INCJOSP, INCJOSP, "incjosp"),
++    NORMAL_MNEMONIC(LD_D, LD_D1, "ld.d"),
++    NORMAL_MNEMONIC(LD_SB, LD_SB2, "ld.sb"),
++    NORMAL_MNEMONIC(LD_UB, LD_UB1, "ld.ub"),
++    NORMAL_MNEMONIC(LD_SH, LD_SH1, "ld.sh"),
++    NORMAL_MNEMONIC(LD_UH, LD_UH1, "ld.uh"),
++    NORMAL_MNEMONIC(LD_W, LD_W1, "ld.w"),
++    NORMAL_MNEMONIC(LDC_D, LDC_D3, "ldc.d"),
++    NORMAL_MNEMONIC(LDC_W, LDC_W3, "ldc.w"),
++    NORMAL_MNEMONIC(LDC0_D, LDC0_D, "ldc0.d"),
++    NORMAL_MNEMONIC(LDC0_W, LDC0_W, "ldc0.w"),
++    NORMAL_MNEMONIC(LDCM_D, LDCM_D, "ldcm.d"),
++    NORMAL_MNEMONIC(LDCM_W, LDCM_W, "ldcm.w"),
++    NORMAL_MNEMONIC(LDDPC, LDDPC, "lddpc"),
++    NORMAL_MNEMONIC(LDDSP, LDDSP, "lddsp"),
++    NORMAL_MNEMONIC(LDINS_B, LDINS_B, "ldins.b"),
++    NORMAL_MNEMONIC(LDINS_H, LDINS_H, "ldins.h"),
++    NORMAL_MNEMONIC(LDM, LDM, "ldm"),
++    NORMAL_MNEMONIC(LDMTS, LDMTS, "ldmts"),
++    NORMAL_MNEMONIC(LDSWP_SH, LDSWP_SH, "ldswp.sh"),
++    NORMAL_MNEMONIC(LDSWP_UH, LDSWP_UH, "ldswp.uh"),
++    NORMAL_MNEMONIC(LDSWP_W, LDSWP_W, "ldswp.w"),
++    NORMAL_MNEMONIC(LSL, LSL1, "lsl"),
++    NORMAL_MNEMONIC(LSR, LSR1, "lsr"),
++    NORMAL_MNEMONIC(MAC, MAC, "mac"),
++    NORMAL_MNEMONIC(MACHH_D, MACHH_D, "machh.d"),
++    NORMAL_MNEMONIC(MACHH_W, MACHH_W, "machh.w"),
++    NORMAL_MNEMONIC(MACS_D, MACS_D, "macs.d"),
++    NORMAL_MNEMONIC(MACSATHH_W, MACSATHH_W, "macsathh.w"),
++    NORMAL_MNEMONIC(MACU_D, MACUD, "macu.d"),
++    NORMAL_MNEMONIC(MACWH_D, MACWH_D, "macwh.d"),
++    NORMAL_MNEMONIC(MAX, MAX, "max"),
++    NORMAL_MNEMONIC(MCALL, MCALL, "mcall"),
++    NORMAL_MNEMONIC(MFDR, MFDR, "mfdr"),
++    NORMAL_MNEMONIC(MFSR, MFSR, "mfsr"),
++    NORMAL_MNEMONIC(MIN, MIN, "min"),
++    NORMAL_MNEMONIC(MOV, MOV3, "mov"),
++    NORMAL_MNEMONIC(MOVEQ, MOVEQ1, "moveq"),
++    NORMAL_MNEMONIC(MOVNE, MOVNE1, "movne"),
++    NORMAL_MNEMONIC(MOVCC, MOVCC1, "movcc"),
++    NORMAL_MNEMONIC(MOVCS, MOVCS1, "movcs"),
++    NORMAL_MNEMONIC(MOVGE, MOVGE1, "movge"),
++    NORMAL_MNEMONIC(MOVLT, MOVLT1, "movlt"),
++    NORMAL_MNEMONIC(MOVMI, MOVMI1, "movmi"),
++    NORMAL_MNEMONIC(MOVPL, MOVPL1, "movpl"),
++    NORMAL_MNEMONIC(MOVLS, MOVLS1, "movls"),
++    NORMAL_MNEMONIC(MOVGT, MOVGT1, "movgt"),
++    NORMAL_MNEMONIC(MOVLE, MOVLE1, "movle"),
++    NORMAL_MNEMONIC(MOVHI, MOVHI1, "movhi"),
++    NORMAL_MNEMONIC(MOVVS, MOVVS1, "movvs"),
++    NORMAL_MNEMONIC(MOVVC, MOVVC1, "movvc"),
++    NORMAL_MNEMONIC(MOVQS, MOVQS1, "movqs"),
++    NORMAL_MNEMONIC(MOVAL, MOVAL1, "moval"),
++    NORMAL_MNEMONIC(MOVHS, MOVHS1, "movhs"),
++    NORMAL_MNEMONIC(MOVLO, MOVLO1, "movlo"),
++    NORMAL_MNEMONIC(MTDR, MTDR, "mtdr"),
++    NORMAL_MNEMONIC(MTSR, MTSR, "mtsr"),
++    NORMAL_MNEMONIC(MUL, MUL1, "mul"),
++    NORMAL_MNEMONIC(MULHH_W, MULHH_W, "mulhh.w"),
++    NORMAL_MNEMONIC(MULNHH_W, MULNHH_W, "mulnhh.w"),
++    NORMAL_MNEMONIC(MULNWH_D, MULNWH_D, "mulnwh.d"),
++    NORMAL_MNEMONIC(MULS_D, MULSD, "muls.d"),
++    NORMAL_MNEMONIC(MULSATHH_H, MULSATHH_H, "mulsathh.h"),
++    NORMAL_MNEMONIC(MULSATHH_W, MULSATHH_W, "mulsathh.w"),
++    NORMAL_MNEMONIC(MULSATRNDHH_H, MULSATRNDHH_H, "mulsatrndhh.h"),
++    NORMAL_MNEMONIC(MULSATRNDWH_W, MULSATRNDWH_W, "mulsatrndwh.w"),
++    NORMAL_MNEMONIC(MULSATWH_W, MULSATWH_W, "mulsatwh.w"),
++    NORMAL_MNEMONIC(MULU_D, MULU_D, "mulu.d"),
++    NORMAL_MNEMONIC(MULWH_D, MULWH_D, "mulwh.d"),
++    NORMAL_MNEMONIC(MUSFR, MUSFR, "musfr"),
++    NORMAL_MNEMONIC(MUSTR, MUSTR, "mustr"),
++    NORMAL_MNEMONIC(MVCR_D, MVCR_D, "mvcr.d"),
++    NORMAL_MNEMONIC(MVCR_W, MVCR_W, "mvcr.w"),
++    NORMAL_MNEMONIC(MVRC_D, MVRC_D, "mvrc.d"),
++    NORMAL_MNEMONIC(MVRC_W, MVRC_W, "mvrc.w"),
++    NORMAL_MNEMONIC(NEG, NEG, "neg"),
++    NORMAL_MNEMONIC(NOP, NOP, "nop"),
++    NORMAL_MNEMONIC(OR, OR1, "or"),
++    NORMAL_MNEMONIC(ORH, ORH, "orh"),
++    NORMAL_MNEMONIC(ORL, ORL, "orl"),
++    NORMAL_MNEMONIC(PABS_SB, PABS_SB, "pabs.sb"),
++    NORMAL_MNEMONIC(PABS_SH, PABS_SH, "pabs.sh"),
++    NORMAL_MNEMONIC(PACKSH_SB, PACKSH_SB, "packsh.sb"),
++    NORMAL_MNEMONIC(PACKSH_UB, PACKSH_UB, "packsh.ub"),
++    NORMAL_MNEMONIC(PACKW_SH, PACKW_SH, "packw.sh"),
++    NORMAL_MNEMONIC(PADD_B, PADD_B, "padd.b"),
++    NORMAL_MNEMONIC(PADD_H, PADD_H, "padd.h"),
++    NORMAL_MNEMONIC(PADDH_SH, PADDH_SH, "paddh.sh"),
++    NORMAL_MNEMONIC(PADDH_UB, PADDH_UB, "paddh.ub"),
++    NORMAL_MNEMONIC(PADDS_SB, PADDS_SB, "padds.sb"),
++    NORMAL_MNEMONIC(PADDS_SH, PADDS_SH, "padds.sh"),
++    NORMAL_MNEMONIC(PADDS_UB, PADDS_UB, "padds.ub"),
++    NORMAL_MNEMONIC(PADDS_UH, PADDS_UH, "padds.uh"),
++    NORMAL_MNEMONIC(PADDSUB_H, PADDSUB_H, "paddsub.h"),
++    NORMAL_MNEMONIC(PADDSUBH_SH, PADDSUBH_SH, "paddsubh.sh"),
++    NORMAL_MNEMONIC(PADDSUBS_SH, PADDSUBS_SH, "paddsubs.sh"),
++    NORMAL_MNEMONIC(PADDSUBS_UH, PADDSUBS_UH, "paddsubs.uh"),
++    NORMAL_MNEMONIC(PADDX_H, PADDX_H, "paddx.h"),
++    NORMAL_MNEMONIC(PADDXH_SH, PADDXH_SH, "paddxh.sh"),
++    NORMAL_MNEMONIC(PADDXS_SH, PADDXS_SH, "paddxs.sh"),
++    NORMAL_MNEMONIC(PADDXS_UH, PADDXS_UH, "paddxs.uh"),
++    NORMAL_MNEMONIC(PASR_B, PASR_B, "pasr.b"),
++    NORMAL_MNEMONIC(PASR_H, PASR_H, "pasr.h"),
++    NORMAL_MNEMONIC(PAVG_SH, PAVG_SH, "pavg.sh"),
++    NORMAL_MNEMONIC(PAVG_UB, PAVG_UB, "pavg.ub"),
++    NORMAL_MNEMONIC(PLSL_B, PLSL_B, "plsl.b"),
++    NORMAL_MNEMONIC(PLSL_H, PLSL_H, "plsl.h"),
++    NORMAL_MNEMONIC(PLSR_B, PLSR_B, "plsr.b"),
++    NORMAL_MNEMONIC(PLSR_H, PLSR_H, "plsr.h"),
++    NORMAL_MNEMONIC(PMAX_SH, PMAX_SH, "pmax.sh"),
++    NORMAL_MNEMONIC(PMAX_UB, PMAX_UB, "pmax.ub"),
++    NORMAL_MNEMONIC(PMIN_SH, PMIN_SH, "pmin.sh"),
++    NORMAL_MNEMONIC(PMIN_UB, PMIN_UB, "pmin.ub"),
++    NORMAL_MNEMONIC(POPJC, POPJC, "popjc"),
++    NORMAL_MNEMONIC(POPM, POPM, "popm"),
++    NORMAL_MNEMONIC(PREF, PREF, "pref"),
++    NORMAL_MNEMONIC(PSAD, PSAD, "psad"),
++    NORMAL_MNEMONIC(PSUB_B, PSUB_B, "psub.b"),
++    NORMAL_MNEMONIC(PSUB_H, PSUB_H, "psub.h"),
++    NORMAL_MNEMONIC(PSUBADD_H, PSUBADD_H, "psubadd.h"),
++    NORMAL_MNEMONIC(PSUBADDH_SH, PSUBADDH_SH, "psubaddh.sh"),
++    NORMAL_MNEMONIC(PSUBADDS_SH, PSUBADDS_SH, "psubadds.sh"),
++    NORMAL_MNEMONIC(PSUBADDS_UH, PSUBADDS_UH, "psubadds.uh"),
++    NORMAL_MNEMONIC(PSUBH_SH, PSUBH_SH, "psubh.sh"),
++    NORMAL_MNEMONIC(PSUBH_UB, PSUBH_UB, "psubh.ub"),
++    NORMAL_MNEMONIC(PSUBS_SB, PSUBS_SB, "psubs.sb"),
++    NORMAL_MNEMONIC(PSUBS_SH, PSUBS_SH, "psubs.sh"),
++    NORMAL_MNEMONIC(PSUBS_UB, PSUBS_UB, "psubs.ub"),
++    NORMAL_MNEMONIC(PSUBS_UH, PSUBS_UH, "psubs.uh"),
++    NORMAL_MNEMONIC(PSUBX_H, PSUBX_H, "psubx.h"),
++    NORMAL_MNEMONIC(PSUBXH_SH, PSUBXH_SH, "psubxh.sh"),
++    NORMAL_MNEMONIC(PSUBXS_SH, PSUBXS_SH, "psubxs.sh"),
++    NORMAL_MNEMONIC(PSUBXS_UH, PSUBXS_UH, "psubxs.uh"),
++    NORMAL_MNEMONIC(PUNPCKSB_H, PUNPCKSB_H, "punpcksb.h"),
++    NORMAL_MNEMONIC(PUNPCKUB_H, PUNPCKUB_H, "punpckub.h"),
++    NORMAL_MNEMONIC(PUSHJC, PUSHJC, "pushjc"),
++    NORMAL_MNEMONIC(PUSHM, PUSHM, "pushm"),
++    NORMAL_MNEMONIC(RCALL, RCALL1, "rcall"),
++    NORMAL_MNEMONIC(RETEQ, RETEQ, "reteq"),
++    NORMAL_MNEMONIC(RETNE, RETNE, "retne"),
++    NORMAL_MNEMONIC(RETCC, RETCC, "retcc"),
++    NORMAL_MNEMONIC(RETCS, RETCS, "retcs"),
++    NORMAL_MNEMONIC(RETGE, RETGE, "retge"),
++    NORMAL_MNEMONIC(RETLT, RETLT, "retlt"),
++    NORMAL_MNEMONIC(RETMI, RETMI, "retmi"),
++    NORMAL_MNEMONIC(RETPL, RETPL, "retpl"),
++    NORMAL_MNEMONIC(RETLS, RETLS, "retls"),
++    NORMAL_MNEMONIC(RETGT, RETGT, "retgt"),
++    NORMAL_MNEMONIC(RETLE, RETLE, "retle"),
++    NORMAL_MNEMONIC(RETHI, RETHI, "rethi"),
++    NORMAL_MNEMONIC(RETVS, RETVS, "retvs"),
++    NORMAL_MNEMONIC(RETVC, RETVC, "retvc"),
++    NORMAL_MNEMONIC(RETQS, RETQS, "retqs"),
++    NORMAL_MNEMONIC(RETAL, RETAL, "retal"),
++    NORMAL_MNEMONIC(RETHS, RETHS, "reths"),
++    NORMAL_MNEMONIC(RETLO, RETLO, "retlo"),
++    NORMAL_MNEMONIC(RET, RETAL, "ret"),
++    NORMAL_MNEMONIC(RETD, RETD, "retd"),
++    NORMAL_MNEMONIC(RETE, RETE, "rete"),
++    NORMAL_MNEMONIC(RETJ, RETJ, "retj"),
++    NORMAL_MNEMONIC(RETS, RETS, "rets"),
++    NORMAL_MNEMONIC(RJMP, RJMP, "rjmp"),
++    NORMAL_MNEMONIC(ROL, ROL, "rol"),
++    NORMAL_MNEMONIC(ROR, ROR, "ror"),
++    NORMAL_MNEMONIC(RSUB, RSUB1, "rsub"),
++    NORMAL_MNEMONIC(SATADD_H, SATADD_H, "satadd.h"),
++    NORMAL_MNEMONIC(SATADD_W, SATADD_W, "satadd.w"),
++    NORMAL_MNEMONIC(SATRNDS, SATRNDS, "satrnds"),
++    NORMAL_MNEMONIC(SATRNDU, SATRNDU, "satrndu"),
++    NORMAL_MNEMONIC(SATS, SATS, "sats"),
++    NORMAL_MNEMONIC(SATSUB_H, SATSUB_H, "satsub.h"),
++    NORMAL_MNEMONIC(SATSUB_W, SATSUB_W1, "satsub.w"),
++    NORMAL_MNEMONIC(SATU, SATU, "satu"),
++    NORMAL_MNEMONIC(SBC, SBC, "sbc"),
++    NORMAL_MNEMONIC(SBR, SBR, "sbr"),
++    NORMAL_MNEMONIC(SCALL, SCALL, "scall"),
++    NORMAL_MNEMONIC(SCR, SCR, "scr"),
++    NORMAL_MNEMONIC(SLEEP, SLEEP, "sleep"),
++    NORMAL_MNEMONIC(SREQ, SREQ, "sreq"),
++    NORMAL_MNEMONIC(SRNE, SRNE, "srne"),
++    NORMAL_MNEMONIC(SRCC, SRCC, "srcc"),
++    NORMAL_MNEMONIC(SRCS, SRCS, "srcs"),
++    NORMAL_MNEMONIC(SRGE, SRGE, "srge"),
++    NORMAL_MNEMONIC(SRLT, SRLT, "srlt"),
++    NORMAL_MNEMONIC(SRMI, SRMI, "srmi"),
++    NORMAL_MNEMONIC(SRPL, SRPL, "srpl"),
++    NORMAL_MNEMONIC(SRLS, SRLS, "srls"),
++    NORMAL_MNEMONIC(SRGT, SRGT, "srgt"),
++    NORMAL_MNEMONIC(SRLE, SRLE, "srle"),
++    NORMAL_MNEMONIC(SRHI, SRHI, "srhi"),
++    NORMAL_MNEMONIC(SRVS, SRVS, "srvs"),
++    NORMAL_MNEMONIC(SRVC, SRVC, "srvc"),
++    NORMAL_MNEMONIC(SRQS, SRQS, "srqs"),
++    NORMAL_MNEMONIC(SRAL, SRAL, "sral"),
++    NORMAL_MNEMONIC(SRHS, SRHS, "srhs"),
++    NORMAL_MNEMONIC(SRLO, SRLO, "srlo"),
++    NORMAL_MNEMONIC(SSRF, SSRF, "ssrf"),
++    NORMAL_MNEMONIC(ST_B, ST_B1, "st.b"),
++    NORMAL_MNEMONIC(ST_D, ST_D1, "st.d"),
++    NORMAL_MNEMONIC(ST_H, ST_H1, "st.h"),
++    NORMAL_MNEMONIC(ST_W, ST_W1, "st.w"),
++    NORMAL_MNEMONIC(STC_D, STC_D3, "stc.d"),
++    NORMAL_MNEMONIC(STC_W, STC_W3, "stc.w"),
++    NORMAL_MNEMONIC(STC0_D, STC0_D, "stc0.d"),
++    NORMAL_MNEMONIC(STC0_W, STC0_W, "stc0.w"),
++    NORMAL_MNEMONIC(STCM_D, STCM_D, "stcm.d"),
++    NORMAL_MNEMONIC(STCM_W, STCM_W, "stcm.w"),
++    NORMAL_MNEMONIC(STCOND, STCOND, "stcond"),
++    NORMAL_MNEMONIC(STDSP, STDSP, "stdsp"),
++    NORMAL_MNEMONIC(STHH_W, STHH_W2, "sthh.w"),
++    NORMAL_MNEMONIC(STM, STM, "stm"),
++    NORMAL_MNEMONIC(STMTS, STMTS, "stmts"),
++    NORMAL_MNEMONIC(STSWP_H, STSWP_H, "stswp.h"),
++    NORMAL_MNEMONIC(STSWP_W, STSWP_W, "stswp.w"),
++    NORMAL_MNEMONIC(SUB, SUB1, "sub"),
++    NORMAL_MNEMONIC(SUBEQ, SUBEQ, "subeq"),
++    NORMAL_MNEMONIC(SUBNE, SUBNE, "subne"),
++    NORMAL_MNEMONIC(SUBCC, SUBCC, "subcc"),
++    NORMAL_MNEMONIC(SUBCS, SUBCS, "subcs"),
++    NORMAL_MNEMONIC(SUBGE, SUBGE, "subge"),
++    NORMAL_MNEMONIC(SUBLT, SUBLT, "sublt"),
++    NORMAL_MNEMONIC(SUBMI, SUBMI, "submi"),
++    NORMAL_MNEMONIC(SUBPL, SUBPL, "subpl"),
++    NORMAL_MNEMONIC(SUBLS, SUBLS, "subls"),
++    NORMAL_MNEMONIC(SUBGT, SUBGT, "subgt"),
++    NORMAL_MNEMONIC(SUBLE, SUBLE, "suble"),
++    NORMAL_MNEMONIC(SUBHI, SUBHI, "subhi"),
++    NORMAL_MNEMONIC(SUBVS, SUBVS, "subvs"),
++    NORMAL_MNEMONIC(SUBVC, SUBVC, "subvc"),
++    NORMAL_MNEMONIC(SUBQS, SUBQS, "subqs"),
++    NORMAL_MNEMONIC(SUBAL, SUBAL, "subal"),
++    NORMAL_MNEMONIC(SUBHS, SUBHS, "subhs"),
++    NORMAL_MNEMONIC(SUBLO, SUBLO, "sublo"),
++    NORMAL_MNEMONIC(SUBFEQ, SUBFEQ, "subfeq"),
++    NORMAL_MNEMONIC(SUBFNE, SUBFNE, "subfne"),
++    NORMAL_MNEMONIC(SUBFCC, SUBFCC, "subfcc"),
++    NORMAL_MNEMONIC(SUBFCS, SUBFCS, "subfcs"),
++    NORMAL_MNEMONIC(SUBFGE, SUBFGE, "subfge"),
++    NORMAL_MNEMONIC(SUBFLT, SUBFLT, "subflt"),
++    NORMAL_MNEMONIC(SUBFMI, SUBFMI, "subfmi"),
++    NORMAL_MNEMONIC(SUBFPL, SUBFPL, "subfpl"),
++    NORMAL_MNEMONIC(SUBFLS, SUBFLS, "subfls"),
++    NORMAL_MNEMONIC(SUBFGT, SUBFGT, "subfgt"),
++    NORMAL_MNEMONIC(SUBFLE, SUBFLE, "subfle"),
++    NORMAL_MNEMONIC(SUBFHI, SUBFHI, "subfhi"),
++    NORMAL_MNEMONIC(SUBFVS, SUBFVS, "subfvs"),
++    NORMAL_MNEMONIC(SUBFVC, SUBFVC, "subfvc"),
++    NORMAL_MNEMONIC(SUBFQS, SUBFQS, "subfqs"),
++    NORMAL_MNEMONIC(SUBFAL, SUBFAL, "subfal"),
++    NORMAL_MNEMONIC(SUBFHS, SUBFHS, "subfhs"),
++    NORMAL_MNEMONIC(SUBFLO, SUBFLO, "subflo"),
++    NORMAL_MNEMONIC(SUBHH_W, SUBHH_W, "subhh.w"),
++    NORMAL_MNEMONIC(SWAP_B, SWAP_B, "swap.b"),
++    NORMAL_MNEMONIC(SWAP_BH, SWAP_BH, "swap.bh"),
++    NORMAL_MNEMONIC(SWAP_H, SWAP_H, "swap.h"),
++    NORMAL_MNEMONIC(SYNC, SYNC, "sync"),
++    NORMAL_MNEMONIC(TLBR, TLBR, "tlbr"),
++    NORMAL_MNEMONIC(TLBS, TLBS, "tlbs"),
++    NORMAL_MNEMONIC(TLBW, TLBW, "tlbw"),
++    NORMAL_MNEMONIC(TNBZ, TNBZ, "tnbz"),
++    NORMAL_MNEMONIC(TST, TST, "tst"),
++    NORMAL_MNEMONIC(XCHG, XCHG, "xchg"),
++    NORMAL_MNEMONIC(MEMC, MEMC, "memc"),
++    NORMAL_MNEMONIC(MEMS, MEMS, "mems"),
++    NORMAL_MNEMONIC(MEMT, MEMT, "memt"),
++    FP_MNEMONIC(FADD, FADD, "fadd"),
++    FP_MNEMONIC(FSUB, FSUB, "fsub"),
++    FP_MNEMONIC(FMAC, FMAC, "fmac"),
++    FP_MNEMONIC(FNMAC, FNMAC, "fnmac"),
++    FP_MNEMONIC(FMSC, FMSC, "fmsc"),
++    FP_MNEMONIC(FNMSC, FNMSC, "fnmsc"),
++    FP_MNEMONIC(FMUL, FMUL, "fmul"),
++    FP_MNEMONIC(FNMUL, FNMUL, "fnmul"),
++    FP_MNEMONIC(FNEG, FNEG, "fneg"),
++    FP_MNEMONIC(FABS, FABS, "fabs"),
++    FP_MNEMONIC(FCMP, FCMP, "fcmp"),
++    FP_MNEMONIC(FMOV, FMOV1, "fmov"),
++    NORMAL_MNEMONIC(FCASTS_D, FCASTS_D, "fcasts.d"),
++    NORMAL_MNEMONIC(FCASTD_S, FCASTD_S, "fcastd.s"),
++    NORMAL_MNEMONIC(LDA_W, LDA_W, "lda.w"),
++    NORMAL_MNEMONIC(CALL, CALL, "call"),
++    NORMAL_MNEMONIC(PICOSVMAC, PICOSVMAC0, "picosvmac"),
++    NORMAL_MNEMONIC(PICOSVMUL, PICOSVMUL0, "picosvmul"),
++    NORMAL_MNEMONIC(PICOVMAC, PICOVMAC0, "picovmac"),
++    NORMAL_MNEMONIC(PICOVMUL, PICOVMUL0, "picovmul"),
++    NORMAL_MNEMONIC(PICOLD_D, PICOLD_D2, "picold.d"),
++    NORMAL_MNEMONIC(PICOLD_W, PICOLD_W2, "picold.w"),
++    NORMAL_MNEMONIC(PICOLDM_D, PICOLDM_D, "picoldm.d"),
++    NORMAL_MNEMONIC(PICOLDM_W, PICOLDM_W, "picoldm.w"),
++    NORMAL_MNEMONIC(PICOMV_D, PICOMV_D1, "picomv.d"),
++    NORMAL_MNEMONIC(PICOMV_W, PICOMV_W1, "picomv.w"),
++    NORMAL_MNEMONIC(PICOST_D, PICOST_D2, "picost.d"),
++    NORMAL_MNEMONIC(PICOST_W, PICOST_W2, "picost.w"),
++    NORMAL_MNEMONIC(PICOSTM_D, PICOSTM_D, "picostm.d"),
++    NORMAL_MNEMONIC(PICOSTM_W, PICOSTM_W, "picostm.w"),
++  };
++#undef NORMAL_MNEMONIC
++#undef ALIAS_MNEMONIC
++#undef FP_MNEMONIC
+diff -Nrup binutils-2.17/opcodes/avr32-opc.h binutils-2.17-atmel/opcodes/avr32-opc.h
+--- binutils-2.17/opcodes/avr32-opc.h  1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.17-atmel/opcodes/avr32-opc.h    2007-01-29 12:21:57.000000000 +0100
+@@ -0,0 +1,1655 @@
++/* Opcode tables for AVR32.
++   Copyright 2005, 2006 Atmel Corporation.
++
++   Written by Haavard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   This file is part of libopcodes.
++
++   This program is free software; you can redistribute it and/or
++   modify it under the terms of the GNU General Public License as
++   published by the Free Software Foundation; either version 2 of the
++   License, or (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful, but
++   WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++   General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++   02111-1307, USA.  */
++
++#include "bfd.h"
++
++#define AVR32_MAX_OPERANDS    8
++#define AVR32_MAX_FIELDS      8
++
++#define AVR32_V1              (1 << 1)
++#define AVR32_SIMD            (1 << 2)
++#define AVR32_DSP             (1 << 3)
++#define AVR32_RMW             (1 << 4)
++#define AVR32_FP              (1 << 16)
++#define AVR32_PICO            (1 << 17)
++
++/* Registers we commonly refer to */
++#define AVR32_REG_R12         12
++#define AVR32_REG_SP          13
++#define AVR32_REG_LR          14
++#define AVR32_REG_PC          15
++
++struct avr32_ifield
++{
++  int id;
++  unsigned short bitsize;
++  unsigned short shift;
++  unsigned long mask;
++
++  /* If the value doesn't fit, it will be truncated with no warning */
++  void (*insert)(const struct avr32_ifield *, void *, unsigned long);
++  void (*extract)(const struct avr32_ifield *, void *, unsigned long *);
++};
++
++struct avr32_opcode
++{
++  int id;
++  int size;
++  unsigned long value;
++  unsigned long mask;
++  const struct avr32_syntax *syntax;
++  bfd_reloc_code_real_type reloc_type;
++  unsigned int nr_fields;
++  /* if relaxable, which field is variable, otherwise -1 */
++  int var_field;
++  const struct avr32_ifield *fields[AVR32_MAX_FIELDS];
++};
++
++struct avr32_alias
++{
++  int id;
++  const struct avr32_opcode *opc;
++  struct {
++    int is_opindex;
++    unsigned long value;
++  } operand_map[AVR32_MAX_OPERANDS];
++};
++
++struct avr32_syntax
++{
++  int id;
++  unsigned long isa_flags;
++  const struct avr32_mnemonic *mnemonic;
++  int type;
++  union {
++    const struct avr32_opcode *opc;
++    const struct avr32_alias *alias;
++  } u;
++  const struct avr32_syntax *next;
++  /* negative means "vararg" */
++  int nr_operands;
++  int operand[AVR32_MAX_OPERANDS];
++};
++
++#if 0
++#define AVR32_ALIAS_MAKE_CONST(val) ((val) | 0x80000000UL)
++#define AVR32_ALIAS_IS_CONST(mapval) (((mapval) & 0x80000000UL) != 0)
++#define AVR32_ALIAS_GET_CONST(mapval) ((mapval) & ~0x80000000UL)
++#endif
++
++struct avr32_mnemonic
++{
++  int id;
++  const char *name;
++  const struct avr32_syntax *syntax;
++};
++
++extern const struct avr32_ifield avr32_ifield_table[];
++extern struct avr32_opcode avr32_opc_table[];
++extern const struct avr32_syntax avr32_syntax_table[];
++extern const struct avr32_alias avr32_alias_table[];
++extern const struct avr32_mnemonic avr32_mnemonic_table[];
++
++extern void avr32_insert_simple(const struct avr32_ifield *field,
++                              void *buf, unsigned long value);
++extern void avr32_insert_bit5c(const struct avr32_ifield *field,
++                             void *buf, unsigned long value);
++extern void avr32_insert_k10(const struct avr32_ifield *field,
++                           void *buf, unsigned long value);
++extern void avr32_insert_k21(const struct avr32_ifield *field,
++                           void *buf, unsigned long value);
++extern void avr32_insert_cpop(const struct avr32_ifield *field,
++                            void *buf, unsigned long value);
++extern void avr32_insert_k12cp(const struct avr32_ifield *field,
++                             void *buf, unsigned long value);
++
++extern void avr32_extract_simple(const struct avr32_ifield *field,
++                               void *buf, unsigned long *value);
++extern void avr32_extract_bit5c(const struct avr32_ifield *field,
++                              void *buf, unsigned long *value);
++extern void avr32_extract_k10(const struct avr32_ifield *field,
++                            void *buf, unsigned long *value);
++extern void avr32_extract_k21(const struct avr32_ifield *field,
++                            void *buf, unsigned long *value);
++extern void avr32_extract_cpop(const struct avr32_ifield *field,
++                             void *buf, unsigned long *value);
++extern void avr32_extract_k12cp(const struct avr32_ifield *field,
++                              void *buf, unsigned long *value);
++
++enum avr32_operand_type
++{
++  AVR32_OPERAND_INTREG,               /* just a register */
++  AVR32_OPERAND_INTREG_PREDEC,        /* register with pre-decrement */
++  AVR32_OPERAND_INTREG_POSTINC,       /* register with post-increment */
++  AVR32_OPERAND_INTREG_LSL,   /* register with left shift */
++  AVR32_OPERAND_INTREG_LSR,   /* register with right shift */
++  AVR32_OPERAND_INTREG_BSEL,  /* register with byte selector */
++  AVR32_OPERAND_INTREG_HSEL,  /* register with halfword selector */
++  AVR32_OPERAND_INTREG_SDISP, /* Rp[signed disp] */
++  AVR32_OPERAND_INTREG_SDISP_H,       /* Rp[signed hword-aligned disp] */
++  AVR32_OPERAND_INTREG_SDISP_W,       /* Rp[signed word-aligned disp] */
++  AVR32_OPERAND_INTREG_UDISP, /* Rp[unsigned disp] */
++  AVR32_OPERAND_INTREG_UDISP_H,       /* Rp[unsigned hword-aligned disp] */
++  AVR32_OPERAND_INTREG_UDISP_W, /* Rp[unsigned word-aligned disp] */
++  AVR32_OPERAND_INTREG_INDEX, /* Rp[Ri << sa] */
++  AVR32_OPERAND_INTREG_XINDEX,        /* Rp[Ri:bytesel << 2] */
++  AVR32_OPERAND_DWREG,                /* Even-numbered register */
++  AVR32_OPERAND_PC_UDISP_W,   /* PC[unsigned word-aligned disp] or label */
++  AVR32_OPERAND_SP,           /* Just SP */
++  AVR32_OPERAND_SP_UDISP_W,   /* SP[unsigned word-aligned disp] */
++  AVR32_OPERAND_CPNO,
++  AVR32_OPERAND_CPREG,
++  AVR32_OPERAND_CPREG_D,
++  AVR32_OPERAND_UNSIGNED_CONST,
++  AVR32_OPERAND_UNSIGNED_CONST_W,
++  AVR32_OPERAND_SIGNED_CONST,
++  AVR32_OPERAND_SIGNED_CONST_W,
++  AVR32_OPERAND_JMPLABEL,
++  AVR32_OPERAND_UNSIGNED_NUMBER,
++  AVR32_OPERAND_UNSIGNED_NUMBER_W,
++  AVR32_OPERAND_REGLIST8,
++  AVR32_OPERAND_REGLIST9,
++  AVR32_OPERAND_REGLIST16,
++  AVR32_OPERAND_REGLIST_LDM,
++  AVR32_OPERAND_REGLIST_CP8,
++  AVR32_OPERAND_REGLIST_CPD8,
++  AVR32_OPERAND_RETVAL,
++  AVR32_OPERAND_MCALL,
++  AVR32_OPERAND_JOSPINC,
++  AVR32_OPERAND_COH,
++  AVR32_OPERAND_FPREG_S,
++  AVR32_OPERAND_FPREG_D,
++  AVR32_OPERAND_PICO_REG_W,
++  AVR32_OPERAND_PICO_REG_D,
++  AVR32_OPERAND_PICO_REGLIST_W,
++  AVR32_OPERAND_PICO_REGLIST_D,
++  AVR32_OPERAND_PICO_IN,
++  AVR32_OPERAND_PICO_OUT0,
++  AVR32_OPERAND_PICO_OUT1,
++  AVR32_OPERAND_PICO_OUT2,
++  AVR32_OPERAND_PICO_OUT3,
++  AVR32_OPERAND__END_
++};
++#define AVR32_OPERAND_UNKNOWN AVR32_OPERAND__END_
++#define AVR32_NR_OPERANDS AVR32_OPERAND__END_
++
++enum avr32_ifield_type
++{
++  AVR32_IFIELD_RX,
++  AVR32_IFIELD_RY,
++  AVR32_IFIELD_COND4C,
++  AVR32_IFIELD_K8C,
++  AVR32_IFIELD_K7C,
++  AVR32_IFIELD_K5C,
++  AVR32_IFIELD_K3,
++  AVR32_IFIELD_RY_DW,
++  AVR32_IFIELD_COND4E,
++  AVR32_IFIELD_K8E,
++  AVR32_IFIELD_BIT5C,
++  AVR32_IFIELD_COND3,
++  AVR32_IFIELD_K10,
++  AVR32_IFIELD_POPM,
++  AVR32_IFIELD_K2,
++  AVR32_IFIELD_RD_E,
++  AVR32_IFIELD_RD_DW,
++  AVR32_IFIELD_X,
++  AVR32_IFIELD_Y,
++  AVR32_IFIELD_X2,
++  AVR32_IFIELD_Y2,
++  AVR32_IFIELD_K5E,
++  AVR32_IFIELD_PART2,
++  AVR32_IFIELD_PART1,
++  AVR32_IFIELD_K16,
++  AVR32_IFIELD_CACHEOP,
++  AVR32_IFIELD_K11,
++  AVR32_IFIELD_K21,
++  AVR32_IFIELD_CPOP,
++  AVR32_IFIELD_CPNO,
++  AVR32_IFIELD_CRD_RI,
++  AVR32_IFIELD_CRX,
++  AVR32_IFIELD_CRY,
++  AVR32_IFIELD_K7E,
++  AVR32_IFIELD_CRD_DW,
++  AVR32_IFIELD_PART1_K12,
++  AVR32_IFIELD_PART2_K12,
++  AVR32_IFIELD_K12,
++  AVR32_IFIELD_S5,
++  AVR32_IFIELD_K5E2,
++  AVR32_IFIELD_K4,
++  AVR32_IFIELD_COND4E2,
++  AVR32_IFIELD_K8E2,
++  AVR32_IFIELD_K6,
++  AVR32_IFIELD_MEM15,
++  AVR32_IFIELD_MEMB5,
++  AVR32_IFIELD_W,
++  AVR32_IFIELD_CM_HL,
++  AVR32_IFIELD_K12CP,
++  AVR32_IFIELD__END_,
++};
++#define AVR32_NR_IFIELDS AVR32_IFIELD__END_
++
++enum avr32_opc_type
++{
++  AVR32_OPC_ABS,
++  AVR32_OPC_ACALL,
++  AVR32_OPC_ACR,
++  AVR32_OPC_ADC,
++  AVR32_OPC_ADD1,
++  AVR32_OPC_ADD2,
++  AVR32_OPC_ADDABS,
++  AVR32_OPC_ADDHH_W,
++  AVR32_OPC_AND1,
++  AVR32_OPC_AND2,
++  AVR32_OPC_AND3,
++  AVR32_OPC_ANDH,
++  AVR32_OPC_ANDH_COH,
++  AVR32_OPC_ANDL,
++  AVR32_OPC_ANDL_COH,
++  AVR32_OPC_ANDN,
++  AVR32_OPC_ASR1,
++  AVR32_OPC_ASR3,
++  AVR32_OPC_ASR2,
++  AVR32_OPC_BLD,
++  AVR32_OPC_BREQ1,
++  AVR32_OPC_BRNE1,
++  AVR32_OPC_BRCC1,
++  AVR32_OPC_BRCS1,
++  AVR32_OPC_BRGE1,
++  AVR32_OPC_BRLT1,
++  AVR32_OPC_BRMI1,
++  AVR32_OPC_BRPL1,
++  AVR32_OPC_BREQ2,
++  AVR32_OPC_BRNE2,
++  AVR32_OPC_BRCC2,
++  AVR32_OPC_BRCS2,
++  AVR32_OPC_BRGE2,
++  AVR32_OPC_BRLT2,
++  AVR32_OPC_BRMI2,
++  AVR32_OPC_BRPL2,
++  AVR32_OPC_BRLS,
++  AVR32_OPC_BRGT,
++  AVR32_OPC_BRLE,
++  AVR32_OPC_BRHI,
++  AVR32_OPC_BRVS,
++  AVR32_OPC_BRVC,
++  AVR32_OPC_BRQS,
++  AVR32_OPC_BRAL,
++  AVR32_OPC_BREAKPOINT,
++  AVR32_OPC_BREV,
++  AVR32_OPC_BST,
++  AVR32_OPC_CACHE,
++  AVR32_OPC_CASTS_B,
++  AVR32_OPC_CASTS_H,
++  AVR32_OPC_CASTU_B,
++  AVR32_OPC_CASTU_H,
++  AVR32_OPC_CBR,
++  AVR32_OPC_CLZ,
++  AVR32_OPC_COM,
++  AVR32_OPC_COP,
++  AVR32_OPC_CP_B,
++  AVR32_OPC_CP_H,
++  AVR32_OPC_CP_W1,
++  AVR32_OPC_CP_W2,
++  AVR32_OPC_CP_W3,
++  AVR32_OPC_CPC1,
++  AVR32_OPC_CPC2,
++  AVR32_OPC_CSRF,
++  AVR32_OPC_CSRFCZ,
++  AVR32_OPC_DIVS,
++  AVR32_OPC_DIVU,
++  AVR32_OPC_EOR1,
++  AVR32_OPC_EOR2,
++  AVR32_OPC_EOR3,
++  AVR32_OPC_EORL,
++  AVR32_OPC_EORH,
++  AVR32_OPC_FRS,
++  AVR32_OPC_ICALL,
++  AVR32_OPC_INCJOSP,
++  AVR32_OPC_LD_D1,
++  AVR32_OPC_LD_D2,
++  AVR32_OPC_LD_D3,
++  AVR32_OPC_LD_D5,
++  AVR32_OPC_LD_D4,
++  AVR32_OPC_LD_SB2,
++  AVR32_OPC_LD_SB1,
++  AVR32_OPC_LD_UB1,
++  AVR32_OPC_LD_UB2,
++  AVR32_OPC_LD_UB5,
++  AVR32_OPC_LD_UB3,
++  AVR32_OPC_LD_UB4,
++  AVR32_OPC_LD_SH1,
++  AVR32_OPC_LD_SH2,
++  AVR32_OPC_LD_SH5,
++  AVR32_OPC_LD_SH3,
++  AVR32_OPC_LD_SH4,
++  AVR32_OPC_LD_UH1,
++  AVR32_OPC_LD_UH2,
++  AVR32_OPC_LD_UH5,
++  AVR32_OPC_LD_UH3,
++  AVR32_OPC_LD_UH4,
++  AVR32_OPC_LD_W1,
++  AVR32_OPC_LD_W2,
++  AVR32_OPC_LD_W5,
++  AVR32_OPC_LD_W6,
++  AVR32_OPC_LD_W3,
++  AVR32_OPC_LD_W4,
++  AVR32_OPC_LDC_D1,
++  AVR32_OPC_LDC_D2,
++  AVR32_OPC_LDC_D3,
++  AVR32_OPC_LDC_W1,
++  AVR32_OPC_LDC_W2,
++  AVR32_OPC_LDC_W3,
++  AVR32_OPC_LDC0_D,
++  AVR32_OPC_LDC0_W,
++  AVR32_OPC_LDCM_D,
++  AVR32_OPC_LDCM_D_PU,
++  AVR32_OPC_LDCM_W,
++  AVR32_OPC_LDCM_W_PU,
++  AVR32_OPC_LDDPC,
++  AVR32_OPC_LDDPC_EXT,
++  AVR32_OPC_LDDSP,
++  AVR32_OPC_LDINS_B,
++  AVR32_OPC_LDINS_H,
++  AVR32_OPC_LDM,
++  AVR32_OPC_LDMTS,
++  AVR32_OPC_LDMTS_PU,
++  AVR32_OPC_LDSWP_SH,
++  AVR32_OPC_LDSWP_UH,
++  AVR32_OPC_LDSWP_W,
++  AVR32_OPC_LSL1,
++  AVR32_OPC_LSL3,
++  AVR32_OPC_LSL2,
++  AVR32_OPC_LSR1,
++  AVR32_OPC_LSR3,
++  AVR32_OPC_LSR2,
++  AVR32_OPC_MAC,
++  AVR32_OPC_MACHH_D,
++  AVR32_OPC_MACHH_W,
++  AVR32_OPC_MACS_D,
++  AVR32_OPC_MACSATHH_W,
++  AVR32_OPC_MACUD,
++  AVR32_OPC_MACWH_D,
++  AVR32_OPC_MAX,
++  AVR32_OPC_MCALL,
++  AVR32_OPC_MFDR,
++  AVR32_OPC_MFSR,
++  AVR32_OPC_MIN,
++  AVR32_OPC_MOV3,
++  AVR32_OPC_MOV1,
++  AVR32_OPC_MOV2,
++  AVR32_OPC_MOVEQ1,
++  AVR32_OPC_MOVNE1,
++  AVR32_OPC_MOVCC1,
++  AVR32_OPC_MOVCS1,
++  AVR32_OPC_MOVGE1,
++  AVR32_OPC_MOVLT1,
++  AVR32_OPC_MOVMI1,
++  AVR32_OPC_MOVPL1,
++  AVR32_OPC_MOVLS1,
++  AVR32_OPC_MOVGT1,
++  AVR32_OPC_MOVLE1,
++  AVR32_OPC_MOVHI1,
++  AVR32_OPC_MOVVS1,
++  AVR32_OPC_MOVVC1,
++  AVR32_OPC_MOVQS1,
++  AVR32_OPC_MOVAL1,
++  AVR32_OPC_MOVEQ2,
++  AVR32_OPC_MOVNE2,
++  AVR32_OPC_MOVCC2,
++  AVR32_OPC_MOVCS2,
++  AVR32_OPC_MOVGE2,
++  AVR32_OPC_MOVLT2,
++  AVR32_OPC_MOVMI2,
++  AVR32_OPC_MOVPL2,
++  AVR32_OPC_MOVLS2,
++  AVR32_OPC_MOVGT2,
++  AVR32_OPC_MOVLE2,
++  AVR32_OPC_MOVHI2,
++  AVR32_OPC_MOVVS2,
++  AVR32_OPC_MOVVC2,
++  AVR32_OPC_MOVQS2,
++  AVR32_OPC_MOVAL2,
++  AVR32_OPC_MTDR,
++  AVR32_OPC_MTSR,
++  AVR32_OPC_MUL1,
++  AVR32_OPC_MUL2,
++  AVR32_OPC_MUL3,
++  AVR32_OPC_MULHH_W,
++  AVR32_OPC_MULNHH_W,
++  AVR32_OPC_MULNWH_D,
++  AVR32_OPC_MULSD,
++  AVR32_OPC_MULSATHH_H,
++  AVR32_OPC_MULSATHH_W,
++  AVR32_OPC_MULSATRNDHH_H,
++  AVR32_OPC_MULSATRNDWH_W,
++  AVR32_OPC_MULSATWH_W,
++  AVR32_OPC_MULU_D,
++  AVR32_OPC_MULWH_D,
++  AVR32_OPC_MUSFR,
++  AVR32_OPC_MUSTR,
++  AVR32_OPC_MVCR_D,
++  AVR32_OPC_MVCR_W,
++  AVR32_OPC_MVRC_D,
++  AVR32_OPC_MVRC_W,
++  AVR32_OPC_NEG,
++  AVR32_OPC_NOP,
++  AVR32_OPC_OR1,
++  AVR32_OPC_OR2,
++  AVR32_OPC_OR3,
++  AVR32_OPC_ORH,
++  AVR32_OPC_ORL,
++  AVR32_OPC_PABS_SB,
++  AVR32_OPC_PABS_SH,
++  AVR32_OPC_PACKSH_SB,
++  AVR32_OPC_PACKSH_UB,
++  AVR32_OPC_PACKW_SH,
++  AVR32_OPC_PADD_B,
++  AVR32_OPC_PADD_H,
++  AVR32_OPC_PADDH_SH,
++  AVR32_OPC_PADDH_UB,
++  AVR32_OPC_PADDS_SB,
++  AVR32_OPC_PADDS_SH,
++  AVR32_OPC_PADDS_UB,
++  AVR32_OPC_PADDS_UH,
++  AVR32_OPC_PADDSUB_H,
++  AVR32_OPC_PADDSUBH_SH,
++  AVR32_OPC_PADDSUBS_SH,
++  AVR32_OPC_PADDSUBS_UH,
++  AVR32_OPC_PADDX_H,
++  AVR32_OPC_PADDXH_SH,
++  AVR32_OPC_PADDXS_SH,
++  AVR32_OPC_PADDXS_UH,
++  AVR32_OPC_PASR_B,
++  AVR32_OPC_PASR_H,
++  AVR32_OPC_PAVG_SH,
++  AVR32_OPC_PAVG_UB,
++  AVR32_OPC_PLSL_B,
++  AVR32_OPC_PLSL_H,
++  AVR32_OPC_PLSR_B,
++  AVR32_OPC_PLSR_H,
++  AVR32_OPC_PMAX_SH,
++  AVR32_OPC_PMAX_UB,
++  AVR32_OPC_PMIN_SH,
++  AVR32_OPC_PMIN_UB,
++  AVR32_OPC_POPJC,
++  AVR32_OPC_POPM,
++  AVR32_OPC_POPM_E,
++  AVR32_OPC_PREF,
++  AVR32_OPC_PSAD,
++  AVR32_OPC_PSUB_B,
++  AVR32_OPC_PSUB_H,
++  AVR32_OPC_PSUBADD_H,
++  AVR32_OPC_PSUBADDH_SH,
++  AVR32_OPC_PSUBADDS_SH,
++  AVR32_OPC_PSUBADDS_UH,
++  AVR32_OPC_PSUBH_SH,
++  AVR32_OPC_PSUBH_UB,
++  AVR32_OPC_PSUBS_SB,
++  AVR32_OPC_PSUBS_SH,
++  AVR32_OPC_PSUBS_UB,
++  AVR32_OPC_PSUBS_UH,
++  AVR32_OPC_PSUBX_H,
++  AVR32_OPC_PSUBXH_SH,
++  AVR32_OPC_PSUBXS_SH,
++  AVR32_OPC_PSUBXS_UH,
++  AVR32_OPC_PUNPCKSB_H,
++  AVR32_OPC_PUNPCKUB_H,
++  AVR32_OPC_PUSHJC,
++  AVR32_OPC_PUSHM,
++  AVR32_OPC_PUSHM_E,
++  AVR32_OPC_RCALL1,
++  AVR32_OPC_RCALL2,
++  AVR32_OPC_RETEQ,
++  AVR32_OPC_RETNE,
++  AVR32_OPC_RETCC,
++  AVR32_OPC_RETCS,
++  AVR32_OPC_RETGE,
++  AVR32_OPC_RETLT,
++  AVR32_OPC_RETMI,
++  AVR32_OPC_RETPL,
++  AVR32_OPC_RETLS,
++  AVR32_OPC_RETGT,
++  AVR32_OPC_RETLE,
++  AVR32_OPC_RETHI,
++  AVR32_OPC_RETVS,
++  AVR32_OPC_RETVC,
++  AVR32_OPC_RETQS,
++  AVR32_OPC_RETAL,
++  AVR32_OPC_RETD,
++  AVR32_OPC_RETE,
++  AVR32_OPC_RETJ,
++  AVR32_OPC_RETS,
++  AVR32_OPC_RJMP,
++  AVR32_OPC_ROL,
++  AVR32_OPC_ROR,
++  AVR32_OPC_RSUB1,
++  AVR32_OPC_RSUB2,
++  AVR32_OPC_SATADD_H,
++  AVR32_OPC_SATADD_W,
++  AVR32_OPC_SATRNDS,
++  AVR32_OPC_SATRNDU,
++  AVR32_OPC_SATS,
++  AVR32_OPC_SATSUB_H,
++  AVR32_OPC_SATSUB_W1,
++  AVR32_OPC_SATSUB_W2,
++  AVR32_OPC_SATU,
++  AVR32_OPC_SBC,
++  AVR32_OPC_SBR,
++  AVR32_OPC_SCALL,
++  AVR32_OPC_SCR,
++  AVR32_OPC_SLEEP,
++  AVR32_OPC_SREQ,
++  AVR32_OPC_SRNE,
++  AVR32_OPC_SRCC,
++  AVR32_OPC_SRCS,
++  AVR32_OPC_SRGE,
++  AVR32_OPC_SRLT,
++  AVR32_OPC_SRMI,
++  AVR32_OPC_SRPL,
++  AVR32_OPC_SRLS,
++  AVR32_OPC_SRGT,
++  AVR32_OPC_SRLE,
++  AVR32_OPC_SRHI,
++  AVR32_OPC_SRVS,
++  AVR32_OPC_SRVC,
++  AVR32_OPC_SRQS,
++  AVR32_OPC_SRAL,
++  AVR32_OPC_SSRF,
++  AVR32_OPC_ST_B1,
++  AVR32_OPC_ST_B2,
++  AVR32_OPC_ST_B5,
++  AVR32_OPC_ST_B3,
++  AVR32_OPC_ST_B4,
++  AVR32_OPC_ST_D1,
++  AVR32_OPC_ST_D2,
++  AVR32_OPC_ST_D3,
++  AVR32_OPC_ST_D5,
++  AVR32_OPC_ST_D4,
++  AVR32_OPC_ST_H1,
++  AVR32_OPC_ST_H2,
++  AVR32_OPC_ST_H5,
++  AVR32_OPC_ST_H3,
++  AVR32_OPC_ST_H4,
++  AVR32_OPC_ST_W1,
++  AVR32_OPC_ST_W2,
++  AVR32_OPC_ST_W5,
++  AVR32_OPC_ST_W3,
++  AVR32_OPC_ST_W4,
++  AVR32_OPC_STC_D1,
++  AVR32_OPC_STC_D2,
++  AVR32_OPC_STC_D3,
++  AVR32_OPC_STC_W1,
++  AVR32_OPC_STC_W2,
++  AVR32_OPC_STC_W3,
++  AVR32_OPC_STC0_D,
++  AVR32_OPC_STC0_W,
++  AVR32_OPC_STCM_D,
++  AVR32_OPC_STCM_D_PU,
++  AVR32_OPC_STCM_W,
++  AVR32_OPC_STCM_W_PU,
++  AVR32_OPC_STCOND,
++  AVR32_OPC_STDSP,
++  AVR32_OPC_STHH_W2,
++  AVR32_OPC_STHH_W1,
++  AVR32_OPC_STM,
++  AVR32_OPC_STM_PU,
++  AVR32_OPC_STMTS,
++  AVR32_OPC_STMTS_PU,
++  AVR32_OPC_STSWP_H,
++  AVR32_OPC_STSWP_W,
++  AVR32_OPC_SUB1,
++  AVR32_OPC_SUB2,
++  AVR32_OPC_SUB5,
++  AVR32_OPC_SUB3_SP,
++  AVR32_OPC_SUB3,
++  AVR32_OPC_SUB4,
++  AVR32_OPC_SUBEQ,
++  AVR32_OPC_SUBNE,
++  AVR32_OPC_SUBCC,
++  AVR32_OPC_SUBCS,
++  AVR32_OPC_SUBGE,
++  AVR32_OPC_SUBLT,
++  AVR32_OPC_SUBMI,
++  AVR32_OPC_SUBPL,
++  AVR32_OPC_SUBLS,
++  AVR32_OPC_SUBGT,
++  AVR32_OPC_SUBLE,
++  AVR32_OPC_SUBHI,
++  AVR32_OPC_SUBVS,
++  AVR32_OPC_SUBVC,
++  AVR32_OPC_SUBQS,
++  AVR32_OPC_SUBAL,
++  AVR32_OPC_SUBFEQ,
++  AVR32_OPC_SUBFNE,
++  AVR32_OPC_SUBFCC,
++  AVR32_OPC_SUBFCS,
++  AVR32_OPC_SUBFGE,
++  AVR32_OPC_SUBFLT,
++  AVR32_OPC_SUBFMI,
++  AVR32_OPC_SUBFPL,
++  AVR32_OPC_SUBFLS,
++  AVR32_OPC_SUBFGT,
++  AVR32_OPC_SUBFLE,
++  AVR32_OPC_SUBFHI,
++  AVR32_OPC_SUBFVS,
++  AVR32_OPC_SUBFVC,
++  AVR32_OPC_SUBFQS,
++  AVR32_OPC_SUBFAL,
++  AVR32_OPC_SUBHH_W,
++  AVR32_OPC_SWAP_B,
++  AVR32_OPC_SWAP_BH,
++  AVR32_OPC_SWAP_H,
++  AVR32_OPC_SYNC,
++  AVR32_OPC_TLBR,
++  AVR32_OPC_TLBS,
++  AVR32_OPC_TLBW,
++  AVR32_OPC_TNBZ,
++  AVR32_OPC_TST,
++  AVR32_OPC_XCHG,
++  AVR32_OPC_MEMC,
++  AVR32_OPC_MEMS,
++  AVR32_OPC_MEMT,
++  AVR32_OPC_BFEXTS,
++  AVR32_OPC_BFEXTU,
++  AVR32_OPC_BFINS,
++  AVR32_OPC__END_
++};
++#define AVR32_NR_OPCODES AVR32_OPC__END_
++
++enum avr32_syntax_type
++{
++  AVR32_SYNTAX_ABS,
++  AVR32_SYNTAX_ACALL,
++  AVR32_SYNTAX_ACR,
++  AVR32_SYNTAX_ADC,
++  AVR32_SYNTAX_ADD1,
++  AVR32_SYNTAX_ADD2,
++  AVR32_SYNTAX_ADDABS,
++  AVR32_SYNTAX_ADDHH_W,
++  AVR32_SYNTAX_AND1,
++  AVR32_SYNTAX_AND2,
++  AVR32_SYNTAX_AND3,
++  AVR32_SYNTAX_ANDH,
++  AVR32_SYNTAX_ANDH_COH,
++  AVR32_SYNTAX_ANDL,
++  AVR32_SYNTAX_ANDL_COH,
++  AVR32_SYNTAX_ANDN,
++  AVR32_SYNTAX_ASR1,
++  AVR32_SYNTAX_ASR3,
++  AVR32_SYNTAX_ASR2,
++  AVR32_SYNTAX_BFEXTS,
++  AVR32_SYNTAX_BFEXTU,
++  AVR32_SYNTAX_BFINS,
++  AVR32_SYNTAX_BLD,
++  AVR32_SYNTAX_BREQ1,
++  AVR32_SYNTAX_BRNE1,
++  AVR32_SYNTAX_BRCC1,
++  AVR32_SYNTAX_BRCS1,
++  AVR32_SYNTAX_BRGE1,
++  AVR32_SYNTAX_BRLT1,
++  AVR32_SYNTAX_BRMI1,
++  AVR32_SYNTAX_BRPL1,
++  AVR32_SYNTAX_BRHS1,
++  AVR32_SYNTAX_BRLO1,
++  AVR32_SYNTAX_BREQ2,
++  AVR32_SYNTAX_BRNE2,
++  AVR32_SYNTAX_BRCC2,
++  AVR32_SYNTAX_BRCS2,
++  AVR32_SYNTAX_BRGE2,
++  AVR32_SYNTAX_BRLT2,
++  AVR32_SYNTAX_BRMI2,
++  AVR32_SYNTAX_BRPL2,
++  AVR32_SYNTAX_BRLS,
++  AVR32_SYNTAX_BRGT,
++  AVR32_SYNTAX_BRLE,
++  AVR32_SYNTAX_BRHI,
++  AVR32_SYNTAX_BRVS,
++  AVR32_SYNTAX_BRVC,
++  AVR32_SYNTAX_BRQS,
++  AVR32_SYNTAX_BRAL,
++  AVR32_SYNTAX_BRHS2,
++  AVR32_SYNTAX_BRLO2,
++  AVR32_SYNTAX_BREAKPOINT,
++  AVR32_SYNTAX_BREV,
++  AVR32_SYNTAX_BST,
++  AVR32_SYNTAX_CACHE,
++  AVR32_SYNTAX_CASTS_B,
++  AVR32_SYNTAX_CASTS_H,
++  AVR32_SYNTAX_CASTU_B,
++  AVR32_SYNTAX_CASTU_H,
++  AVR32_SYNTAX_CBR,
++  AVR32_SYNTAX_CLZ,
++  AVR32_SYNTAX_COM,
++  AVR32_SYNTAX_COP,
++  AVR32_SYNTAX_CP_B,
++  AVR32_SYNTAX_CP_H,
++  AVR32_SYNTAX_CP_W1,
++  AVR32_SYNTAX_CP_W2,
++  AVR32_SYNTAX_CP_W3,
++  AVR32_SYNTAX_CPC1,
++  AVR32_SYNTAX_CPC2,
++  AVR32_SYNTAX_CSRF,
++  AVR32_SYNTAX_CSRFCZ,
++  AVR32_SYNTAX_DIVS,
++  AVR32_SYNTAX_DIVU,
++  AVR32_SYNTAX_EOR1,
++  AVR32_SYNTAX_EOR2,
++  AVR32_SYNTAX_EOR3,
++  AVR32_SYNTAX_EORL,
++  AVR32_SYNTAX_EORH,
++  AVR32_SYNTAX_FRS,
++  AVR32_SYNTAX_ICALL,
++  AVR32_SYNTAX_INCJOSP,
++  AVR32_SYNTAX_LD_D1,
++  AVR32_SYNTAX_LD_D2,
++  AVR32_SYNTAX_LD_D3,
++  AVR32_SYNTAX_LD_D5,
++  AVR32_SYNTAX_LD_D4,
++  AVR32_SYNTAX_LD_SB2,
++  AVR32_SYNTAX_LD_SB1,
++  AVR32_SYNTAX_LD_UB1,
++  AVR32_SYNTAX_LD_UB2,
++  AVR32_SYNTAX_LD_UB5,
++  AVR32_SYNTAX_LD_UB3,
++  AVR32_SYNTAX_LD_UB4,
++  AVR32_SYNTAX_LD_SH1,
++  AVR32_SYNTAX_LD_SH2,
++  AVR32_SYNTAX_LD_SH5,
++  AVR32_SYNTAX_LD_SH3,
++  AVR32_SYNTAX_LD_SH4,
++  AVR32_SYNTAX_LD_UH1,
++  AVR32_SYNTAX_LD_UH2,
++  AVR32_SYNTAX_LD_UH5,
++  AVR32_SYNTAX_LD_UH3,
++  AVR32_SYNTAX_LD_UH4,
++  AVR32_SYNTAX_LD_W1,
++  AVR32_SYNTAX_LD_W2,
++  AVR32_SYNTAX_LD_W5,
++  AVR32_SYNTAX_LD_W6,
++  AVR32_SYNTAX_LD_W3,
++  AVR32_SYNTAX_LD_W4,
++  AVR32_SYNTAX_LDC_D1,
++  AVR32_SYNTAX_LDC_D2,
++  AVR32_SYNTAX_LDC_D3,
++  AVR32_SYNTAX_LDC_W1,
++  AVR32_SYNTAX_LDC_W2,
++  AVR32_SYNTAX_LDC_W3,
++  AVR32_SYNTAX_LDC0_D,
++  AVR32_SYNTAX_LDC0_W,
++  AVR32_SYNTAX_LDCM_D,
++  AVR32_SYNTAX_LDCM_D_PU,
++  AVR32_SYNTAX_LDCM_W,
++  AVR32_SYNTAX_LDCM_W_PU,
++  AVR32_SYNTAX_LDDPC,
++  AVR32_SYNTAX_LDDPC_EXT,
++  AVR32_SYNTAX_LDDSP,
++  AVR32_SYNTAX_LDINS_B,
++  AVR32_SYNTAX_LDINS_H,
++  AVR32_SYNTAX_LDM,
++  AVR32_SYNTAX_LDMTS,
++  AVR32_SYNTAX_LDMTS_PU,
++  AVR32_SYNTAX_LDSWP_SH,
++  AVR32_SYNTAX_LDSWP_UH,
++  AVR32_SYNTAX_LDSWP_W,
++  AVR32_SYNTAX_LSL1,
++  AVR32_SYNTAX_LSL3,
++  AVR32_SYNTAX_LSL2,
++  AVR32_SYNTAX_LSR1,
++  AVR32_SYNTAX_LSR3,
++  AVR32_SYNTAX_LSR2,
++  AVR32_SYNTAX_MAC,
++  AVR32_SYNTAX_MACHH_D,
++  AVR32_SYNTAX_MACHH_W,
++  AVR32_SYNTAX_MACS_D,
++  AVR32_SYNTAX_MACSATHH_W,
++  AVR32_SYNTAX_MACUD,
++  AVR32_SYNTAX_MACWH_D,
++  AVR32_SYNTAX_MAX,
++  AVR32_SYNTAX_MCALL,
++  AVR32_SYNTAX_MFDR,
++  AVR32_SYNTAX_MFSR,
++  AVR32_SYNTAX_MIN,
++  AVR32_SYNTAX_MOV3,
++  AVR32_SYNTAX_MOV1,
++  AVR32_SYNTAX_MOV2,
++  AVR32_SYNTAX_MOVEQ1,
++  AVR32_SYNTAX_MOVNE1,
++  AVR32_SYNTAX_MOVCC1,
++  AVR32_SYNTAX_MOVCS1,
++  AVR32_SYNTAX_MOVGE1,
++  AVR32_SYNTAX_MOVLT1,
++  AVR32_SYNTAX_MOVMI1,
++  AVR32_SYNTAX_MOVPL1,
++  AVR32_SYNTAX_MOVLS1,
++  AVR32_SYNTAX_MOVGT1,
++  AVR32_SYNTAX_MOVLE1,
++  AVR32_SYNTAX_MOVHI1,
++  AVR32_SYNTAX_MOVVS1,
++  AVR32_SYNTAX_MOVVC1,
++  AVR32_SYNTAX_MOVQS1,
++  AVR32_SYNTAX_MOVAL1,
++  AVR32_SYNTAX_MOVHS1,
++  AVR32_SYNTAX_MOVLO1,
++  AVR32_SYNTAX_MOVEQ2,
++  AVR32_SYNTAX_MOVNE2,
++  AVR32_SYNTAX_MOVCC2,
++  AVR32_SYNTAX_MOVCS2,
++  AVR32_SYNTAX_MOVGE2,
++  AVR32_SYNTAX_MOVLT2,
++  AVR32_SYNTAX_MOVMI2,
++  AVR32_SYNTAX_MOVPL2,
++  AVR32_SYNTAX_MOVLS2,
++  AVR32_SYNTAX_MOVGT2,
++  AVR32_SYNTAX_MOVLE2,
++  AVR32_SYNTAX_MOVHI2,
++  AVR32_SYNTAX_MOVVS2,
++  AVR32_SYNTAX_MOVVC2,
++  AVR32_SYNTAX_MOVQS2,
++  AVR32_SYNTAX_MOVAL2,
++  AVR32_SYNTAX_MOVHS2,
++  AVR32_SYNTAX_MOVLO2,
++  AVR32_SYNTAX_MTDR,
++  AVR32_SYNTAX_MTSR,
++  AVR32_SYNTAX_MUL1,
++  AVR32_SYNTAX_MUL2,
++  AVR32_SYNTAX_MUL3,
++  AVR32_SYNTAX_MULHH_W,
++  AVR32_SYNTAX_MULNHH_W,
++  AVR32_SYNTAX_MULNWH_D,
++  AVR32_SYNTAX_MULSD,
++  AVR32_SYNTAX_MULSATHH_H,
++  AVR32_SYNTAX_MULSATHH_W,
++  AVR32_SYNTAX_MULSATRNDHH_H,
++  AVR32_SYNTAX_MULSATRNDWH_W,
++  AVR32_SYNTAX_MULSATWH_W,
++  AVR32_SYNTAX_MULU_D,
++  AVR32_SYNTAX_MULWH_D,
++  AVR32_SYNTAX_MUSFR,
++  AVR32_SYNTAX_MUSTR,
++  AVR32_SYNTAX_MVCR_D,
++  AVR32_SYNTAX_MVCR_W,
++  AVR32_SYNTAX_MVRC_D,
++  AVR32_SYNTAX_MVRC_W,
++  AVR32_SYNTAX_NEG,
++  AVR32_SYNTAX_NOP,
++  AVR32_SYNTAX_OR1,
++  AVR32_SYNTAX_OR2,
++  AVR32_SYNTAX_OR3,
++  AVR32_SYNTAX_ORH,
++  AVR32_SYNTAX_ORL,
++  AVR32_SYNTAX_PABS_SB,
++  AVR32_SYNTAX_PABS_SH,
++  AVR32_SYNTAX_PACKSH_SB,
++  AVR32_SYNTAX_PACKSH_UB,
++  AVR32_SYNTAX_PACKW_SH,
++  AVR32_SYNTAX_PADD_B,
++  AVR32_SYNTAX_PADD_H,
++  AVR32_SYNTAX_PADDH_SH,
++  AVR32_SYNTAX_PADDH_UB,
++  AVR32_SYNTAX_PADDS_SB,
++  AVR32_SYNTAX_PADDS_SH,
++  AVR32_SYNTAX_PADDS_UB,
++  AVR32_SYNTAX_PADDS_UH,
++  AVR32_SYNTAX_PADDSUB_H,
++  AVR32_SYNTAX_PADDSUBH_SH,
++  AVR32_SYNTAX_PADDSUBS_SH,
++  AVR32_SYNTAX_PADDSUBS_UH,
++  AVR32_SYNTAX_PADDX_H,
++  AVR32_SYNTAX_PADDXH_SH,
++  AVR32_SYNTAX_PADDXS_SH,
++  AVR32_SYNTAX_PADDXS_UH,
++  AVR32_SYNTAX_PASR_B,
++  AVR32_SYNTAX_PASR_H,
++  AVR32_SYNTAX_PAVG_SH,
++  AVR32_SYNTAX_PAVG_UB,
++  AVR32_SYNTAX_PLSL_B,
++  AVR32_SYNTAX_PLSL_H,
++  AVR32_SYNTAX_PLSR_B,
++  AVR32_SYNTAX_PLSR_H,
++  AVR32_SYNTAX_PMAX_SH,
++  AVR32_SYNTAX_PMAX_UB,
++  AVR32_SYNTAX_PMIN_SH,
++  AVR32_SYNTAX_PMIN_UB,
++  AVR32_SYNTAX_POPJC,
++  AVR32_SYNTAX_POPM,
++  AVR32_SYNTAX_POPM_E,
++  AVR32_SYNTAX_PREF,
++  AVR32_SYNTAX_PSAD,
++  AVR32_SYNTAX_PSUB_B,
++  AVR32_SYNTAX_PSUB_H,
++  AVR32_SYNTAX_PSUBADD_H,
++  AVR32_SYNTAX_PSUBADDH_SH,
++  AVR32_SYNTAX_PSUBADDS_SH,
++  AVR32_SYNTAX_PSUBADDS_UH,
++  AVR32_SYNTAX_PSUBH_SH,
++  AVR32_SYNTAX_PSUBH_UB,
++  AVR32_SYNTAX_PSUBS_SB,
++  AVR32_SYNTAX_PSUBS_SH,
++  AVR32_SYNTAX_PSUBS_UB,
++  AVR32_SYNTAX_PSUBS_UH,
++  AVR32_SYNTAX_PSUBX_H,
++  AVR32_SYNTAX_PSUBXH_SH,
++  AVR32_SYNTAX_PSUBXS_SH,
++  AVR32_SYNTAX_PSUBXS_UH,
++  AVR32_SYNTAX_PUNPCKSB_H,
++  AVR32_SYNTAX_PUNPCKUB_H,
++  AVR32_SYNTAX_PUSHJC,
++  AVR32_SYNTAX_PUSHM,
++  AVR32_SYNTAX_PUSHM_E,
++  AVR32_SYNTAX_RCALL1,
++  AVR32_SYNTAX_RCALL2,
++  AVR32_SYNTAX_RETEQ,
++  AVR32_SYNTAX_RETNE,
++  AVR32_SYNTAX_RETCC,
++  AVR32_SYNTAX_RETCS,
++  AVR32_SYNTAX_RETGE,
++  AVR32_SYNTAX_RETLT,
++  AVR32_SYNTAX_RETMI,
++  AVR32_SYNTAX_RETPL,
++  AVR32_SYNTAX_RETLS,
++  AVR32_SYNTAX_RETGT,
++  AVR32_SYNTAX_RETLE,
++  AVR32_SYNTAX_RETHI,
++  AVR32_SYNTAX_RETVS,
++  AVR32_SYNTAX_RETVC,
++  AVR32_SYNTAX_RETQS,
++  AVR32_SYNTAX_RETAL,
++  AVR32_SYNTAX_RETHS,
++  AVR32_SYNTAX_RETLO,
++  AVR32_SYNTAX_RETD,
++  AVR32_SYNTAX_RETE,
++  AVR32_SYNTAX_RETJ,
++  AVR32_SYNTAX_RETS,
++  AVR32_SYNTAX_RJMP,
++  AVR32_SYNTAX_ROL,
++  AVR32_SYNTAX_ROR,
++  AVR32_SYNTAX_RSUB1,
++  AVR32_SYNTAX_RSUB2,
++  AVR32_SYNTAX_SATADD_H,
++  AVR32_SYNTAX_SATADD_W,
++  AVR32_SYNTAX_SATRNDS,
++  AVR32_SYNTAX_SATRNDU,
++  AVR32_SYNTAX_SATS,
++  AVR32_SYNTAX_SATSUB_H,
++  AVR32_SYNTAX_SATSUB_W1,
++  AVR32_SYNTAX_SATSUB_W2,
++  AVR32_SYNTAX_SATU,
++  AVR32_SYNTAX_SBC,
++  AVR32_SYNTAX_SBR,
++  AVR32_SYNTAX_SCALL,
++  AVR32_SYNTAX_SCR,
++  AVR32_SYNTAX_SLEEP,
++  AVR32_SYNTAX_SREQ,
++  AVR32_SYNTAX_SRNE,
++  AVR32_SYNTAX_SRCC,
++  AVR32_SYNTAX_SRCS,
++  AVR32_SYNTAX_SRGE,
++  AVR32_SYNTAX_SRLT,
++  AVR32_SYNTAX_SRMI,
++  AVR32_SYNTAX_SRPL,
++  AVR32_SYNTAX_SRLS,
++  AVR32_SYNTAX_SRGT,
++  AVR32_SYNTAX_SRLE,
++  AVR32_SYNTAX_SRHI,
++  AVR32_SYNTAX_SRVS,
++  AVR32_SYNTAX_SRVC,
++  AVR32_SYNTAX_SRQS,
++  AVR32_SYNTAX_SRAL,
++  AVR32_SYNTAX_SRHS,
++  AVR32_SYNTAX_SRLO,
++  AVR32_SYNTAX_SSRF,
++  AVR32_SYNTAX_ST_B1,
++  AVR32_SYNTAX_ST_B2,
++  AVR32_SYNTAX_ST_B5,
++  AVR32_SYNTAX_ST_B3,
++  AVR32_SYNTAX_ST_B4,
++  AVR32_SYNTAX_ST_D1,
++  AVR32_SYNTAX_ST_D2,
++  AVR32_SYNTAX_ST_D3,
++  AVR32_SYNTAX_ST_D5,
++  AVR32_SYNTAX_ST_D4,
++  AVR32_SYNTAX_ST_H1,
++  AVR32_SYNTAX_ST_H2,
++  AVR32_SYNTAX_ST_H5,
++  AVR32_SYNTAX_ST_H3,
++  AVR32_SYNTAX_ST_H4,
++  AVR32_SYNTAX_ST_W1,
++  AVR32_SYNTAX_ST_W2,
++  AVR32_SYNTAX_ST_W5,
++  AVR32_SYNTAX_ST_W3,
++  AVR32_SYNTAX_ST_W4,
++  AVR32_SYNTAX_STC_D1,
++  AVR32_SYNTAX_STC_D2,
++  AVR32_SYNTAX_STC_D3,
++  AVR32_SYNTAX_STC_W1,
++  AVR32_SYNTAX_STC_W2,
++  AVR32_SYNTAX_STC_W3,
++  AVR32_SYNTAX_STC0_D,
++  AVR32_SYNTAX_STC0_W,
++  AVR32_SYNTAX_STCM_D,
++  AVR32_SYNTAX_STCM_D_PU,
++  AVR32_SYNTAX_STCM_W,
++  AVR32_SYNTAX_STCM_W_PU,
++  AVR32_SYNTAX_STCOND,
++  AVR32_SYNTAX_STDSP,
++  AVR32_SYNTAX_STHH_W2,
++  AVR32_SYNTAX_STHH_W1,
++  AVR32_SYNTAX_STM,
++  AVR32_SYNTAX_STM_PU,
++  AVR32_SYNTAX_STMTS,
++  AVR32_SYNTAX_STMTS_PU,
++  AVR32_SYNTAX_STSWP_H,
++  AVR32_SYNTAX_STSWP_W,
++  AVR32_SYNTAX_SUB1,
++  AVR32_SYNTAX_SUB2,
++  AVR32_SYNTAX_SUB5,
++  AVR32_SYNTAX_SUB3_SP,
++  AVR32_SYNTAX_SUB3,
++  AVR32_SYNTAX_SUB4,
++  AVR32_SYNTAX_SUBEQ,
++  AVR32_SYNTAX_SUBNE,
++  AVR32_SYNTAX_SUBCC,
++  AVR32_SYNTAX_SUBCS,
++  AVR32_SYNTAX_SUBGE,
++  AVR32_SYNTAX_SUBLT,
++  AVR32_SYNTAX_SUBMI,
++  AVR32_SYNTAX_SUBPL,
++  AVR32_SYNTAX_SUBLS,
++  AVR32_SYNTAX_SUBGT,
++  AVR32_SYNTAX_SUBLE,
++  AVR32_SYNTAX_SUBHI,
++  AVR32_SYNTAX_SUBVS,
++  AVR32_SYNTAX_SUBVC,
++  AVR32_SYNTAX_SUBQS,
++  AVR32_SYNTAX_SUBAL,
++  AVR32_SYNTAX_SUBHS,
++  AVR32_SYNTAX_SUBLO,
++  AVR32_SYNTAX_SUBFEQ,
++  AVR32_SYNTAX_SUBFNE,
++  AVR32_SYNTAX_SUBFCC,
++  AVR32_SYNTAX_SUBFCS,
++  AVR32_SYNTAX_SUBFGE,
++  AVR32_SYNTAX_SUBFLT,
++  AVR32_SYNTAX_SUBFMI,
++  AVR32_SYNTAX_SUBFPL,
++  AVR32_SYNTAX_SUBFLS,
++  AVR32_SYNTAX_SUBFGT,
++  AVR32_SYNTAX_SUBFLE,
++  AVR32_SYNTAX_SUBFHI,
++  AVR32_SYNTAX_SUBFVS,
++  AVR32_SYNTAX_SUBFVC,
++  AVR32_SYNTAX_SUBFQS,
++  AVR32_SYNTAX_SUBFAL,
++  AVR32_SYNTAX_SUBFHS,
++  AVR32_SYNTAX_SUBFLO,
++  AVR32_SYNTAX_SUBHH_W,
++  AVR32_SYNTAX_SWAP_B,
++  AVR32_SYNTAX_SWAP_BH,
++  AVR32_SYNTAX_SWAP_H,
++  AVR32_SYNTAX_SYNC,
++  AVR32_SYNTAX_TLBR,
++  AVR32_SYNTAX_TLBS,
++  AVR32_SYNTAX_TLBW,
++  AVR32_SYNTAX_TNBZ,
++  AVR32_SYNTAX_TST,
++  AVR32_SYNTAX_XCHG,
++  AVR32_SYNTAX_MEMC,
++  AVR32_SYNTAX_MEMS,
++  AVR32_SYNTAX_MEMT,
++  AVR32_SYNTAX_FADD_S,
++  AVR32_SYNTAX_FADD_D,
++  AVR32_SYNTAX_FSUB_S,
++  AVR32_SYNTAX_FSUB_D,
++  AVR32_SYNTAX_FMAC_S,
++  AVR32_SYNTAX_FMAC_D,
++  AVR32_SYNTAX_FNMAC_S,
++  AVR32_SYNTAX_FNMAC_D,
++  AVR32_SYNTAX_FMSC_S,
++  AVR32_SYNTAX_FMSC_D,
++  AVR32_SYNTAX_FNMSC_S,
++  AVR32_SYNTAX_FNMSC_D,
++  AVR32_SYNTAX_FMUL_S,
++  AVR32_SYNTAX_FMUL_D,
++  AVR32_SYNTAX_FNMUL_S,
++  AVR32_SYNTAX_FNMUL_D,
++  AVR32_SYNTAX_FNEG_S,
++  AVR32_SYNTAX_FNEG_D,
++  AVR32_SYNTAX_FABS_S,
++  AVR32_SYNTAX_FABS_D,
++  AVR32_SYNTAX_FCMP_S,
++  AVR32_SYNTAX_FCMP_D,
++  AVR32_SYNTAX_FMOV1_S,
++  AVR32_SYNTAX_FMOV1_D,
++  AVR32_SYNTAX_FMOV2_S,
++  AVR32_SYNTAX_FMOV2_D,
++  AVR32_SYNTAX_FMOV3_S,
++  AVR32_SYNTAX_FMOV3_D,
++  AVR32_SYNTAX_FCASTS_D,
++  AVR32_SYNTAX_FCASTD_S,
++  AVR32_SYNTAX_LDA_W,
++  AVR32_SYNTAX_CALL,
++  AVR32_SYNTAX_PICOSVMAC0,
++  AVR32_SYNTAX_PICOSVMAC1,
++  AVR32_SYNTAX_PICOSVMAC2,
++  AVR32_SYNTAX_PICOSVMAC3,
++  AVR32_SYNTAX_PICOSVMUL0,
++  AVR32_SYNTAX_PICOSVMUL1,
++  AVR32_SYNTAX_PICOSVMUL2,
++  AVR32_SYNTAX_PICOSVMUL3,
++  AVR32_SYNTAX_PICOVMAC0,
++  AVR32_SYNTAX_PICOVMAC1,
++  AVR32_SYNTAX_PICOVMAC2,
++  AVR32_SYNTAX_PICOVMAC3,
++  AVR32_SYNTAX_PICOVMUL0,
++  AVR32_SYNTAX_PICOVMUL1,
++  AVR32_SYNTAX_PICOVMUL2,
++  AVR32_SYNTAX_PICOVMUL3,
++  AVR32_SYNTAX_PICOLD_D2,
++  AVR32_SYNTAX_PICOLD_D3,
++  AVR32_SYNTAX_PICOLD_D1,
++  AVR32_SYNTAX_PICOLD_W2,
++  AVR32_SYNTAX_PICOLD_W3,
++  AVR32_SYNTAX_PICOLD_W1,
++  AVR32_SYNTAX_PICOLDM_D,
++  AVR32_SYNTAX_PICOLDM_D_PU,
++  AVR32_SYNTAX_PICOLDM_W,
++  AVR32_SYNTAX_PICOLDM_W_PU,
++  AVR32_SYNTAX_PICOMV_D1,
++  AVR32_SYNTAX_PICOMV_D2,
++  AVR32_SYNTAX_PICOMV_W1,
++  AVR32_SYNTAX_PICOMV_W2,
++  AVR32_SYNTAX_PICOST_D2,
++  AVR32_SYNTAX_PICOST_D3,
++  AVR32_SYNTAX_PICOST_D1,
++  AVR32_SYNTAX_PICOST_W2,
++  AVR32_SYNTAX_PICOST_W3,
++  AVR32_SYNTAX_PICOST_W1,
++  AVR32_SYNTAX_PICOSTM_D,
++  AVR32_SYNTAX_PICOSTM_D_PU,
++  AVR32_SYNTAX_PICOSTM_W,
++  AVR32_SYNTAX_PICOSTM_W_PU,
++  AVR32_SYNTAX__END_
++};
++#define AVR32_NR_SYNTAX AVR32_SYNTAX__END_
++
++enum avr32_alias_type
++  {
++    AVR32_ALIAS_FMAC_S,
++    AVR32_ALIAS_FMAC_D,
++    AVR32_ALIAS_FNMAC_S,
++    AVR32_ALIAS_FNMAC_D,
++    AVR32_ALIAS_FMSC_S,
++    AVR32_ALIAS_FMSC_D,
++    AVR32_ALIAS_FNMSC_S,
++    AVR32_ALIAS_FNMSC_D,
++    AVR32_ALIAS_FADD_S,
++    AVR32_ALIAS_FADD_D,
++    AVR32_ALIAS_FSUB_S,
++    AVR32_ALIAS_FSUB_D,
++    AVR32_ALIAS_FMUL_S,
++    AVR32_ALIAS_FMUL_D,
++    AVR32_ALIAS_FNMUL_S,
++    AVR32_ALIAS_FNMUL_D,
++    AVR32_ALIAS_FNEG_S,
++    AVR32_ALIAS_FNEG_D,
++    AVR32_ALIAS_FABS_S,
++    AVR32_ALIAS_FABS_D,
++    AVR32_ALIAS_FCMP_S,
++    AVR32_ALIAS_FCMP_D,
++    AVR32_ALIAS_FMOV1_S,
++    AVR32_ALIAS_FMOV1_D,
++    AVR32_ALIAS_FMOV2_S,
++    AVR32_ALIAS_FMOV2_D,
++    AVR32_ALIAS_FMOV3_S,
++    AVR32_ALIAS_FMOV3_D,
++    AVR32_ALIAS_FCASTS_D,
++    AVR32_ALIAS_FCASTD_S,
++    AVR32_ALIAS_PICOSVMAC0,
++    AVR32_ALIAS_PICOSVMAC1,
++    AVR32_ALIAS_PICOSVMAC2,
++    AVR32_ALIAS_PICOSVMAC3,
++    AVR32_ALIAS_PICOSVMUL0,
++    AVR32_ALIAS_PICOSVMUL1,
++    AVR32_ALIAS_PICOSVMUL2,
++    AVR32_ALIAS_PICOSVMUL3,
++    AVR32_ALIAS_PICOVMAC0,
++    AVR32_ALIAS_PICOVMAC1,
++    AVR32_ALIAS_PICOVMAC2,
++    AVR32_ALIAS_PICOVMAC3,
++    AVR32_ALIAS_PICOVMUL0,
++    AVR32_ALIAS_PICOVMUL1,
++    AVR32_ALIAS_PICOVMUL2,
++    AVR32_ALIAS_PICOVMUL3,
++    AVR32_ALIAS_PICOLD_D1,
++    AVR32_ALIAS_PICOLD_D2,
++    AVR32_ALIAS_PICOLD_D3,
++    AVR32_ALIAS_PICOLD_W1,
++    AVR32_ALIAS_PICOLD_W2,
++    AVR32_ALIAS_PICOLD_W3,
++    AVR32_ALIAS_PICOLDM_D,
++    AVR32_ALIAS_PICOLDM_D_PU,
++    AVR32_ALIAS_PICOLDM_W,
++    AVR32_ALIAS_PICOLDM_W_PU,
++    AVR32_ALIAS_PICOMV_D1,
++    AVR32_ALIAS_PICOMV_D2,
++    AVR32_ALIAS_PICOMV_W1,
++    AVR32_ALIAS_PICOMV_W2,
++    AVR32_ALIAS_PICOST_D1,
++    AVR32_ALIAS_PICOST_D2,
++    AVR32_ALIAS_PICOST_D3,
++    AVR32_ALIAS_PICOST_W1,
++    AVR32_ALIAS_PICOST_W2,
++    AVR32_ALIAS_PICOST_W3,
++    AVR32_ALIAS_PICOSTM_D,
++    AVR32_ALIAS_PICOSTM_D_PU,
++    AVR32_ALIAS_PICOSTM_W,
++    AVR32_ALIAS_PICOSTM_W_PU,
++    AVR32_ALIAS__END_
++  };
++#define AVR32_NR_ALIAS AVR32_ALIAS__END_
++
++enum avr32_mnemonic_type
++{
++  AVR32_MNEMONIC_ABS,
++  AVR32_MNEMONIC_ACALL,
++  AVR32_MNEMONIC_ACR,
++  AVR32_MNEMONIC_ADC,
++  AVR32_MNEMONIC_ADD,
++  AVR32_MNEMONIC_ADDABS,
++  AVR32_MNEMONIC_ADDHH_W,
++  AVR32_MNEMONIC_AND,
++  AVR32_MNEMONIC_ANDH,
++  AVR32_MNEMONIC_ANDL,
++  AVR32_MNEMONIC_ANDN,
++  AVR32_MNEMONIC_ASR,
++  AVR32_MNEMONIC_BFEXTS,
++  AVR32_MNEMONIC_BFEXTU,
++  AVR32_MNEMONIC_BFINS,
++  AVR32_MNEMONIC_BLD,
++  AVR32_MNEMONIC_BREQ,
++  AVR32_MNEMONIC_BRNE,
++  AVR32_MNEMONIC_BRCC,
++  AVR32_MNEMONIC_BRCS,
++  AVR32_MNEMONIC_BRGE,
++  AVR32_MNEMONIC_BRLT,
++  AVR32_MNEMONIC_BRMI,
++  AVR32_MNEMONIC_BRPL,
++  AVR32_MNEMONIC_BRHS,
++  AVR32_MNEMONIC_BRLO,
++  AVR32_MNEMONIC_BRLS,
++  AVR32_MNEMONIC_BRGT,
++  AVR32_MNEMONIC_BRLE,
++  AVR32_MNEMONIC_BRHI,
++  AVR32_MNEMONIC_BRVS,
++  AVR32_MNEMONIC_BRVC,
++  AVR32_MNEMONIC_BRQS,
++  AVR32_MNEMONIC_BRAL,
++  AVR32_MNEMONIC_BREAKPOINT,
++  AVR32_MNEMONIC_BREV,
++  AVR32_MNEMONIC_BST,
++  AVR32_MNEMONIC_CACHE,
++  AVR32_MNEMONIC_CASTS_B,
++  AVR32_MNEMONIC_CASTS_H,
++  AVR32_MNEMONIC_CASTU_B,
++  AVR32_MNEMONIC_CASTU_H,
++  AVR32_MNEMONIC_CBR,
++  AVR32_MNEMONIC_CLZ,
++  AVR32_MNEMONIC_COM,
++  AVR32_MNEMONIC_COP,
++  AVR32_MNEMONIC_CP_B,
++  AVR32_MNEMONIC_CP_H,
++  AVR32_MNEMONIC_CP_W,
++  AVR32_MNEMONIC_CP,
++  AVR32_MNEMONIC_CPC,
++  AVR32_MNEMONIC_CSRF,
++  AVR32_MNEMONIC_CSRFCZ,
++  AVR32_MNEMONIC_DIVS,
++  AVR32_MNEMONIC_DIVU,
++  AVR32_MNEMONIC_EOR,
++  AVR32_MNEMONIC_EORL,
++  AVR32_MNEMONIC_EORH,
++  AVR32_MNEMONIC_FRS,
++  AVR32_MNEMONIC_ICALL,
++  AVR32_MNEMONIC_INCJOSP,
++  AVR32_MNEMONIC_LD_D,
++  AVR32_MNEMONIC_LD_SB,
++  AVR32_MNEMONIC_LD_UB,
++  AVR32_MNEMONIC_LD_SH,
++  AVR32_MNEMONIC_LD_UH,
++  AVR32_MNEMONIC_LD_W,
++  AVR32_MNEMONIC_LDC_D,
++  AVR32_MNEMONIC_LDC_W,
++  AVR32_MNEMONIC_LDC0_D,
++  AVR32_MNEMONIC_LDC0_W,
++  AVR32_MNEMONIC_LDCM_D,
++  AVR32_MNEMONIC_LDCM_W,
++  AVR32_MNEMONIC_LDDPC,
++  AVR32_MNEMONIC_LDDSP,
++  AVR32_MNEMONIC_LDINS_B,
++  AVR32_MNEMONIC_LDINS_H,
++  AVR32_MNEMONIC_LDM,
++  AVR32_MNEMONIC_LDMTS,
++  AVR32_MNEMONIC_LDSWP_SH,
++  AVR32_MNEMONIC_LDSWP_UH,
++  AVR32_MNEMONIC_LDSWP_W,
++  AVR32_MNEMONIC_LSL,
++  AVR32_MNEMONIC_LSR,
++  AVR32_MNEMONIC_MAC,
++  AVR32_MNEMONIC_MACHH_D,
++  AVR32_MNEMONIC_MACHH_W,
++  AVR32_MNEMONIC_MACS_D,
++  AVR32_MNEMONIC_MACSATHH_W,
++  AVR32_MNEMONIC_MACU_D,
++  AVR32_MNEMONIC_MACWH_D,
++  AVR32_MNEMONIC_MAX,
++  AVR32_MNEMONIC_MCALL,
++  AVR32_MNEMONIC_MFDR,
++  AVR32_MNEMONIC_MFSR,
++  AVR32_MNEMONIC_MIN,
++  AVR32_MNEMONIC_MOV,
++  AVR32_MNEMONIC_MOVEQ,
++  AVR32_MNEMONIC_MOVNE,
++  AVR32_MNEMONIC_MOVCC,
++  AVR32_MNEMONIC_MOVCS,
++  AVR32_MNEMONIC_MOVGE,
++  AVR32_MNEMONIC_MOVLT,
++  AVR32_MNEMONIC_MOVMI,
++  AVR32_MNEMONIC_MOVPL,
++  AVR32_MNEMONIC_MOVLS,
++  AVR32_MNEMONIC_MOVGT,
++  AVR32_MNEMONIC_MOVLE,
++  AVR32_MNEMONIC_MOVHI,
++  AVR32_MNEMONIC_MOVVS,
++  AVR32_MNEMONIC_MOVVC,
++  AVR32_MNEMONIC_MOVQS,
++  AVR32_MNEMONIC_MOVAL,
++  AVR32_MNEMONIC_MOVHS,
++  AVR32_MNEMONIC_MOVLO,
++  AVR32_MNEMONIC_MTDR,
++  AVR32_MNEMONIC_MTSR,
++  AVR32_MNEMONIC_MUL,
++  AVR32_MNEMONIC_MULHH_W,
++  AVR32_MNEMONIC_MULNHH_W,
++  AVR32_MNEMONIC_MULNWH_D,
++  AVR32_MNEMONIC_MULS_D,
++  AVR32_MNEMONIC_MULSATHH_H,
++  AVR32_MNEMONIC_MULSATHH_W,
++  AVR32_MNEMONIC_MULSATRNDHH_H,
++  AVR32_MNEMONIC_MULSATRNDWH_W,
++  AVR32_MNEMONIC_MULSATWH_W,
++  AVR32_MNEMONIC_MULU_D,
++  AVR32_MNEMONIC_MULWH_D,
++  AVR32_MNEMONIC_MUSFR,
++  AVR32_MNEMONIC_MUSTR,
++  AVR32_MNEMONIC_MVCR_D,
++  AVR32_MNEMONIC_MVCR_W,
++  AVR32_MNEMONIC_MVRC_D,
++  AVR32_MNEMONIC_MVRC_W,
++  AVR32_MNEMONIC_NEG,
++  AVR32_MNEMONIC_NOP,
++  AVR32_MNEMONIC_OR,
++  AVR32_MNEMONIC_ORH,
++  AVR32_MNEMONIC_ORL,
++  AVR32_MNEMONIC_PABS_SB,
++  AVR32_MNEMONIC_PABS_SH,
++  AVR32_MNEMONIC_PACKSH_SB,
++  AVR32_MNEMONIC_PACKSH_UB,
++  AVR32_MNEMONIC_PACKW_SH,
++  AVR32_MNEMONIC_PADD_B,
++  AVR32_MNEMONIC_PADD_H,
++  AVR32_MNEMONIC_PADDH_SH,
++  AVR32_MNEMONIC_PADDH_UB,
++  AVR32_MNEMONIC_PADDS_SB,
++  AVR32_MNEMONIC_PADDS_SH,
++  AVR32_MNEMONIC_PADDS_UB,
++  AVR32_MNEMONIC_PADDS_UH,
++  AVR32_MNEMONIC_PADDSUB_H,
++  AVR32_MNEMONIC_PADDSUBH_SH,
++  AVR32_MNEMONIC_PADDSUBS_SH,
++  AVR32_MNEMONIC_PADDSUBS_UH,
++  AVR32_MNEMONIC_PADDX_H,
++  AVR32_MNEMONIC_PADDXH_SH,
++  AVR32_MNEMONIC_PADDXS_SH,
++  AVR32_MNEMONIC_PADDXS_UH,
++  AVR32_MNEMONIC_PASR_B,
++  AVR32_MNEMONIC_PASR_H,
++  AVR32_MNEMONIC_PAVG_SH,
++  AVR32_MNEMONIC_PAVG_UB,
++  AVR32_MNEMONIC_PLSL_B,
++  AVR32_MNEMONIC_PLSL_H,
++  AVR32_MNEMONIC_PLSR_B,
++  AVR32_MNEMONIC_PLSR_H,
++  AVR32_MNEMONIC_PMAX_SH,
++  AVR32_MNEMONIC_PMAX_UB,
++  AVR32_MNEMONIC_PMIN_SH,
++  AVR32_MNEMONIC_PMIN_UB,
++  AVR32_MNEMONIC_POPJC,
++  AVR32_MNEMONIC_POPM,
++  AVR32_MNEMONIC_PREF,
++  AVR32_MNEMONIC_PSAD,
++  AVR32_MNEMONIC_PSUB_B,
++  AVR32_MNEMONIC_PSUB_H,
++  AVR32_MNEMONIC_PSUBADD_H,
++  AVR32_MNEMONIC_PSUBADDH_SH,
++  AVR32_MNEMONIC_PSUBADDS_SH,
++  AVR32_MNEMONIC_PSUBADDS_UH,
++  AVR32_MNEMONIC_PSUBH_SH,
++  AVR32_MNEMONIC_PSUBH_UB,
++  AVR32_MNEMONIC_PSUBS_SB,
++  AVR32_MNEMONIC_PSUBS_SH,
++  AVR32_MNEMONIC_PSUBS_UB,
++  AVR32_MNEMONIC_PSUBS_UH,
++  AVR32_MNEMONIC_PSUBX_H,
++  AVR32_MNEMONIC_PSUBXH_SH,
++  AVR32_MNEMONIC_PSUBXS_SH,
++  AVR32_MNEMONIC_PSUBXS_UH,
++  AVR32_MNEMONIC_PUNPCKSB_H,
++  AVR32_MNEMONIC_PUNPCKUB_H,
++  AVR32_MNEMONIC_PUSHJC,
++  AVR32_MNEMONIC_PUSHM,
++  AVR32_MNEMONIC_RCALL,
++  AVR32_MNEMONIC_RETEQ,
++  AVR32_MNEMONIC_RETNE,
++  AVR32_MNEMONIC_RETCC,
++  AVR32_MNEMONIC_RETCS,
++  AVR32_MNEMONIC_RETGE,
++  AVR32_MNEMONIC_RETLT,
++  AVR32_MNEMONIC_RETMI,
++  AVR32_MNEMONIC_RETPL,
++  AVR32_MNEMONIC_RETLS,
++  AVR32_MNEMONIC_RETGT,
++  AVR32_MNEMONIC_RETLE,
++  AVR32_MNEMONIC_RETHI,
++  AVR32_MNEMONIC_RETVS,
++  AVR32_MNEMONIC_RETVC,
++  AVR32_MNEMONIC_RETQS,
++  AVR32_MNEMONIC_RETAL,
++  AVR32_MNEMONIC_RETHS,
++  AVR32_MNEMONIC_RETLO,
++  AVR32_MNEMONIC_RET,
++  AVR32_MNEMONIC_RETD,
++  AVR32_MNEMONIC_RETE,
++  AVR32_MNEMONIC_RETJ,
++  AVR32_MNEMONIC_RETS,
++  AVR32_MNEMONIC_RJMP,
++  AVR32_MNEMONIC_ROL,
++  AVR32_MNEMONIC_ROR,
++  AVR32_MNEMONIC_RSUB,
++  AVR32_MNEMONIC_SATADD_H,
++  AVR32_MNEMONIC_SATADD_W,
++  AVR32_MNEMONIC_SATRNDS,
++  AVR32_MNEMONIC_SATRNDU,
++  AVR32_MNEMONIC_SATS,
++  AVR32_MNEMONIC_SATSUB_H,
++  AVR32_MNEMONIC_SATSUB_W,
++  AVR32_MNEMONIC_SATU,
++  AVR32_MNEMONIC_SBC,
++  AVR32_MNEMONIC_SBR,
++  AVR32_MNEMONIC_SCALL,
++  AVR32_MNEMONIC_SCR,
++  AVR32_MNEMONIC_SLEEP,
++  AVR32_MNEMONIC_SREQ,
++  AVR32_MNEMONIC_SRNE,
++  AVR32_MNEMONIC_SRCC,
++  AVR32_MNEMONIC_SRCS,
++  AVR32_MNEMONIC_SRGE,
++  AVR32_MNEMONIC_SRLT,
++  AVR32_MNEMONIC_SRMI,
++  AVR32_MNEMONIC_SRPL,
++  AVR32_MNEMONIC_SRLS,
++  AVR32_MNEMONIC_SRGT,
++  AVR32_MNEMONIC_SRLE,
++  AVR32_MNEMONIC_SRHI,
++  AVR32_MNEMONIC_SRVS,
++  AVR32_MNEMONIC_SRVC,
++  AVR32_MNEMONIC_SRQS,
++  AVR32_MNEMONIC_SRAL,
++  AVR32_MNEMONIC_SRHS,
++  AVR32_MNEMONIC_SRLO,
++  AVR32_MNEMONIC_SSRF,
++  AVR32_MNEMONIC_ST_B,
++  AVR32_MNEMONIC_ST_D,
++  AVR32_MNEMONIC_ST_H,
++  AVR32_MNEMONIC_ST_W,
++  AVR32_MNEMONIC_STC_D,
++  AVR32_MNEMONIC_STC_W,
++  AVR32_MNEMONIC_STC0_D,
++  AVR32_MNEMONIC_STC0_W,
++  AVR32_MNEMONIC_STCM_D,
++  AVR32_MNEMONIC_STCM_W,
++  AVR32_MNEMONIC_STCOND,
++  AVR32_MNEMONIC_STDSP,
++  AVR32_MNEMONIC_STHH_W,
++  AVR32_MNEMONIC_STM,
++  AVR32_MNEMONIC_STMTS,
++  AVR32_MNEMONIC_STSWP_H,
++  AVR32_MNEMONIC_STSWP_W,
++  AVR32_MNEMONIC_SUB,
++  AVR32_MNEMONIC_SUBEQ,
++  AVR32_MNEMONIC_SUBNE,
++  AVR32_MNEMONIC_SUBCC,
++  AVR32_MNEMONIC_SUBCS,
++  AVR32_MNEMONIC_SUBGE,
++  AVR32_MNEMONIC_SUBLT,
++  AVR32_MNEMONIC_SUBMI,
++  AVR32_MNEMONIC_SUBPL,
++  AVR32_MNEMONIC_SUBLS,
++  AVR32_MNEMONIC_SUBGT,
++  AVR32_MNEMONIC_SUBLE,
++  AVR32_MNEMONIC_SUBHI,
++  AVR32_MNEMONIC_SUBVS,
++  AVR32_MNEMONIC_SUBVC,
++  AVR32_MNEMONIC_SUBQS,
++  AVR32_MNEMONIC_SUBAL,
++  AVR32_MNEMONIC_SUBHS,
++  AVR32_MNEMONIC_SUBLO,
++  AVR32_MNEMONIC_SUBFEQ,
++  AVR32_MNEMONIC_SUBFNE,
++  AVR32_MNEMONIC_SUBFCC,
++  AVR32_MNEMONIC_SUBFCS,
++  AVR32_MNEMONIC_SUBFGE,
++  AVR32_MNEMONIC_SUBFLT,
++  AVR32_MNEMONIC_SUBFMI,
++  AVR32_MNEMONIC_SUBFPL,
++  AVR32_MNEMONIC_SUBFLS,
++  AVR32_MNEMONIC_SUBFGT,
++  AVR32_MNEMONIC_SUBFLE,
++  AVR32_MNEMONIC_SUBFHI,
++  AVR32_MNEMONIC_SUBFVS,
++  AVR32_MNEMONIC_SUBFVC,
++  AVR32_MNEMONIC_SUBFQS,
++  AVR32_MNEMONIC_SUBFAL,
++  AVR32_MNEMONIC_SUBFHS,
++  AVR32_MNEMONIC_SUBFLO,
++  AVR32_MNEMONIC_SUBHH_W,
++  AVR32_MNEMONIC_SWAP_B,
++  AVR32_MNEMONIC_SWAP_BH,
++  AVR32_MNEMONIC_SWAP_H,
++  AVR32_MNEMONIC_SYNC,
++  AVR32_MNEMONIC_TLBR,
++  AVR32_MNEMONIC_TLBS,
++  AVR32_MNEMONIC_TLBW,
++  AVR32_MNEMONIC_TNBZ,
++  AVR32_MNEMONIC_TST,
++  AVR32_MNEMONIC_XCHG,
++  AVR32_MNEMONIC_MEMC,
++  AVR32_MNEMONIC_MEMS,
++  AVR32_MNEMONIC_MEMT,
++  AVR32_MNEMONIC_FADD_S,
++  AVR32_MNEMONIC_FADD_D,
++  AVR32_MNEMONIC_FSUB_S,
++  AVR32_MNEMONIC_FSUB_D,
++  AVR32_MNEMONIC_FMAC_S,
++  AVR32_MNEMONIC_FMAC_D,
++  AVR32_MNEMONIC_FNMAC_S,
++  AVR32_MNEMONIC_FNMAC_D,
++  AVR32_MNEMONIC_FMSC_S,
++  AVR32_MNEMONIC_FMSC_D,
++  AVR32_MNEMONIC_FNMSC_S,
++  AVR32_MNEMONIC_FNMSC_D,
++  AVR32_MNEMONIC_FMUL_S,
++  AVR32_MNEMONIC_FMUL_D,
++  AVR32_MNEMONIC_FNMUL_S,
++  AVR32_MNEMONIC_FNMUL_D,
++  AVR32_MNEMONIC_FNEG_S,
++  AVR32_MNEMONIC_FNEG_D,
++  AVR32_MNEMONIC_FABS_S,
++  AVR32_MNEMONIC_FABS_D,
++  AVR32_MNEMONIC_FCMP_S,
++  AVR32_MNEMONIC_FCMP_D,
++  AVR32_MNEMONIC_FMOV_S,
++  AVR32_MNEMONIC_FMOV_D,
++  AVR32_MNEMONIC_FCASTS_D,
++  AVR32_MNEMONIC_FCASTD_S,
++  /* AVR32_MNEMONIC_FLD_S,
++     AVR32_MNEMONIC_FLD_D,
++     AVR32_MNEMONIC_FST_S,
++     AVR32_MNEMONIC_FST_D, */
++  AVR32_MNEMONIC_LDA_W,
++  AVR32_MNEMONIC_CALL,
++  AVR32_MNEMONIC_PICOSVMAC,
++  AVR32_MNEMONIC_PICOSVMUL,
++  AVR32_MNEMONIC_PICOVMAC,
++  AVR32_MNEMONIC_PICOVMUL,
++  AVR32_MNEMONIC_PICOLD_D,
++  AVR32_MNEMONIC_PICOLD_W,
++  AVR32_MNEMONIC_PICOLDM_D,
++  AVR32_MNEMONIC_PICOLDM_W,
++  AVR32_MNEMONIC_PICOMV_D,
++  AVR32_MNEMONIC_PICOMV_W,
++  AVR32_MNEMONIC_PICOST_D,
++  AVR32_MNEMONIC_PICOST_W,
++  AVR32_MNEMONIC_PICOSTM_D,
++  AVR32_MNEMONIC_PICOSTM_W,
++  AVR32_MNEMONIC__END_
++};
++#define AVR32_NR_MNEMONICS AVR32_MNEMONIC__END_
++
++enum avr32_syntax_parser
++  {
++    AVR32_PARSER_NORMAL,
++    AVR32_PARSER_ALIAS,
++    AVR32_PARSER_LDA,
++    AVR32_PARSER_CALL,
++    AVR32_PARSER__END_
++  };
++#define AVR32_NR_PARSERS AVR32_PARSER__END_
+diff -Nrup binutils-2.17/opcodes/config.in binutils-2.17-atmel/opcodes/config.in
+--- binutils-2.17/opcodes/config.in    2005-03-31 18:52:53.000000000 +0200
++++ binutils-2.17-atmel/opcodes/config.in      2007-02-20 16:07:47.000000000 +0100
+@@ -138,7 +138,7 @@
+ /* If using the C implementation of alloca, define if you know the
+    direction of stack growth for your system; otherwise it will be
+-   automatically deduced at run-time.
++   automatically deduced at runtime.
+       STACK_DIRECTION > 0 => grows toward higher addresses
+       STACK_DIRECTION < 0 => grows toward lower addresses
+       STACK_DIRECTION = 0 => direction of growth unknown */
+@@ -159,8 +159,8 @@
+ #undef inline
+ #endif
+-/* Define to `long' if <sys/types.h> does not define. */
++/* Define to `long int' if <sys/types.h> does not define. */
+ #undef off_t
+-/* Define to `unsigned' if <sys/types.h> does not define. */
++/* Define to `unsigned int' if <sys/types.h> does not define. */
+ #undef size_t
+diff -Nrup binutils-2.17/opcodes/configure binutils-2.17-atmel/opcodes/configure
+--- binutils-2.17/opcodes/configure    2006-02-17 15:36:28.000000000 +0100
++++ binutils-2.17-atmel/opcodes/configure      2007-02-20 16:07:46.000000000 +0100
+@@ -1,25 +1,54 @@
+ #! /bin/sh
+ # Guess values for system-dependent variables and create Makefiles.
+-# Generated by GNU Autoconf 2.59.
++# Generated by GNU Autoconf 2.61.
+ #
+-# Copyright (C) 2003 Free Software Foundation, Inc.
++# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ # This configure script is free software; the Free Software Foundation
+ # gives unlimited permission to copy, distribute and modify it.
+ ## --------------------- ##
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -29,8 +58,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -44,18 +108,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -63,157 +128,388 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++# CDPATH.
++$as_unset CDPATH
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
++if test "x$CONFIG_SHELL" = x; then
++  if (eval ":") 2>/dev/null; then
++  as_have_required=yes
++else
++  as_have_required=no
++fi
++
++  if test $as_have_required = yes &&   (eval ":
++(as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
+ fi
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0) || { (exit 1); exit 1; }
++
++(
++  as_lineno_1=\$LINENO
++  as_lineno_2=\$LINENO
++  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
++  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
++") 2> /dev/null; then
++  :
++else
++  as_candidate_shells=
+     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
++  case $as_dir in
+        /*)
+-         if ("$as_dir/$as_base" -c '
++         for as_base in sh bash ksh sh5; do
++           as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
++         done;;
++       esac
++done
++IFS=$as_save_IFS
++
++
++      for as_shell in $as_candidate_shells $SHELL; do
++       # Try only shells that exist, to save several forks.
++       if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
++              { ("$as_shell") 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++_ASEOF
++}; then
++  CONFIG_SHELL=$as_shell
++             as_have_required=yes
++             if { "$as_shell" 2> /dev/null <<\_ASEOF
++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
++  emulate sh
++  NULLCMD=:
++  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
++  # is contrary to our usage.  Disable this feature.
++  alias -g '${1+"$@"}'='"$@"'
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++:
++(as_func_return () {
++  (exit $1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = "$1" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test $exitcode = 0) || { (exit 1); exit 1; }
++
++(
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
++
++_ASEOF
++}; then
++  break
++fi
++
++fi
++
++      done
++
++      if test "x$CONFIG_SHELL" != x; then
++  for as_var in BASH_ENV ENV
++        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++        done
++        export CONFIG_SHELL
++        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
++fi
++
++
++    if test $as_have_required = no; then
++  echo This script requires a shell more modern than all the
++      echo shells that I found on your system.  Please install a
++      echo modern shell, or manually run the script under such a
++      echo shell if you do have one.
++      { (exit 1); exit 1; }
++fi
++
++
++fi
++
++fi
++
++
++
++(eval "as_func_return () {
++  (exit \$1)
++}
++as_func_success () {
++  as_func_return 0
++}
++as_func_failure () {
++  as_func_return 1
++}
++as_func_ret_success () {
++  return 0
++}
++as_func_ret_failure () {
++  return 1
++}
++
++exitcode=0
++if as_func_success; then
++  :
++else
++  exitcode=1
++  echo as_func_success failed.
++fi
++
++if as_func_failure; then
++  exitcode=1
++  echo as_func_failure succeeded.
++fi
++
++if as_func_ret_success; then
++  :
++else
++  exitcode=1
++  echo as_func_ret_success failed.
++fi
++
++if as_func_ret_failure; then
++  exitcode=1
++  echo as_func_ret_failure succeeded.
++fi
++
++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
++  :
++else
++  exitcode=1
++  echo positional parameters were not saved.
++fi
++
++test \$exitcode = 0") || {
++  echo No shell found that supports shell functions.
++  echo Please tell autoconf@gnu.org about your system,
++  echo including any error possibly output before this
++  echo message
++}
++
++
++
++  as_lineno_1=$LINENO
++  as_lineno_2=$LINENO
++  test "x$as_lineno_1" != "x$as_lineno_2" &&
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
++  chmod +x "$as_me.lineno" ||
+     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -222,7 +518,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -231,39 +548,27 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
++exec 7<&0 </dev/null 6>&1
+ # Name of the host.
+ # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+ # so uname gets run too.
+ ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+-exec 6>&1
+-
+ #
+ # Initializations.
+ #
+ ac_default_prefix=/usr/local
++ac_clean_files=
+ ac_config_libobj_dir=.
++LIBOBJS=
+ cross_compiling=no
+ subdirs=
+ MFLAGS=
+ MAKEFLAGS=
+ SHELL=${CONFIG_SHELL-/bin/sh}
+-# Maximum number of lines to put in a shell here document.
+-# This variable seems obsolete.  It should probably be removed, and
+-# only ac_max_sed_lines should be used.
+-: ${ac_max_here_lines=38}
+-
+ # Identity of this package.
+ PACKAGE_NAME=
+ PACKAGE_TARNAME=
+@@ -275,42 +580,187 @@ ac_unique_file="z8k-dis.c"
+ # Factoring default headers for most tests.
+ ac_includes_default="\
+ #include <stdio.h>
+-#if HAVE_SYS_TYPES_H
++#ifdef HAVE_SYS_TYPES_H
+ # include <sys/types.h>
+ #endif
+-#if HAVE_SYS_STAT_H
++#ifdef HAVE_SYS_STAT_H
+ # include <sys/stat.h>
+ #endif
+-#if STDC_HEADERS
++#ifdef STDC_HEADERS
+ # include <stdlib.h>
+ # include <stddef.h>
+ #else
+-# if HAVE_STDLIB_H
++# ifdef HAVE_STDLIB_H
+ #  include <stdlib.h>
+ # endif
+ #endif
+-#if HAVE_STRING_H
+-# if !STDC_HEADERS && HAVE_MEMORY_H
++#ifdef HAVE_STRING_H
++# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+ #  include <memory.h>
+ # endif
+ # include <string.h>
+ #endif
+-#if HAVE_STRINGS_H
++#ifdef HAVE_STRINGS_H
+ # include <strings.h>
+ #endif
+-#if HAVE_INTTYPES_H
++#ifdef HAVE_INTTYPES_H
+ # include <inttypes.h>
+-#else
+-# if HAVE_STDINT_H
+-#  include <stdint.h>
+-# endif
+ #endif
+-#if HAVE_UNISTD_H
++#ifdef HAVE_STDINT_H
++# include <stdint.h>
++#endif
++#ifdef HAVE_UNISTD_H
+ # include <unistd.h>
+ #endif"
+-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE AR ac_ct_AR RANLIB ac_ct_RANLIB LN_S LIBTOOL WARN_CFLAGS NO_WERROR MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT INSTALL_LIBBFD_TRUE INSTALL_LIBBFD_FALSE host_noncanonical target_noncanonical bfdlibdir bfdincludedir CPP EGREP ALLOCA USE_NLS MSGFMT GMSGFMT XGETTEXT USE_INCLUDED_LIBINTL CATALOGS CATOBJEXT DATADIRNAME GMOFILES INSTOBJEXT INTLDEPS INTLLIBS INTLOBJS POFILES POSUB INCLUDE_LOCALE_H GT_NO GT_YES MKINSTALLDIRS l CC_FOR_BUILD EXEEXT_FOR_BUILD HDEFINES CGEN_MAINT_TRUE CGEN_MAINT_FALSE cgendir WIN32LDFLAGS WIN32LIBADD archdefs BFD_MACHINES LIBOBJS LTLIBOBJS'
++ac_subst_vars='SHELL
++PATH_SEPARATOR
++PACKAGE_NAME
++PACKAGE_TARNAME
++PACKAGE_VERSION
++PACKAGE_STRING
++PACKAGE_BUGREPORT
++exec_prefix
++prefix
++program_transform_name
++bindir
++sbindir
++libexecdir
++datarootdir
++datadir
++sysconfdir
++sharedstatedir
++localstatedir
++includedir
++oldincludedir
++docdir
++infodir
++htmldir
++dvidir
++pdfdir
++psdir
++libdir
++localedir
++mandir
++DEFS
++ECHO_C
++ECHO_N
++ECHO_T
++LIBS
++build_alias
++host_alias
++target_alias
++build
++build_cpu
++build_vendor
++build_os
++host
++host_cpu
++host_vendor
++host_os
++target
++target_cpu
++target_vendor
++target_os
++CC
++CFLAGS
++LDFLAGS
++CPPFLAGS
++ac_ct_CC
++EXEEXT
++OBJEXT
++INSTALL_PROGRAM
++INSTALL_SCRIPT
++INSTALL_DATA
++CYGPATH_W
++PACKAGE
++VERSION
++ACLOCAL
++AUTOCONF
++AUTOMAKE
++AUTOHEADER
++MAKEINFO
++install_sh
++STRIP
++INSTALL_STRIP_PROGRAM
++mkdir_p
++AWK
++SET_MAKE
++am__leading_dot
++AMTAR
++am__tar
++am__untar
++DEPDIR
++am__include
++am__quote
++AMDEP_TRUE
++AMDEP_FALSE
++AMDEPBACKSLASH
++CCDEPMODE
++am__fastdepCC_TRUE
++am__fastdepCC_FALSE
++AR
++RANLIB
++LN_S
++LIBTOOL
++WARN_CFLAGS
++NO_WERROR
++MAINTAINER_MODE_TRUE
++MAINTAINER_MODE_FALSE
++MAINT
++INSTALL_LIBBFD_TRUE
++INSTALL_LIBBFD_FALSE
++host_noncanonical
++target_noncanonical
++bfdlibdir
++bfdincludedir
++CPP
++GREP
++EGREP
++ALLOCA
++USE_NLS
++MSGFMT
++GMSGFMT
++XGETTEXT
++USE_INCLUDED_LIBINTL
++CATALOGS
++CATOBJEXT
++DATADIRNAME
++GMOFILES
++INSTOBJEXT
++INTLDEPS
++INTLLIBS
++INTLOBJS
++POFILES
++POSUB
++INCLUDE_LOCALE_H
++GT_NO
++GT_YES
++MKINSTALLDIRS
++l
++CC_FOR_BUILD
++EXEEXT_FOR_BUILD
++HDEFINES
++CGEN_MAINT_TRUE
++CGEN_MAINT_FALSE
++cgendir
++WIN32LDFLAGS
++WIN32LIBADD
++archdefs
++BFD_MACHINES
++LIBOBJS
++LTLIBOBJS'
+ ac_subst_files=''
++      ac_precious_vars='build_alias
++host_alias
++target_alias
++CC
++CFLAGS
++LDFLAGS
++LIBS
++CPPFLAGS
++CPP'
++
+ # Initialize some variables set by options.
+ ac_init_help=
+@@ -337,34 +787,48 @@ x_libraries=NONE
+ # and all the variables that are supposed to be based on exec_prefix
+ # by default will actually change.
+ # Use braces instead of parens because sh, perl, etc. also accept them.
++# (The list follows the same order as the GNU Coding Standards.)
+ bindir='${exec_prefix}/bin'
+ sbindir='${exec_prefix}/sbin'
+ libexecdir='${exec_prefix}/libexec'
+-datadir='${prefix}/share'
++datarootdir='${prefix}/share'
++datadir='${datarootdir}'
+ sysconfdir='${prefix}/etc'
+ sharedstatedir='${prefix}/com'
+ localstatedir='${prefix}/var'
+-libdir='${exec_prefix}/lib'
+ includedir='${prefix}/include'
+ oldincludedir='/usr/include'
+-infodir='${prefix}/info'
+-mandir='${prefix}/man'
++docdir='${datarootdir}/doc/${PACKAGE}'
++infodir='${datarootdir}/info'
++htmldir='${docdir}'
++dvidir='${docdir}'
++pdfdir='${docdir}'
++psdir='${docdir}'
++libdir='${exec_prefix}/lib'
++localedir='${datarootdir}/locale'
++mandir='${datarootdir}/man'
+ ac_prev=
++ac_dashdash=
+ for ac_option
+ do
+   # If the previous option needs an argument, assign it.
+   if test -n "$ac_prev"; then
+-    eval "$ac_prev=\$ac_option"
++    eval $ac_prev=\$ac_option
+     ac_prev=
+     continue
+   fi
+-  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
++  case $ac_option in
++  *=*)        ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
++  *)  ac_optarg=yes ;;
++  esac
+   # Accept the important Cygnus configure options, so we can diagnose typos.
+-  case $ac_option in
++  case $ac_dashdash$ac_option in
++  --)
++    ac_dashdash=yes ;;
+   -bindir | --bindir | --bindi | --bind | --bin | --bi)
+     ac_prev=bindir ;;
+@@ -386,33 +850,45 @@ do
+   --config-cache | -C)
+     cache_file=config.cache ;;
+-  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
++  -datadir | --datadir | --datadi | --datad)
+     ac_prev=datadir ;;
+-  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+-  | --da=*)
++  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+     datadir=$ac_optarg ;;
++  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
++  | --dataroo | --dataro | --datar)
++    ac_prev=datarootdir ;;
++  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
++  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
++    datarootdir=$ac_optarg ;;
++
+   -disable-* | --disable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    eval "enable_$ac_feature=no" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=no ;;
++
++  -docdir | --docdir | --docdi | --doc | --do)
++    ac_prev=docdir ;;
++  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
++    docdir=$ac_optarg ;;
++
++  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
++    ac_prev=dvidir ;;
++  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
++    dvidir=$ac_optarg ;;
+   -enable-* | --enable-*)
+     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+    { (exit 1); exit 1; }; }
+-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "enable_$ac_feature='$ac_optarg'" ;;
++    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
++    eval enable_$ac_feature=\$ac_optarg ;;
+   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+@@ -439,6 +915,12 @@ do
+   -host=* | --host=* | --hos=* | --ho=*)
+     host_alias=$ac_optarg ;;
++  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
++    ac_prev=htmldir ;;
++  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
++  | --ht=*)
++    htmldir=$ac_optarg ;;
++
+   -includedir | --includedir | --includedi | --included | --include \
+   | --includ | --inclu | --incl | --inc)
+     ac_prev=includedir ;;
+@@ -463,13 +945,16 @@ do
+   | --libexe=* | --libex=* | --libe=*)
+     libexecdir=$ac_optarg ;;
++  -localedir | --localedir | --localedi | --localed | --locale)
++    ac_prev=localedir ;;
++  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
++    localedir=$ac_optarg ;;
++
+   -localstatedir | --localstatedir | --localstatedi | --localstated \
+-  | --localstate | --localstat | --localsta | --localst \
+-  | --locals | --local | --loca | --loc | --lo)
++  | --localstate | --localstat | --localsta | --localst | --locals)
+     ac_prev=localstatedir ;;
+   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+-  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+-  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
++  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+     localstatedir=$ac_optarg ;;
+   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+@@ -534,6 +1019,16 @@ do
+   | --progr-tra=* | --program-tr=* | --program-t=*)
+     program_transform_name=$ac_optarg ;;
++  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
++    ac_prev=pdfdir ;;
++  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
++    pdfdir=$ac_optarg ;;
++
++  -psdir | --psdir | --psdi | --psd | --ps)
++    ac_prev=psdir ;;
++  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
++    psdir=$ac_optarg ;;
++
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil)
+     silent=yes ;;
+@@ -586,24 +1081,20 @@ do
+   -with-* | --with-*)
+     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package| sed 's/-/_/g'`
+-    case $ac_option in
+-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+-      *) ac_optarg=yes ;;
+-    esac
+-    eval "with_$ac_package='$ac_optarg'" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=\$ac_optarg ;;
+   -without-* | --without-*)
+     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
++    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid package name: $ac_package" >&2
+    { (exit 1); exit 1; }; }
+-    ac_package=`echo $ac_package | sed 's/-/_/g'`
+-    eval "with_$ac_package=no" ;;
++    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
++    eval with_$ac_package=no ;;
+   --x)
+     # Obsolete; use --with-x.
+@@ -634,8 +1125,7 @@ Try \`$0 --help' for more information." 
+     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
+       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
+    { (exit 1); exit 1; }; }
+-    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
+-    eval "$ac_envvar='$ac_optarg'"
++    eval $ac_envvar=\$ac_optarg
+     export $ac_envvar ;;
+   *)
+@@ -655,27 +1145,19 @@ if test -n "$ac_prev"; then
+    { (exit 1); exit 1; }; }
+ fi
+-# Be sure to have absolute paths.
+-for ac_var in exec_prefix prefix
+-do
+-  eval ac_val=$`echo $ac_var`
+-  case $ac_val in
+-    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
+-  esac
+-done
+-
+-# Be sure to have absolute paths.
+-for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
+-            localstatedir libdir includedir oldincludedir infodir mandir
++# Be sure to have absolute directory names.
++for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
++              datadir sysconfdir sharedstatedir localstatedir includedir \
++              oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
++              libdir localedir mandir
+ do
+-  eval ac_val=$`echo $ac_var`
++  eval ac_val=\$$ac_var
+   case $ac_val in
+-    [\\/$]* | ?:[\\/]* ) ;;
+-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+-   { (exit 1); exit 1; }; };;
++    [\\/$]* | ?:[\\/]* )  continue;;
++    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+   esac
++  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
++   { (exit 1); exit 1; }; }
+ done
+ # There might be people who depend on the old broken behavior: `$host'
+@@ -702,74 +1184,76 @@ test -n "$host_alias" && ac_tool_prefix=
+ test "$silent" = yes && exec 6>/dev/null
++ac_pwd=`pwd` && test -n "$ac_pwd" &&
++ac_ls_di=`ls -di .` &&
++ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
++  { echo "$as_me: error: Working directory cannot be determined" >&2
++   { (exit 1); exit 1; }; }
++test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
++  { echo "$as_me: error: pwd does not report name of working directory" >&2
++   { (exit 1); exit 1; }; }
++
++
+ # Find the source files, if location was not specified.
+ if test -z "$srcdir"; then
+   ac_srcdir_defaulted=yes
+-  # Try the directory containing this script, then its parent.
+-  ac_confdir=`(dirname "$0") 2>/dev/null ||
++  # Try the directory containing this script, then the parent directory.
++  ac_confdir=`$as_dirname -- "$0" ||
+ $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$0" : 'X\(//\)[^/]' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$0" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   srcdir=$ac_confdir
+-  if test ! -r $srcdir/$ac_unique_file; then
++  if test ! -r "$srcdir/$ac_unique_file"; then
+     srcdir=..
+   fi
+ else
+   ac_srcdir_defaulted=no
+ fi
+-if test ! -r $srcdir/$ac_unique_file; then
+-  if test "$ac_srcdir_defaulted" = yes; then
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
+-   { (exit 1); exit 1; }; }
+-  else
+-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
+-   { (exit 1); exit 1; }; }
+-  fi
+-fi
+-(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
+-  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
+-   { (exit 1); exit 1; }; }
+-srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
+-ac_env_build_alias_set=${build_alias+set}
+-ac_env_build_alias_value=$build_alias
+-ac_cv_env_build_alias_set=${build_alias+set}
+-ac_cv_env_build_alias_value=$build_alias
+-ac_env_host_alias_set=${host_alias+set}
+-ac_env_host_alias_value=$host_alias
+-ac_cv_env_host_alias_set=${host_alias+set}
+-ac_cv_env_host_alias_value=$host_alias
+-ac_env_target_alias_set=${target_alias+set}
+-ac_env_target_alias_value=$target_alias
+-ac_cv_env_target_alias_set=${target_alias+set}
+-ac_cv_env_target_alias_value=$target_alias
+-ac_env_CC_set=${CC+set}
+-ac_env_CC_value=$CC
+-ac_cv_env_CC_set=${CC+set}
+-ac_cv_env_CC_value=$CC
+-ac_env_CFLAGS_set=${CFLAGS+set}
+-ac_env_CFLAGS_value=$CFLAGS
+-ac_cv_env_CFLAGS_set=${CFLAGS+set}
+-ac_cv_env_CFLAGS_value=$CFLAGS
+-ac_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_env_LDFLAGS_value=$LDFLAGS
+-ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
+-ac_cv_env_LDFLAGS_value=$LDFLAGS
+-ac_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_env_CPPFLAGS_value=$CPPFLAGS
+-ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
+-ac_cv_env_CPPFLAGS_value=$CPPFLAGS
+-ac_env_CPP_set=${CPP+set}
+-ac_env_CPP_value=$CPP
+-ac_cv_env_CPP_set=${CPP+set}
+-ac_cv_env_CPP_value=$CPP
++if test ! -r "$srcdir/$ac_unique_file"; then
++  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
++  { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
++   { (exit 1); exit 1; }; }
++fi
++ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
++ac_abs_confdir=`(
++      cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2
++   { (exit 1); exit 1; }; }
++      pwd)`
++# When building in place, set srcdir=.
++if test "$ac_abs_confdir" = "$ac_pwd"; then
++  srcdir=.
++fi
++# Remove unnecessary trailing slashes from srcdir.
++# Double slashes in file names in object file debugging info
++# mess up M-x gdb in Emacs.
++case $srcdir in
++*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
++esac
++for ac_var in $ac_precious_vars; do
++  eval ac_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_env_${ac_var}_value=\$${ac_var}
++  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
++  eval ac_cv_env_${ac_var}_value=\$${ac_var}
++done
+ #
+ # Report the --help message.
+@@ -798,9 +1282,6 @@ Configuration:
+   -n, --no-create         do not create output files
+       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+-_ACEOF
+-
+-  cat <<_ACEOF
+ Installation directories:
+   --prefix=PREFIX         install architecture-independent files in PREFIX
+                         [$ac_default_prefix]
+@@ -818,15 +1299,22 @@ Fine tuning of the installation director
+   --bindir=DIR           user executables [EPREFIX/bin]
+   --sbindir=DIR          system admin executables [EPREFIX/sbin]
+   --libexecdir=DIR       program executables [EPREFIX/libexec]
+-  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
+   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
+   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
+   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
+   --libdir=DIR           object code libraries [EPREFIX/lib]
+   --includedir=DIR       C header files [PREFIX/include]
+   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
+-  --infodir=DIR          info documentation [PREFIX/info]
+-  --mandir=DIR           man documentation [PREFIX/man]
++  --datarootdir=DIR      read-only arch.-independent data root [PREFIX/share]
++  --datadir=DIR          read-only architecture-independent data [DATAROOTDIR]
++  --infodir=DIR          info documentation [DATAROOTDIR/info]
++  --localedir=DIR        locale-dependent data [DATAROOTDIR/locale]
++  --mandir=DIR           man documentation [DATAROOTDIR/man]
++  --docdir=DIR           documentation root [DATAROOTDIR/doc/PACKAGE]
++  --htmldir=DIR          html documentation [DOCDIR]
++  --dvidir=DIR           dvi documentation [DOCDIR]
++  --pdfdir=DIR           pdf documentation [DOCDIR]
++  --psdir=DIR            ps documentation [DOCDIR]
+ _ACEOF
+   cat <<\_ACEOF
+@@ -878,126 +1366,95 @@ Some influential environment variables:
+   CFLAGS      C compiler flags
+   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+               nonstandard directory <lib dir>
+-  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
+-              headers in a nonstandard directory <include dir>
++  LIBS        libraries to pass to the linker, e.g. -l<library>
++  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
++              you have headers in a nonstandard directory <include dir>
+   CPP         C preprocessor
+ Use these variables to override the choices made by `configure' or to help
+ it to find libraries and programs with nonstandard names/locations.
+ _ACEOF
++ac_status=$?
+ fi
+ if test "$ac_init_help" = "recursive"; then
+   # If there are subdirs, report their specific --help.
+-  ac_popdir=`pwd`
+   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+-    test -d $ac_dir || continue
++    test -d "$ac_dir" || continue
+     ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
+-
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
+-
+-    cd $ac_dir
+-    # Check for guested configure; otherwise get Cygnus style configure.
+-    if test -f $ac_srcdir/configure.gnu; then
+-      echo
+-      $SHELL $ac_srcdir/configure.gnu  --help=recursive
+-    elif test -f $ac_srcdir/configure; then
+-      echo
+-      $SHELL $ac_srcdir/configure  --help=recursive
+-    elif test -f $ac_srcdir/configure.ac ||
+-         test -f $ac_srcdir/configure.in; then
+-      echo
+-      $ac_configure --help
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
++
++    cd "$ac_dir" || { ac_status=$?; continue; }
++    # Check for guested configure.
++    if test -f "$ac_srcdir/configure.gnu"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
++    elif test -f "$ac_srcdir/configure"; then
++      echo &&
++      $SHELL "$ac_srcdir/configure" --help=recursive
+     else
+       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+-    fi
+-    cd $ac_popdir
++    fi || ac_status=$?
++    cd "$ac_pwd" || { ac_status=$?; break; }
+   done
+ fi
+-test -n "$ac_init_help" && exit 0
++test -n "$ac_init_help" && exit $ac_status
+ if $ac_init_version; then
+   cat <<\_ACEOF
++configure
++generated by GNU Autoconf 2.61
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
++2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ This configure script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it.
+ _ACEOF
+-  exit 0
++  exit
+ fi
+-exec 5>config.log
+-cat >&5 <<_ACEOF
++cat >config.log <<_ACEOF
+ This file contains any messages produced by compilers while
+ running configure, to aid debugging if configure makes a mistake.
+ It was created by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   $ $0 $@
+ _ACEOF
++exec 5>>config.log
+ {
+ cat <<_ASUNAME
+ ## --------- ##
+@@ -1016,7 +1473,7 @@ uname -v = `(uname -v) 2>/dev/null || ec
+ /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+ /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+ /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+-hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
++/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+ /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+ /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+ /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+@@ -1030,6 +1487,7 @@ do
+   test -z "$as_dir" && as_dir=.
+   echo "PATH: $as_dir"
+ done
++IFS=$as_save_IFS
+ } >&5
+@@ -1051,7 +1509,6 @@ _ACEOF
+ ac_configure_args=
+ ac_configure_args0=
+ ac_configure_args1=
+-ac_sep=
+ ac_must_keep_next=false
+ for ac_pass in 1 2
+ do
+@@ -1062,7 +1519,7 @@ do
+     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+     | -silent | --silent | --silen | --sile | --sil)
+       continue ;;
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
++    *\'*)
+       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+     esac
+     case $ac_pass in
+@@ -1084,9 +1541,7 @@ do
+         -* ) ac_must_keep_next=true ;;
+       esac
+       fi
+-      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
+-      # Get rid of the leading space.
+-      ac_sep=" "
++      ac_configure_args="$ac_configure_args '$ac_arg'"
+       ;;
+     esac
+   done
+@@ -1097,8 +1552,8 @@ $as_unset ac_configure_args1 || test "${
+ # When interrupted or exit'd, cleanup temporary files, and complete
+ # config.log.  We remove comments because anyway the quotes in there
+ # would cause problems or look ugly.
+-# WARNING: Be sure not to use single quotes in there, as some shells,
+-# such as our DU 5.0 friend, will then `close' the trap.
++# WARNING: Use '\'' to represent an apostrophe within the trap.
++# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+ trap 'exit_status=$?
+   # Save into config.log some information that might help in debugging.
+   {
+@@ -1111,20 +1566,34 @@ trap 'exit_status=$?
+ _ASBOX
+     echo
+     # The following way of writing the cache mishandles newlines in values,
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
+   (set) 2>&1 |
+-    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       sed -n \
+-      "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
+-        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
+-      ;;
++      "s/'\''/'\''\\\\'\'''\''/g;
++        s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
++      ;; #(
+     *)
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-}
++    esac |
++    sort
++)
+     echo
+     cat <<\_ASBOX
+@@ -1135,22 +1604,28 @@ _ASBOX
+     echo
+     for ac_var in $ac_subst_vars
+     do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+     done | sort
+     echo
+     if test -n "$ac_subst_files"; then
+       cat <<\_ASBOX
+-## ------------- ##
+-## Output files. ##
+-## ------------- ##
++## ------------------- ##
++## File substitutions. ##
++## ------------------- ##
+ _ASBOX
+       echo
+       for ac_var in $ac_subst_files
+       do
+-      eval ac_val=$`echo $ac_var`
+-      echo "$ac_var='"'"'$ac_val'"'"'"
++      eval ac_val=\$$ac_var
++      case $ac_val in
++      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      esac
++      echo "$ac_var='\''$ac_val'\''"
+       done | sort
+       echo
+     fi
+@@ -1162,26 +1637,24 @@ _ASBOX
+ ## ----------- ##
+ _ASBOX
+       echo
+-      sed "/^$/d" confdefs.h | sort
++      cat confdefs.h
+       echo
+     fi
+     test "$ac_signal" != 0 &&
+       echo "$as_me: caught signal $ac_signal"
+     echo "$as_me: exit $exit_status"
+   } >&5
+-  rm -f core *.core &&
+-  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
++  rm -f core *.core core.conftest.* &&
++    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+     exit $exit_status
+-     ' 0
++' 0
+ for ac_signal in 1 2 13 15; do
+   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+ done
+ ac_signal=0
+ # confdefs.h avoids OS command line length limits that DEFS can exceed.
+-rm -rf conftest* confdefs.h
+-# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+-echo >confdefs.h
++rm -f -r conftest* confdefs.h
+ # Predefined preprocessor variables.
+@@ -1212,14 +1685,17 @@ _ACEOF
+ # Let the site file select an alternate cache file if it wants to.
+ # Prefer explicitly selected file to automatically selected ones.
+-if test -z "$CONFIG_SITE"; then
+-  if test "x$prefix" != xNONE; then
+-    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+-  else
+-    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+-  fi
++if test -n "$CONFIG_SITE"; then
++  set x "$CONFIG_SITE"
++elif test "x$prefix" != xNONE; then
++  set x "$prefix/share/config.site" "$prefix/etc/config.site"
++else
++  set x "$ac_default_prefix/share/config.site" \
++      "$ac_default_prefix/etc/config.site"
+ fi
+-for ac_site_file in $CONFIG_SITE; do
++shift
++for ac_site_file
++do
+   if test -r "$ac_site_file"; then
+     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
+ echo "$as_me: loading site script $ac_site_file" >&6;}
+@@ -1235,8 +1711,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -1248,12 +1724,11 @@ fi
+ # Check that the precious variables saved in the cache have kept the same
+ # value.
+ ac_cache_corrupted=false
+-for ac_var in `(set) 2>&1 |
+-             sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
++for ac_var in $ac_precious_vars; do
+   eval ac_old_set=\$ac_cv_env_${ac_var}_set
+   eval ac_new_set=\$ac_env_${ac_var}_set
+-  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
+-  eval ac_new_val="\$ac_env_${ac_var}_value"
++  eval ac_old_val=\$ac_cv_env_${ac_var}_value
++  eval ac_new_val=\$ac_env_${ac_var}_value
+   case $ac_old_set,$ac_new_set in
+     set,)
+       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+@@ -1278,8 +1753,7 @@ echo "$as_me:   current value: $ac_new_v
+   # Pass precious variables to config.status.
+   if test "$ac_new_set" = set; then
+     case $ac_new_val in
+-    *" "*|*"  "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+-      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
++    *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+     *) ac_arg=$ac_var=$ac_new_val ;;
+     esac
+     case " $ac_configure_args " in
+@@ -1296,12 +1770,6 @@ echo "$as_me: error: run \`make distclea
+    { (exit 1); exit 1; }; }
+ fi
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+@@ -1318,109 +1786,164 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ ac_aux_dir=
+-for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
+-  if test -f $ac_dir/install-sh; then
++for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
++  if test -f "$ac_dir/install-sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install-sh -c"
+     break
+-  elif test -f $ac_dir/install.sh; then
++  elif test -f "$ac_dir/install.sh"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/install.sh -c"
+     break
+-  elif test -f $ac_dir/shtool; then
++  elif test -f "$ac_dir/shtool"; then
+     ac_aux_dir=$ac_dir
+     ac_install_sh="$ac_aux_dir/shtool install -c"
+     break
+   fi
+ done
+ if test -z "$ac_aux_dir"; then
+-  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
+-echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
++  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&5
++echo "$as_me: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-ac_config_guess="$SHELL $ac_aux_dir/config.guess"
+-ac_config_sub="$SHELL $ac_aux_dir/config.sub"
+-ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
++
++# These three variables are undocumented and unsupported,
++# and are intended to be withdrawn in a future Autoconf release.
++# They can cause serious problems if a builder's source tree is in a directory
++# whose full name contains unusual characters.
++ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
++ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
++ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
++
+ # Make sure we can run config.sub.
+-$ac_config_sub sun4 >/dev/null 2>&1 ||
+-  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
+-echo "$as_me: error: cannot run $ac_config_sub" >&2;}
++$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
++  { { echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
++echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking build system type" >&5
+-echo $ECHO_N "checking build system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking build system type" >&5
++echo $ECHO_N "checking build system type... $ECHO_C" >&6; }
+ if test "${ac_cv_build+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_build_alias=$build_alias
+-test -z "$ac_cv_build_alias" &&
+-  ac_cv_build_alias=`$ac_config_guess`
+-test -z "$ac_cv_build_alias" &&
++  ac_build_alias=$build_alias
++test "x$ac_build_alias" = x &&
++  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
++test "x$ac_build_alias" = x &&
+   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
+ echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
+    { (exit 1); exit 1; }; }
+-ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
++ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
++  { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_build" >&5
+-echo "${ECHO_T}$ac_cv_build" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_build" >&5
++echo "${ECHO_T}$ac_cv_build" >&6; }
++case $ac_cv_build in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
++echo "$as_me: error: invalid value of canonical build" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ build=$ac_cv_build
+-build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_build
++shift
++build_cpu=$1
++build_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++build_os=$*
++IFS=$ac_save_IFS
++case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking host system type" >&5
+-echo $ECHO_N "checking host system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking host system type" >&5
++echo $ECHO_N "checking host system type... $ECHO_C" >&6; }
+ if test "${ac_cv_host+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_host_alias=$host_alias
+-test -z "$ac_cv_host_alias" &&
+-  ac_cv_host_alias=$ac_cv_build_alias
+-ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
++  if test "x$host_alias" = x; then
++  ac_cv_host=$ac_cv_build
++else
++  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_host" >&5
+-echo "${ECHO_T}$ac_cv_host" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_host" >&5
++echo "${ECHO_T}$ac_cv_host" >&6; }
++case $ac_cv_host in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
++echo "$as_me: error: invalid value of canonical host" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ host=$ac_cv_host
+-host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_host
++shift
++host_cpu=$1
++host_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++host_os=$*
++IFS=$ac_save_IFS
++case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+-echo "$as_me:$LINENO: checking target system type" >&5
+-echo $ECHO_N "checking target system type... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking target system type" >&5
++echo $ECHO_N "checking target system type... $ECHO_C" >&6; }
+ if test "${ac_cv_target+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_target_alias=$target_alias
+-test "x$ac_cv_target_alias" = "x" &&
+-  ac_cv_target_alias=$ac_cv_host_alias
+-ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
+-  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
+-echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
++  if test "x$target_alias" = x; then
++  ac_cv_target=$ac_cv_host
++else
++  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
++    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&5
++echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $target_alias failed" >&2;}
+    { (exit 1); exit 1; }; }
++fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_target" >&5
+-echo "${ECHO_T}$ac_cv_target" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_target" >&5
++echo "${ECHO_T}$ac_cv_target" >&6; }
++case $ac_cv_target in
++*-*-*) ;;
++*) { { echo "$as_me:$LINENO: error: invalid value of canonical target" >&5
++echo "$as_me: error: invalid value of canonical target" >&2;}
++   { (exit 1); exit 1; }; };;
++esac
+ target=$ac_cv_target
+-target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+-target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+-target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++ac_save_IFS=$IFS; IFS='-'
++set x $ac_cv_target
++shift
++target_cpu=$1
++target_vendor=$2
++shift; shift
++# Remember, the first character of IFS is used to create $*,
++# except with old shells:
++target_os=$*
++IFS=$ac_save_IFS
++case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
+ # The aliases save the names the user supplied, while $host etc.
+@@ -1437,8 +1960,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1451,32 +1974,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_CC"; then
+   ac_ct_CC=$CC
+   # Extract the first word of "gcc", so it can be a program name with args.
+ set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1489,36 +2014,51 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ else
+   CC="$ac_cv_prog_CC"
+ fi
+ if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1531,74 +2071,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}cc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
+-
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++  fi
+ fi
+ if test -z "$CC"; then
+   # Extract the first word of "cc", so it can be a program name with args.
+ set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1612,7 +2112,7 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+        continue
+@@ -1623,6 +2123,7 @@ do
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ if test $ac_prog_rejected = yes; then
+   # We found a bogon in the path, so make sure we never use it.
+@@ -1640,22 +2141,23 @@ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$CC"; then
+   if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1668,36 +2170,38 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+     test -n "$CC" && break
+   done
+ fi
+ if test -z "$CC"; then
+   ac_ct_CC=$CC
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1710,29 +2214,45 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$ac_ct_CC" && break
+ done
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ fi
+ fi
+@@ -1745,21 +2265,35 @@ See \`config.log' for more details." >&2
+    { (exit 1); exit 1; }; }
+ # Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
++echo "$as_me:$LINENO: checking for C compiler version" >&5
+ ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+@@ -1784,47 +2318,77 @@ ac_clean_files="$ac_clean_files a.out a.
+ # Try to create an executable without -o first, disregard a.out.
+ # It will help us diagnose broken compilers, and finding out an intuition
+ # of exeext.
+-echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
+-echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
++echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6; }
+ ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+-if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
+-  (eval $ac_link_default) 2>&5
++#
++# List of possible output files, starting from the most likely.
++# The algorithm is not robust to junk in `.', hence go to wildcards (a.*)
++# only as a last resort.  b.out is created by i960 compilers.
++ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'
++#
++# The IRIX 6 linker writes into existing files which may not be
++# executable, retaining their permissions.  Remove them first so a
++# subsequent execution test works.
++ac_rmfiles=
++for ac_file in $ac_files
++do
++  case $ac_file in
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
++    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
++  esac
++done
++rm -f $ac_rmfiles
++
++if { (ac_try="$ac_link_default"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link_default") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  # Find the output, starting from the most likely.  This scheme is
+-# not robust to junk in `.', hence go to wildcards (a.*) only as a last
+-# resort.
+-
+-# Be careful to initialize this variable, since it used to be cached.
+-# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
+-ac_cv_exeext=
+-# b.out is created by i960 compilers.
+-for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
++  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
++# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
++# in a Makefile.  We should not override ac_cv_exeext if it was cached,
++# so that the user can short-circuit this test for compilers unknown to
++# Autoconf.
++for ac_file in $ac_files ''
+ do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
+-      ;;
+-    conftest.$ac_ext )
+-      # This is the source file.
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )
+       ;;
+     [ab].out )
+       # We found the default executable, but exeext='' is most
+       # certainly right.
+       break;;
+     *.* )
+-      ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-      # FIXME: I believe we export ac_cv_exeext for Libtool,
+-      # but it would be cool to find out if it's true.  Does anybody
+-      # maintain Libtool? --akim.
+-      export ac_cv_exeext
++        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
++      then :; else
++         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
++      fi
++      # We set ac_cv_exeext here because the later test for it is not
++      # safe: cross compilers may not add the suffix if given an `-o'
++      # argument, so we may need to know it at that point already.
++      # Even if this section looks crufty: it has the advantage of
++      # actually working.
+       break;;
+     * )
+       break;;
+   esac
+ done
++test "$ac_cv_exeext" = no && ac_cv_exeext=
++
+ else
++  ac_file=''
++fi
++
++{ echo "$as_me:$LINENO: result: $ac_file" >&5
++echo "${ECHO_T}$ac_file" >&6; }
++if test -z "$ac_file"; then
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+@@ -1836,19 +2400,21 @@ See \`config.log' for more details." >&2
+ fi
+ ac_exeext=$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_file" >&5
+-echo "${ECHO_T}$ac_file" >&6
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether the C compiler works" >&5
+-echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether the C compiler works" >&5
++echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6; }
+ # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
+ # If not cross compiling, check that we can run a simple program.
+ if test "$cross_compiling" != yes; then
+   if { ac_try='./$ac_file'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -1867,22 +2433,27 @@ See \`config.log' for more details." >&2
+     fi
+   fi
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ rm -f a.out a.exe conftest$ac_cv_exeext b.out
+ ac_clean_files=$ac_clean_files_save
+-# Check the compiler produces executables we can run.  If not, either
++# Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
+-echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
+-echo "$as_me:$LINENO: result: $cross_compiling" >&5
+-echo "${ECHO_T}$cross_compiling" >&6
+-
+-echo "$as_me:$LINENO: checking for suffix of executables" >&5
+-echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
++echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }
++{ echo "$as_me:$LINENO: result: $cross_compiling" >&5
++echo "${ECHO_T}$cross_compiling" >&6; }
++
++{ echo "$as_me:$LINENO: checking for suffix of executables" >&5
++echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+@@ -1893,9 +2464,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_l
+ for ac_file in conftest.exe conftest conftest.*; do
+   test -f "$ac_file" || continue
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
+     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+-        export ac_cv_exeext
+         break;;
+     * ) break;;
+   esac
+@@ -1909,14 +2479,14 @@ See \`config.log' for more details." >&2
+ fi
+ rm -f conftest$ac_cv_exeext
+-echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
+-echo "${ECHO_T}$ac_cv_exeext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
++echo "${ECHO_T}$ac_cv_exeext" >&6; }
+ rm -f conftest.$ac_ext
+ EXEEXT=$ac_cv_exeext
+ ac_exeext=$EXEEXT
+-echo "$as_me:$LINENO: checking for suffix of object files" >&5
+-echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for suffix of object files" >&5
++echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }
+ if test "${ac_cv_objext+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1936,14 +2506,20 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.o conftest.obj
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>&5
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then
+-  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
++  for ac_file in conftest.o conftest.obj conftest.*; do
++  test -f "$ac_file" || continue;
+   case $ac_file in
+-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
++    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;
+     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+        break;;
+   esac
+@@ -1961,12 +2537,12 @@ fi
+ rm -f conftest.$ac_cv_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
+-echo "${ECHO_T}$ac_cv_objext" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
++echo "${ECHO_T}$ac_cv_objext" >&6; }
+ OBJEXT=$ac_cv_objext
+ ac_objext=$OBJEXT
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+ if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -1989,50 +2565,49 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+ GCC=`test $ac_compiler_gnu = yes && echo yes`
+ ac_test_CFLAGS=${CFLAGS+set}
+ ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -2048,38 +2623,118 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
++
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
+ if test "$ac_test_CFLAGS" = set; then
+   CFLAGS=$ac_save_CFLAGS
+ elif test $ac_cv_prog_cc_g = yes; then
+@@ -2095,12 +2750,12 @@ else
+     CFLAGS=
+   fi
+ fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_prog_cc_stdc=no
++  ac_cv_prog_cc_c89=no
+ ac_save_CC=$CC
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -2134,12 +2789,17 @@ static char *f (char * (*g) (char **, in
+ /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+    function prototypes and stuff, but not '\xHH' hex character constants.
+    These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
++   as 'x'.  The following induces an error, until -std is added to get
+    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+    array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
++   that's true only with -std.  */
+ int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
+ int test (int i, double x);
+ struct s1 {int (*f) (int a);};
+ struct s2 {int (*f) (double a);};
+@@ -2154,335 +2814,144 @@ return f (e, argv, 0) != argv[0]  ||  f 
+   return 0;
+ }
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+ do
+   CC="$ac_save_CC $ac_arg"
+   rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext
++
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+-rm -f conftest.$ac_ext conftest.$ac_objext
++rm -f conftest.$ac_ext
+ CC=$ac_save_CC
+ fi
+-
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
+   *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
+ esac
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
++
++ac_ext=c
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
++
++
++{ echo "$as_me:$LINENO: checking for library containing strerror" >&5
++echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6; }
++if test "${ac_cv_search_strerror+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_func_search_save_LIBS=$LIBS
+ cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
++
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
++#ifdef __cplusplus
++extern "C"
++#endif
++char strerror ();
+ int
+ main ()
+ {
+-exit (42);
++return strerror ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++for ac_lib in '' cposix; do
++  if test -z "$ac_lib"; then
++    ac_res="none required"
++  else
++    ac_res=-l$ac_lib
++    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
++  fi
++  rm -f conftest.$ac_objext conftest$ac_exeext
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
++  ac_cv_search_strerror=$ac_res
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
+-fi
+-
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
++      conftest$ac_exeext
++  if test "${ac_cv_search_strerror+set}" = set; then
++  break
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-ac_ext=c
+-ac_cpp='$CPP $CPPFLAGS'
+-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-
+-
+-echo "$as_me:$LINENO: checking for library containing strerror" >&5
+-echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6
++done
+ if test "${ac_cv_search_strerror+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  ac_func_search_save_LIBS=$LIBS
+-ac_cv_search_strerror=no
+-cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="none required"
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-if test "$ac_cv_search_strerror" = no; then
+-  for ac_lib in cposix; do
+-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+-    cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-
+-/* Override any gcc2 internal prototype to avoid an error.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+-char strerror ();
+-int
+-main ()
+-{
+-strerror ();
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_search_strerror="-l$ac_lib"
+-break
++  :
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext \
+-      conftest$ac_exeext conftest.$ac_ext
+-  done
++  ac_cv_search_strerror=no
+ fi
++rm conftest.$ac_ext
+ LIBS=$ac_func_search_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
+-echo "${ECHO_T}$ac_cv_search_strerror" >&6
+-if test "$ac_cv_search_strerror" != no; then
+-  test "$ac_cv_search_strerror" = "none required" || LIBS="$ac_cv_search_strerror $LIBS"
++{ echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5
++echo "${ECHO_T}$ac_cv_search_strerror" >&6; }
++ac_res=$ac_cv_search_strerror
++if test "$ac_res" != no; then
++  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+ fi
+@@ -2506,8 +2975,8 @@ am__api_version="1.9"
+ # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+ # OS/2's system install, which has a completely different semantic
+ # ./install, which can be erroneously created by make from ./install.sh.
+-echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+-echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+ if test -z "$INSTALL"; then
+ if test "${ac_cv_path_install+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -2529,7 +2998,7 @@ case $as_dir/ in
+     # by default.
+     for ac_prog in ginstall scoinst install; do
+       for ac_exec_ext in '' $ac_executable_extensions; do
+-      if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
++      if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+         if test $ac_prog = install &&
+           grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+           # AIX install.  It has an incompatible calling convention.
+@@ -2548,21 +3017,22 @@ case $as_dir/ in
+     ;;
+ esac
+ done
++IFS=$as_save_IFS
+ fi
+   if test "${ac_cv_path_install+set}" = set; then
+     INSTALL=$ac_cv_path_install
+   else
+-    # As a last resort, use the slow shell script.  We don't cache a
+-    # path for INSTALL within a source directory, because that will
++    # As a last resort, use the slow shell script.  Don't cache a
++    # value for INSTALL within a source directory, because that will
+     # break other packages using the cache if that directory is
+-    # removed, or if the path is relative.
++    # removed, or if the value is a relative name.
+     INSTALL=$ac_install_sh
+   fi
+ fi
+-echo "$as_me:$LINENO: result: $INSTALL" >&5
+-echo "${ECHO_T}$INSTALL" >&6
++{ echo "$as_me:$LINENO: result: $INSTALL" >&5
++echo "${ECHO_T}$INSTALL" >&6; }
+ # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+ # It thinks the first close brace ends the variable substitution.
+@@ -2572,8 +3042,8 @@ test -z "$INSTALL_SCRIPT" && INSTALL_SCR
+ test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+-echo "$as_me:$LINENO: checking whether build environment is sane" >&5
+-echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether build environment is sane" >&5
++echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6; }
+ # Just in case
+ sleep 1
+ echo timestamp > conftest.file
+@@ -2615,20 +3085,20 @@ echo "$as_me: error: newly created file 
+ Check your system clock" >&2;}
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++{ echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ test "$program_prefix" != NONE &&
+-  program_transform_name="s,^,$program_prefix,;$program_transform_name"
++  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+ # Use a double $ so make ignores it.
+ test "$program_suffix" != NONE &&
+-  program_transform_name="s,\$,$program_suffix,;$program_transform_name"
++  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+ # Double any \ or $.  echo might interpret backslashes.
+ # By default was `s,x,x', remove it if useless.
+ cat <<\_ACEOF >conftest.sed
+ s/[\\$]/&&/g;s/;s,x,x,$//
+ _ACEOF
+ program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
+-rm conftest.sed
++rm -f conftest.sed
+ # expand $ac_aux_dir to an absolute path
+ am_aux_dir=`cd $ac_aux_dir && pwd`
+@@ -2680,8 +3150,8 @@ for ac_prog in gawk mawk nawk awk
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_AWK+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2694,54 +3164,57 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_AWK="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ AWK=$ac_cv_prog_AWK
+ if test -n "$AWK"; then
+-  echo "$as_me:$LINENO: result: $AWK" >&5
+-echo "${ECHO_T}$AWK" >&6
++  { echo "$as_me:$LINENO: result: $AWK" >&5
++echo "${ECHO_T}$AWK" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$AWK" && break
+ done
+-echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+-echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
+-set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
+-if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
++echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6; }
++set x ${MAKE-make}; ac_make=`echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
++if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.make <<\_ACEOF
++SHELL = /bin/sh
+ all:
+-      @echo 'ac_maketemp="$(MAKE)"'
++      @echo '@@@%%%=$(MAKE)=@@@%%%'
+ _ACEOF
+ # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
+-eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
+-if test -n "$ac_maketemp"; then
+-  eval ac_cv_prog_make_${ac_make}_set=yes
+-else
+-  eval ac_cv_prog_make_${ac_make}_set=no
+-fi
++case `${MAKE-make} -f conftest.make 2>/dev/null` in
++  *@@@%%%=?*=@@@%%%*)
++    eval ac_cv_prog_make_${ac_make}_set=yes;;
++  *)
++    eval ac_cv_prog_make_${ac_make}_set=no;;
++esac
+ rm -f conftest.make
+ fi
+-if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+   SET_MAKE=
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+   SET_MAKE="MAKE=${MAKE-make}"
+ fi
+@@ -2756,7 +3229,7 @@ rmdir .tst 2>/dev/null
+ DEPDIR="${am__leading_dot}deps"
+-          ac_config_commands="$ac_config_commands depfiles"
++ac_config_commands="$ac_config_commands depfiles"
+ am_make=${MAKE-make}
+@@ -2766,8 +3239,8 @@ am__doit:
+ .PHONY: am__doit
+ END
+ # If we don't find an include directive, just comment out the code.
+-echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
+-echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
++echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6; }
+ am__include="#"
+ am__quote=
+ _am_result=none
+@@ -2794,15 +3267,15 @@ if test "$am__include" = "#"; then
+ fi
+-echo "$as_me:$LINENO: result: $_am_result" >&5
+-echo "${ECHO_T}$_am_result" >&6
++{ echo "$as_me:$LINENO: result: $_am_result" >&5
++echo "${ECHO_T}$_am_result" >&6; }
+ rm -f confinc confmf
+-# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
++# Check whether --enable-dependency-tracking was given.
+ if test "${enable_dependency_tracking+set}" = set; then
+-  enableval="$enable_dependency_tracking"
++  enableval=$enable_dependency_tracking;
++fi
+-fi;
+ if test "x$enable_dependency_tracking" != xno; then
+   am_depcomp="$ac_aux_dir/depcomp"
+   AMDEPBACKSLASH='\'
+@@ -2877,8 +3350,8 @@ if test "$cross_compiling" != no; then
+   if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2891,32 +3364,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -2929,27 +3404,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -2970,8 +3459,8 @@ am__tar='${AMTAR} chof - "$$tardir"'; am
+ depcc="$CC"   am_compiler_list=
+-echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
+-echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
++echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; }
+ if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3060,8 +3549,8 @@ else
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
+-echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
++echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; }
+ CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+@@ -3082,8 +3571,8 @@ fi
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ar; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_AR+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3096,32 +3585,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_AR="${ac_tool_prefix}ar"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ AR=$ac_cv_prog_AR
+ if test -n "$AR"; then
+-  echo "$as_me:$LINENO: result: $AR" >&5
+-echo "${ECHO_T}$AR" >&6
++  { echo "$as_me:$LINENO: result: $AR" >&5
++echo "${ECHO_T}$AR" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_AR"; then
+   ac_ct_AR=$AR
+   # Extract the first word of "ar", so it can be a program name with args.
+ set dummy ar; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3134,26 +3625,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_AR="ar"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_AR=$ac_cv_prog_ac_ct_AR
+ if test -n "$ac_ct_AR"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
+-echo "${ECHO_T}$ac_ct_AR" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
++echo "${ECHO_T}$ac_ct_AR" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  AR=$ac_ct_AR
++  if test "x$ac_ct_AR" = x; then
++    AR=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    AR=$ac_ct_AR
++  fi
+ else
+   AR="$ac_cv_prog_AR"
+ fi
+@@ -3161,8 +3667,8 @@ fi
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3175,32 +3681,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3213,36 +3721,49 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+-# Check whether --enable-shared or --disable-shared was given.
++# Check whether --enable-shared was given.
+ if test "${enable_shared+set}" = set; then
+-  enableval="$enable_shared"
+-  p=${PACKAGE-default}
++  enableval=$enable_shared; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_shared=yes ;;
+ no) enable_shared=no ;;
+@@ -3260,12 +3781,12 @@ no) enable_shared=no ;;
+ esac
+ else
+   enable_shared=no
+-fi;
++fi
++
+-# Check whether --enable-static or --disable-static was given.
++# Check whether --enable-static was given.
+ if test "${enable_static+set}" = set; then
+-  enableval="$enable_static"
+-  p=${PACKAGE-default}
++  enableval=$enable_static; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_static=yes ;;
+ no) enable_static=no ;;
+@@ -3283,11 +3804,11 @@ no) enable_static=no ;;
+ esac
+ else
+   enable_static=yes
+-fi;
+-# Check whether --enable-fast-install or --disable-fast-install was given.
++fi
++
++# Check whether --enable-fast-install was given.
+ if test "${enable_fast_install+set}" = set; then
+-  enableval="$enable_fast_install"
+-  p=${PACKAGE-default}
++  enableval=$enable_fast_install; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_fast_install=yes ;;
+ no) enable_fast_install=no ;;
+@@ -3305,20 +3826,21 @@ no) enable_fast_install=no ;;
+ esac
+ else
+   enable_fast_install=yes
+-fi;
++fi
++
+-# Check whether --with-gnu-ld or --without-gnu-ld was given.
++# Check whether --with-gnu-ld was given.
+ if test "${with_gnu_ld+set}" = set; then
+-  withval="$with_gnu_ld"
+-  test "$withval" = no || with_gnu_ld=yes
++  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+ else
+   with_gnu_ld=no
+-fi;
++fi
++
+ ac_prog=ld
+ if test "$GCC" = yes; then
+   # Check if gcc -print-prog-name=ld gives a path.
+-  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
+-echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for ld used by GCC" >&5
++echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6; }
+   case $host in
+   *-*-mingw*)
+     # gcc leaves a trailing carriage return which upsets mingw
+@@ -3347,11 +3869,11 @@ echo $ECHO_N "checking for ld used by GC
+     ;;
+   esac
+ elif test "$with_gnu_ld" = yes; then
+-  echo "$as_me:$LINENO: checking for GNU ld" >&5
+-echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for GNU ld" >&5
++echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6; }
+ else
+-  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
+-echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for non-GNU ld" >&5
++echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6; }
+ fi
+ if test "${lt_cv_path_LD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -3380,17 +3902,17 @@ fi
+ LD="$lt_cv_path_LD"
+ if test -n "$LD"; then
+-  echo "$as_me:$LINENO: result: $LD" >&5
+-echo "${ECHO_T}$LD" >&6
++  { echo "$as_me:$LINENO: result: $LD" >&5
++echo "${ECHO_T}$LD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
+ echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
+    { (exit 1); exit 1; }; }
+-echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
+-echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
++echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6; }
+ if test "${lt_cv_prog_gnu_ld+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3401,25 +3923,25 @@ else
+   lt_cv_prog_gnu_ld=no
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
+-echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
++echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6; }
+ with_gnu_ld=$lt_cv_prog_gnu_ld
+-echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
+-echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
++echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6; }
+ if test "${lt_cv_ld_reload_flag+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   lt_cv_ld_reload_flag='-r'
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
+-echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
++echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6; }
+ reload_flag=$lt_cv_ld_reload_flag
+ test -n "$reload_flag" && reload_flag=" $reload_flag"
+-echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
+-echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
++echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6; }
+ if test "${lt_cv_path_NM+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3454,22 +3976,22 @@ fi
+ fi
+ NM="$lt_cv_path_NM"
+-echo "$as_me:$LINENO: result: $NM" >&5
+-echo "${ECHO_T}$NM" >&6
++{ echo "$as_me:$LINENO: result: $NM" >&5
++echo "${ECHO_T}$NM" >&6; }
+-echo "$as_me:$LINENO: checking whether ln -s works" >&5
+-echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether ln -s works" >&5
++echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6; }
+ LN_S=$as_ln_s
+ if test "$LN_S" = "ln -s"; then
+-  echo "$as_me:$LINENO: result: yes" >&5
+-echo "${ECHO_T}yes" >&6
++  { echo "$as_me:$LINENO: result: yes" >&5
++echo "${ECHO_T}yes" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
+-echo "${ECHO_T}no, using $LN_S" >&6
++  { echo "$as_me:$LINENO: result: no, using $LN_S" >&5
++echo "${ECHO_T}no, using $LN_S" >&6; }
+ fi
+-echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
+-echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
++echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6; }
+ if test "${lt_cv_deplibs_check_method+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3631,8 +4153,8 @@ sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+ esac
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
+-echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
++echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6; }
+ file_magic_cmd=$lt_cv_file_magic_cmd
+ deplibs_check_method=$lt_cv_deplibs_check_method
+@@ -3642,8 +4164,8 @@ deplibs_check_method=$lt_cv_deplibs_chec
+ # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
+ # find the maximum length of command line arguments
+-echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
+-echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
++echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6; }
+ if test "${lt_cv_sys_max_cmd_len+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3694,11 +4216,11 @@ else
+ fi
+ if test -n "$lt_cv_sys_max_cmd_len" ; then
+-  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
+-echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
++  { echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
++echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: none" >&5
+-echo "${ECHO_T}none" >&6
++  { echo "$as_me:$LINENO: result: none" >&5
++echo "${ECHO_T}none" >&6; }
+ fi
+@@ -3706,8 +4228,8 @@ fi
+ case $deplibs_check_method in
+ file_magic*)
+   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+-    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
+-echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
++echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3761,17 +4283,17 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+ if test -z "$lt_cv_path_MAGIC_CMD"; then
+   if test -n "$ac_tool_prefix"; then
+-    echo "$as_me:$LINENO: checking for file" >&5
+-echo $ECHO_N "checking for file... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for file" >&5
++echo $ECHO_N "checking for file... $ECHO_C" >&6; }
+ if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3825,11 +4347,11 @@ fi
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if test -n "$MAGIC_CMD"; then
+-  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+-echo "${ECHO_T}$MAGIC_CMD" >&6
++  { echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
++echo "${ECHO_T}$MAGIC_CMD" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+   else
+@@ -3844,8 +4366,8 @@ esac
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3858,32 +4380,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3896,27 +4420,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -3924,8 +4462,8 @@ fi
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3938,32 +4476,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  echo "$as_me:$LINENO: result: $STRIP" >&5
+-echo "${ECHO_T}$STRIP" >&6
++  { echo "$as_me:$LINENO: result: $STRIP" >&5
++echo "${ECHO_T}$STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_STRIP"; then
+   ac_ct_STRIP=$STRIP
+   # Extract the first word of "strip", so it can be a program name with args.
+ set dummy strip; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -3976,27 +4516,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_STRIP="strip"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+ fi
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+-echo "${ECHO_T}$ac_ct_STRIP" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
++echo "${ECHO_T}$ac_ct_STRIP" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  STRIP=$ac_ct_STRIP
++  if test "x$ac_ct_STRIP" = x; then
++    STRIP=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    STRIP=$ac_ct_STRIP
++  fi
+ else
+   STRIP="$ac_cv_prog_STRIP"
+ fi
+@@ -4011,22 +4565,22 @@ test "$GCC" = yes && libtool_flags="$lib
+ test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
+-# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
++# Check whether --enable-libtool-lock was given.
+ if test "${enable_libtool_lock+set}" = set; then
+-  enableval="$enable_libtool_lock"
++  enableval=$enable_libtool_lock;
++fi
+-fi;
+ test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
+ test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
+-# Check whether --with-pic or --without-pic was given.
++# Check whether --with-pic was given.
+ if test "${with_pic+set}" = set; then
+-  withval="$with_pic"
+-  pic_mode="$withval"
++  withval=$with_pic; pic_mode="$withval"
+ else
+   pic_mode=default
+-fi;
++fi
++
+ test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
+ test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
+@@ -4035,7 +4589,7 @@ test x"$pic_mode" = xno && libtool_flags
+ case $host in
+ *-*-irix6*)
+   # Find out which ABI we are using.
+-  echo '#line 4038 "configure"' > conftest.$ac_ext
++  echo '#line 4592 "configure"' > conftest.$ac_ext
+   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+   (eval $ac_compile) 2>&5
+   ac_status=$?
+@@ -4140,13 +4694,12 @@ x86_64-*linux*|ppc*-*linux*|powerpc*-*li
+   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+   SAVE_CFLAGS="$CFLAGS"
+   CFLAGS="$CFLAGS -belf"
+-  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
+-echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
++echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6; }
+ if test "${lt_cv_cc_needs_belf+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -4169,35 +4722,32 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   lt_cv_cc_needs_belf=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-lt_cv_cc_needs_belf=no
++      lt_cv_cc_needs_belf=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+      ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+@@ -4206,8 +4756,8 @@ ac_link='$CC -o conftest$ac_exeext $CFLA
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
+-echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
++{ echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
++echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6; }
+   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+     CFLAGS="$SAVE_CFLAGS"
+@@ -4237,39 +4787,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -4295,8 +4864,8 @@ if test -r "$cache_file"; then
+     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+ echo "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+-      [\\/]* | ?:[\\/]* ) . $cache_file;;
+-      *)                      . ./$cache_file;;
++      [\\/]* | ?:[\\/]* ) . "$cache_file";;
++      *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+@@ -4322,10 +4891,9 @@ exec 5>>./config.log
+-# Check whether --enable-targets or --disable-targets was given.
++# Check whether --enable-targets was given.
+ if test "${enable_targets+set}" = set; then
+-  enableval="$enable_targets"
+-  case "${enableval}" in
++  enableval=$enable_targets; case "${enableval}" in
+   yes | "") { { echo "$as_me:$LINENO: error: enable-targets option must specify target names or 'all'" >&5
+ echo "$as_me: error: enable-targets option must specify target names or 'all'" >&2;}
+    { (exit 1); exit 1; }; }
+@@ -4333,31 +4901,32 @@ echo "$as_me: error: enable-targets opti
+   no)       enable_targets= ;;
+   *)        enable_targets=$enableval ;;
+ esac
+-fi; # Check whether --enable-commonbfdlib or --disable-commonbfdlib was given.
++fi
++# Check whether --enable-commonbfdlib was given.
+ if test "${enable_commonbfdlib+set}" = set; then
+-  enableval="$enable_commonbfdlib"
+-  case "${enableval}" in
++  enableval=$enable_commonbfdlib; case "${enableval}" in
+   yes) commonbfdlib=true ;;
+   no)  commonbfdlib=false ;;
+   *)   { { echo "$as_me:$LINENO: error: bad value ${enableval} for opcodes commonbfdlib option" >&5
+ echo "$as_me: error: bad value ${enableval} for opcodes commonbfdlib option" >&2;}
+    { (exit 1); exit 1; }; } ;;
+ esac
+-fi;
++fi
++
+ GCC_WARN_CFLAGS="-W -Wall -Wstrict-prototypes -Wmissing-prototypes"
+-# Check whether --enable-werror or --disable-werror was given.
++# Check whether --enable-werror was given.
+ if test "${enable_werror+set}" = set; then
+-  enableval="$enable_werror"
+-  case "${enableval}" in
++  enableval=$enable_werror; case "${enableval}" in
+      yes | y) ERROR_ON_WARNING="yes" ;;
+      no | n)  ERROR_ON_WARNING="no" ;;
+      *) { { echo "$as_me:$LINENO: error: bad value ${enableval} for --enable-werror" >&5
+ echo "$as_me: error: bad value ${enableval} for --enable-werror" >&2;}
+    { (exit 1); exit 1; }; } ;;
+    esac
+-fi;
++fi
++
+ # Enable -Werror by default when using gcc
+ if test "${GCC}" = yes -a -z "${ERROR_ON_WARNING}" ; then
+@@ -4374,10 +4943,9 @@ if test "${GCC}" = yes ; then
+   WARN_CFLAGS="${GCC_WARN_CFLAGS}"
+ fi
+-# Check whether --enable-build-warnings or --disable-build-warnings was given.
++# Check whether --enable-build-warnings was given.
+ if test "${enable_build_warnings+set}" = set; then
+-  enableval="$enable_build_warnings"
+-  case "${enableval}" in
++  enableval=$enable_build_warnings; case "${enableval}" in
+   yes)        WARN_CFLAGS="${GCC_WARN_CFLAGS}";;
+   no) if test "${GCC}" = yes ; then
+         WARN_CFLAGS="-w"
+@@ -4388,7 +4956,8 @@ if test "${enable_build_warnings+set}" =
+         WARN_CFLAGS="${t} ${GCC_WARN_CFLAGS}";;
+   *)    WARN_CFLAGS=`echo "${enableval}" | sed -e "s/,/ /g"`;;
+ esac
+-fi;
++fi
++
+ if test x"$silent" != x"yes" && test x"$WARN_CFLAGS" != x""; then
+   echo "Setting warning flags = $WARN_CFLAGS" 6>&1
+@@ -4398,7 +4967,7 @@ fi
+-          ac_config_headers="$ac_config_headers config.h:config.in"
++ac_config_headers="$ac_config_headers config.h:config.in"
+ if test -z "$target" ; then
+@@ -4407,17 +4976,17 @@ echo "$as_me: error: Unrecognized target
+    { (exit 1); exit 1; }; }
+ fi
+-echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
+-echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
+-    # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
++{ echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
++echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6; }
++    # Check whether --enable-maintainer-mode was given.
+ if test "${enable_maintainer_mode+set}" = set; then
+-  enableval="$enable_maintainer_mode"
+-  USE_MAINTAINER_MODE=$enableval
++  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
+ else
+   USE_MAINTAINER_MODE=no
+-fi;
+-  echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
+-echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
++fi
++
++  { echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
++echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6; }
+ if test $USE_MAINTAINER_MODE = yes; then
+@@ -4446,21 +5015,21 @@ esac
+   *) target_noncanonical=${target_alias} ;;
+ esac
+-echo "$as_me:$LINENO: checking whether to install libbfd" >&5
+-echo $ECHO_N "checking whether to install libbfd... $ECHO_C" >&6
+-  # Check whether --enable-install-libbfd or --disable-install-libbfd was given.
++{ echo "$as_me:$LINENO: checking whether to install libbfd" >&5
++echo $ECHO_N "checking whether to install libbfd... $ECHO_C" >&6; }
++  # Check whether --enable-install-libbfd was given.
+ if test "${enable_install_libbfd+set}" = set; then
+-  enableval="$enable_install_libbfd"
+-  install_libbfd_p=$enableval
++  enableval=$enable_install_libbfd; install_libbfd_p=$enableval
+ else
+   if test "${host}" = "${target}" || test "$enable_shared" = "yes"; then
+         install_libbfd_p=yes
+       else
+         install_libbfd_p=no
+       fi
+-fi;
+-  echo "$as_me:$LINENO: result: $install_libbfd_p" >&5
+-echo "${ECHO_T}$install_libbfd_p" >&6
++fi
++
++  { echo "$as_me:$LINENO: result: $install_libbfd_p" >&5
++echo "${ECHO_T}$install_libbfd_p" >&6; }
+ if test $install_libbfd_p = yes; then
+@@ -4499,8 +5068,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4513,32 +5082,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_CC"; then
+   ac_ct_CC=$CC
+   # Extract the first word of "gcc", so it can be a program name with args.
+ set dummy gcc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4551,36 +5122,51 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="gcc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ else
+   CC="$ac_cv_prog_CC"
+ fi
+ if test -z "$CC"; then
+-  if test -n "$ac_tool_prefix"; then
+-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
++          if test -n "$ac_tool_prefix"; then
++    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4593,74 +5179,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="${ac_tool_prefix}cc"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
+-else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
+-fi
+-
+-fi
+-if test -z "$ac_cv_prog_CC"; then
+-  ac_ct_CC=$CC
+-  # Extract the first word of "cc", so it can be a program name with args.
+-set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  if test -n "$ac_ct_CC"; then
+-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+-else
+-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_prog_ac_ct_CC="cc"
+-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+-    break 2
+-  fi
+-done
+-done
+-
+-fi
+-fi
+-ac_ct_CC=$ac_cv_prog_ac_ct_CC
+-if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  CC=$ac_ct_CC
+-else
+-  CC="$ac_cv_prog_CC"
+-fi
++  fi
+ fi
+ if test -z "$CC"; then
+   # Extract the first word of "cc", so it can be a program name with args.
+ set dummy cc; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4674,7 +5220,7 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+        continue
+@@ -4685,6 +5231,7 @@ do
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ if test $ac_prog_rejected = yes; then
+   # We found a bogon in the path, so make sure we never use it.
+@@ -4702,22 +5249,23 @@ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$CC"; then
+   if test -n "$ac_tool_prefix"; then
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4730,36 +5278,38 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  echo "$as_me:$LINENO: result: $CC" >&5
+-echo "${ECHO_T}$CC" >&6
++  { echo "$as_me:$LINENO: result: $CC" >&5
++echo "${ECHO_T}$CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+     test -n "$CC" && break
+   done
+ fi
+ if test -z "$CC"; then
+   ac_ct_CC=$CC
+-  for ac_prog in cl
++  for ac_prog in cl.exe
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4772,29 +5322,45 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+-echo "${ECHO_T}$ac_ct_CC" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
++echo "${ECHO_T}$ac_ct_CC" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+   test -n "$ac_ct_CC" && break
+ done
+-  CC=$ac_ct_CC
++  if test "x$ac_ct_CC" = x; then
++    CC=""
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    CC=$ac_ct_CC
++  fi
+ fi
+ fi
+@@ -4807,27 +5373,41 @@ See \`config.log' for more details." >&2
+    { (exit 1); exit 1; }; }
+ # Provide some information about the compiler.
+-echo "$as_me:$LINENO:" \
+-     "checking for C compiler version" >&5
++echo "$as_me:$LINENO: checking for C compiler version" >&5
+ ac_compiler=`set X $ac_compile; echo $2`
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+-  (eval $ac_compiler --version </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler --version >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler --version >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+-  (eval $ac_compiler -v </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -v >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -v >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+-  (eval $ac_compiler -V </dev/null >&5) 2>&5
++{ (ac_try="$ac_compiler -V >&5"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compiler -V >&5") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+ if test "${ac_cv_c_compiler_gnu+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -4850,50 +5430,49 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_compiler_gnu=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_compiler_gnu=no
++      ac_compiler_gnu=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+ GCC=`test $ac_compiler_gnu = yes && echo yes`
+ ac_test_CFLAGS=${CFLAGS+set}
+ ac_save_CFLAGS=$CFLAGS
+-CFLAGS="-g"
+-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_cc_g+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  cat >conftest.$ac_ext <<_ACEOF
++  ac_save_c_werror_flag=$ac_c_werror_flag
++   ac_c_werror_flag=yes
++   ac_cv_prog_cc_g=no
++   CFLAGS="-g"
++   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -4909,59 +5488,139 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_prog_cc_g=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_prog_cc_g=no
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
+-if test "$ac_test_CFLAGS" = set; then
+-  CFLAGS=$ac_save_CFLAGS
+-elif test $ac_cv_prog_cc_g = yes; then
+-  if test "$GCC" = yes; then
+-    CFLAGS="-g -O2"
+-  else
+-    CFLAGS="-g"
+-  fi
+-else
+-  if test "$GCC" = yes; then
++      CFLAGS=""
++      cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  :
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_c_werror_flag=$ac_save_c_werror_flag
++       CFLAGS="-g"
++       cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_g=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
++if test "$ac_test_CFLAGS" = set; then
++  CFLAGS=$ac_save_CFLAGS
++elif test $ac_cv_prog_cc_g = yes; then
++  if test "$GCC" = yes; then
++    CFLAGS="-g -O2"
++  else
++    CFLAGS="-g"
++  fi
++else
++  if test "$GCC" = yes; then
+     CFLAGS="-O2"
+   else
+     CFLAGS=
+   fi
+ fi
+-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+-if test "${ac_cv_prog_cc_stdc+set}" = set; then
++{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
++echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
++if test "${ac_cv_prog_cc_c89+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  ac_cv_prog_cc_stdc=no
++  ac_cv_prog_cc_c89=no
+ ac_save_CC=$CC
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -4995,12 +5654,17 @@ static char *f (char * (*g) (char **, in
+ /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+    function prototypes and stuff, but not '\xHH' hex character constants.
+    These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std1 is added to get
++   as 'x'.  The following induces an error, until -std is added to get
+    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+    array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std1.  */
++   that's true only with -std.  */
+ int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) 'x'
++int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++
+ int test (int i, double x);
+ struct s1 {int (*f) (int a);};
+ struct s2 {int (*f) (double a);};
+@@ -5015,205 +5679,57 @@ return f (e, argv, 0) != argv[0]  ||  f 
+   return 0;
+ }
+ _ACEOF
+-# Don't try gcc -ansi; that turns off useful extensions and
+-# breaks some systems' header files.
+-# AIX                 -qlanglvl=ansi
+-# Ultrix and OSF/1    -std1
+-# HP-UX 10.20 and later       -Ae
+-# HP-UX older versions        -Aa -D_HPUX_SOURCE
+-# SVR4                        -Xc -D__EXTENSIONS__
+-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
++      -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+ do
+   CC="$ac_save_CC $ac_arg"
+   rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_prog_cc_stdc=$ac_arg
+-break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_prog_cc_c89=$ac_arg
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext
++
++rm -f core conftest.err conftest.$ac_objext
++  test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+-rm -f conftest.$ac_ext conftest.$ac_objext
++rm -f conftest.$ac_ext
+ CC=$ac_save_CC
+ fi
+-
+-case "x$ac_cv_prog_cc_stdc" in
+-  x|xno)
+-    echo "$as_me:$LINENO: result: none needed" >&5
+-echo "${ECHO_T}none needed" >&6 ;;
++# AC_CACHE_VAL
++case "x$ac_cv_prog_cc_c89" in
++  x)
++    { echo "$as_me:$LINENO: result: none needed" >&5
++echo "${ECHO_T}none needed" >&6; } ;;
++  xno)
++    { echo "$as_me:$LINENO: result: unsupported" >&5
++echo "${ECHO_T}unsupported" >&6; } ;;
+   *)
+-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+-    CC="$CC $ac_cv_prog_cc_stdc" ;;
++    CC="$CC $ac_cv_prog_cc_c89"
++    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
++echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
+ esac
+-# Some people use a C++ compiler to compile C.  Since we use `exit',
+-# in C++ we need to declare it.  In case someone uses the same compiler
+-# for both compiling C and C++ we need to have the C++ compiler decide
+-# the declaration of exit, since it's the most demanding environment.
+-cat >conftest.$ac_ext <<_ACEOF
+-#ifndef __cplusplus
+-  choke me
+-#endif
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  for ac_declaration in \
+-   '' \
+-   'extern "C" void std::exit (int) throw (); using std::exit;' \
+-   'extern "C" void std::exit (int); using std::exit;' \
+-   'extern "C" void exit (int) throw ();' \
+-   'extern "C" void exit (int);' \
+-   'void exit (int);'
+-do
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-#include <stdlib.h>
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  :
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-continue
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-$ac_declaration
+-int
+-main ()
+-{
+-exit (42);
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  break
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-done
+-rm -f conftest*
+-if test -n "$ac_declaration"; then
+-  echo '#ifdef __cplusplus' >>confdefs.h
+-  echo $ac_declaration      >>confdefs.h
+-  echo '#endif'             >>confdefs.h
+-fi
+-
+-else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
+-fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_ext=c
+ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -5225,8 +5741,8 @@ ALL_LINGUAS="fr sv tr es da de id pt_BR 
+ if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5239,32 +5755,34 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+ fi
+ fi
+ RANLIB=$ac_cv_prog_RANLIB
+ if test -n "$RANLIB"; then
+-  echo "$as_me:$LINENO: result: $RANLIB" >&5
+-echo "${ECHO_T}$RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $RANLIB" >&5
++echo "${ECHO_T}$RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+ fi
+ if test -z "$ac_cv_prog_RANLIB"; then
+   ac_ct_RANLIB=$RANLIB
+   # Extract the first word of "ranlib", so it can be a program name with args.
+ set dummy ranlib; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5277,27 +5795,41 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_prog_ac_ct_RANLIB="ranlib"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+ fi
+ fi
+ ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+ if test -n "$ac_ct_RANLIB"; then
+-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+-echo "${ECHO_T}$ac_ct_RANLIB" >&6
++  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
++echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+-  RANLIB=$ac_ct_RANLIB
++  if test "x$ac_ct_RANLIB" = x; then
++    RANLIB=":"
++  else
++    case $cross_compiling:$ac_tool_warned in
++yes:)
++{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&5
++echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
++whose name does not start with the host triplet.  If you think this
++configuration is useful to you, please write to autoconf@gnu.org." >&2;}
++ac_tool_warned=yes ;;
++esac
++    RANLIB=$ac_ct_RANLIB
++  fi
+ else
+   RANLIB="$ac_cv_prog_RANLIB"
+ fi
+@@ -5307,8 +5839,8 @@ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
+-echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
++echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }
+ # On Suns, sometimes $CPP names a directory.
+ if test -n "$CPP" && test -d "$CPP"; then
+   CPP=
+@@ -5342,24 +5874,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #endif
+                    Syntax error
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   :
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -5368,9 +5898,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   # Broken: fails on valid input.
+ continue
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
++  # OK, works on sane cases.  Now check whether nonexistent headers
+   # can be detected and how.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -5380,24 +5911,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   # Broken: success on invalid input.
+ continue
+ else
+@@ -5408,6 +5937,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ac_preproc_ok=:
+ break
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+ done
+@@ -5425,8 +5955,8 @@ fi
+ else
+   ac_cv_prog_CPP=$CPP
+ fi
+-echo "$as_me:$LINENO: result: $CPP" >&5
+-echo "${ECHO_T}$CPP" >&6
++{ echo "$as_me:$LINENO: result: $CPP" >&5
++echo "${ECHO_T}$CPP" >&6; }
+ ac_preproc_ok=false
+ for ac_c_preproc_warn_flag in '' yes
+ do
+@@ -5449,24 +5979,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #endif
+                    Syntax error
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   :
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -5475,9 +6003,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   # Broken: fails on valid input.
+ continue
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-  # OK, works on sane cases.  Now check whether non-existent headers
++  # OK, works on sane cases.  Now check whether nonexistent headers
+   # can be detected and how.
+   cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+@@ -5487,24 +6016,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   # Broken: success on invalid input.
+ continue
+ else
+@@ -5515,6 +6042,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ac_preproc_ok=:
+ break
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+ done
+@@ -5537,79 +6065,222 @@ ac_link='$CC -o conftest$ac_exeext $CFLA
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-echo "$as_me:$LINENO: checking for egrep" >&5
+-echo $ECHO_N "checking for egrep... $ECHO_C" >&6
+-if test "${ac_cv_prog_egrep+set}" = set; then
++{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
++echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }
++if test "${ac_cv_path_GREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  # Extract the first word of "grep ggrep" to use in msg output
++if test -z "$GREP"; then
++set dummy grep ggrep; ac_prog_name=$2
++if test "${ac_cv_path_GREP+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+-  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
+-    then ac_cv_prog_egrep='grep -E'
+-    else ac_cv_prog_egrep='egrep'
++  ac_path_GREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in grep ggrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
++    # Check for GNU ac_path_GREP and select it if it is found.
++  # Check for GNU $ac_path_GREP
++case `"$ac_path_GREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'GREP' >> "conftest.nl"
++    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_GREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_GREP="$ac_path_GREP"
++      ac_path_GREP_max=$ac_count
+     fi
+-fi
+-echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
+-echo "${ECHO_T}$ac_cv_prog_egrep" >&6
+- EGREP=$ac_cv_prog_egrep
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
+-echo "$as_me:$LINENO: checking for ANSI C header files" >&5
+-echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
+-if test "${ac_cv_header_stdc+set}" = set; then
+-  echo $ECHO_N "(cached) $ECHO_C" >&6
+-else
+-  cat >conftest.$ac_ext <<_ACEOF
+-/* confdefs.h.  */
+-_ACEOF
+-cat confdefs.h >>conftest.$ac_ext
+-cat >>conftest.$ac_ext <<_ACEOF
+-/* end confdefs.h.  */
+-#include <stdlib.h>
+-#include <stdarg.h>
+-#include <string.h>
+-#include <float.h>
++    $ac_path_GREP_found && break 3
++  done
++done
+-int
+-main ()
+-{
++done
++IFS=$as_save_IFS
++
++
++fi
++
++GREP="$ac_cv_path_GREP"
++if test -z "$GREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
+-  ac_status=$?
+-  grep -v '^ *+' conftest.er1 >conftest.err
+-  rm -f conftest.er1
+-  cat conftest.err >&5
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_header_stdc=yes
+ else
+-  echo "$as_me: failed program was:" >&5
+-sed 's/^/| /' conftest.$ac_ext >&5
++  ac_cv_path_GREP=$GREP
++fi
++
+-ac_cv_header_stdc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
++echo "${ECHO_T}$ac_cv_path_GREP" >&6; }
++ GREP="$ac_cv_path_GREP"
+-if test $ac_cv_header_stdc = yes; then
+-  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+-  cat >conftest.$ac_ext <<_ACEOF
++
++{ echo "$as_me:$LINENO: checking for egrep" >&5
++echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }
++if test "${ac_cv_path_EGREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
++   then ac_cv_path_EGREP="$GREP -E"
++   else
++     # Extract the first word of "egrep" to use in msg output
++if test -z "$EGREP"; then
++set dummy egrep; ac_prog_name=$2
++if test "${ac_cv_path_EGREP+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  ac_path_EGREP_found=false
++# Loop through the user's path and test for each of PROGNAME-LIST
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  for ac_prog in egrep; do
++  for ac_exec_ext in '' $ac_executable_extensions; do
++    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
++    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
++    # Check for GNU ac_path_EGREP and select it if it is found.
++  # Check for GNU $ac_path_EGREP
++case `"$ac_path_EGREP" --version 2>&1` in
++*GNU*)
++  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
++*)
++  ac_count=0
++  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
++  while :
++  do
++    cat "conftest.in" "conftest.in" >"conftest.tmp"
++    mv "conftest.tmp" "conftest.in"
++    cp "conftest.in" "conftest.nl"
++    echo 'EGREP' >> "conftest.nl"
++    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
++    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
++    ac_count=`expr $ac_count + 1`
++    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
++      # Best one so far, save it but keep looking for a better one
++      ac_cv_path_EGREP="$ac_path_EGREP"
++      ac_path_EGREP_max=$ac_count
++    fi
++    # 10*(2^10) chars as input seems more than enough
++    test $ac_count -gt 10 && break
++  done
++  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
++esac
++
++
++    $ac_path_EGREP_found && break 3
++  done
++done
++
++done
++IFS=$as_save_IFS
++
++
++fi
++
++EGREP="$ac_cv_path_EGREP"
++if test -z "$EGREP"; then
++  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
++echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
++   { (exit 1); exit 1; }; }
++fi
++
++else
++  ac_cv_path_EGREP=$EGREP
++fi
++
++
++   fi
++fi
++{ echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
++echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }
++ EGREP="$ac_cv_path_EGREP"
++
++
++{ echo "$as_me:$LINENO: checking for ANSI C header files" >&5
++echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
++if test "${ac_cv_header_stdc+set}" = set; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <stdlib.h>
++#include <stdarg.h>
++#include <string.h>
++#include <float.h>
++
++int
++main ()
++{
++
++  ;
++  return 0;
++}
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_header_stdc=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++      ac_cv_header_stdc=no
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++
++if test $ac_cv_header_stdc = yes; then
++  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
++  cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+@@ -5661,6 +6332,7 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <ctype.h>
++#include <stdlib.h>
+ #if ((' ' & 0x0FF) == 0x020)
+ # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+ # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+@@ -5680,18 +6352,27 @@ main ()
+   for (i = 0; i < 256; i++)
+     if (XOR (islower (i), ISLOWER (i))
+       || toupper (i) != TOUPPER (i))
+-      exit(2);
+-  exit (0);
++      return 2;
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -5704,12 +6385,14 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_header_stdc=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
+-echo "${ECHO_T}$ac_cv_header_stdc" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
++echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
+ if test $ac_cv_header_stdc = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -5718,8 +6401,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
+-echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
++echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; }
+ if test "${ac_cv_c_const+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5737,10 +6420,10 @@ main ()
+ #ifndef __cplusplus
+   /* Ultrix mips cc rejects this.  */
+   typedef int charset[2];
+-  const charset x;
++  const charset cs;
+   /* SunOS 4.1.1 cc rejects this.  */
+-  char const *const *ccp;
+-  char **p;
++  char const *const *pcpcc;
++  char **ppc;
+   /* NEC SVR4.0.2 mips cc rejects this.  */
+   struct point {int x, y;};
+   static struct point const zero = {0,0};
+@@ -5749,16 +6432,17 @@ main ()
+      an arm of an if-expression whose if-part is not a constant
+      expression */
+   const char *g = "string";
+-  ccp = &g + (g ? g-g : 0);
++  pcpcc = &g + (g ? g-g : 0);
+   /* HPUX 7.0 cc rejects these. */
+-  ++ccp;
+-  p = (char**) ccp;
+-  ccp = (char const *const *) p;
++  ++pcpcc;
++  ppc = (char**) pcpcc;
++  pcpcc = (char const *const *) ppc;
+   { /* SCO 3.2v4 cc rejects this.  */
+     char *t;
+     char const *s = 0 ? (char *) 0 : (char const *) 0;
+     *t++ = 0;
++    if (s) return 0;
+   }
+   { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+     int x[] = {25, 17};
+@@ -5777,7 +6461,9 @@ main ()
+   }
+   { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+     const int foo = 10;
++    if (!foo) return 0;
+   }
++  return !cs[0] && !zero.x;
+ #endif
+   ;
+@@ -5785,38 +6471,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_c_const=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_c_const=no
++      ac_cv_c_const=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
+-echo "${ECHO_T}$ac_cv_c_const" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
++echo "${ECHO_T}$ac_cv_c_const" >&6; }
+ if test $ac_cv_c_const = no; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -5825,8 +6507,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for inline" >&5
+-echo $ECHO_N "checking for inline... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for inline" >&5
++echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
+ if test "${ac_cv_c_inline+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5846,39 +6528,37 @@ $ac_kw foo_t foo () {return 0; }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
+-  ac_cv_c_inline=$ac_kw; break
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_cv_c_inline=$ac_kw
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
++
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++  test "$ac_cv_c_inline" != no && break
+ done
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
+-echo "${ECHO_T}$ac_cv_c_inline" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
++echo "${ECHO_T}$ac_cv_c_inline" >&6; }
+ case $ac_cv_c_inline in
+@@ -5910,9 +6590,9 @@ for ac_header in sys/types.h sys/stat.h 
+                 inttypes.h stdint.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -5926,38 +6606,35 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   eval "$as_ac_Header=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_Header=no"
++      eval "$as_ac_Header=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+@@ -5968,8 +6645,8 @@ fi
+ done
+-echo "$as_me:$LINENO: checking for off_t" >&5
+-echo $ECHO_N "checking for off_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for off_t" >&5
++echo $ECHO_N "checking for off_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_off_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -5980,62 +6657,59 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef off_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((off_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (off_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_off_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_off_t=no
++      ac_cv_type_off_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
+-echo "${ECHO_T}$ac_cv_type_off_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
++echo "${ECHO_T}$ac_cv_type_off_t" >&6; }
+ if test $ac_cv_type_off_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define off_t long
++#define off_t long int
+ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for size_t" >&5
+-echo $ECHO_N "checking for size_t... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for size_t" >&5
++echo $ECHO_N "checking for size_t... $ECHO_C" >&6; }
+ if test "${ac_cv_type_size_t+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6046,64 +6720,61 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ $ac_includes_default
++typedef size_t ac__type_new_;
+ int
+ main ()
+ {
+-if ((size_t *) 0)
++if ((ac__type_new_ *) 0)
+   return 0;
+-if (sizeof (size_t))
++if (sizeof (ac__type_new_))
+   return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_type_size_t=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_type_size_t=no
++      ac_cv_type_size_t=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
+-echo "${ECHO_T}$ac_cv_type_size_t" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
++echo "${ECHO_T}$ac_cv_type_size_t" >&6; }
+ if test $ac_cv_type_size_t = yes; then
+   :
+ else
+ cat >>confdefs.h <<_ACEOF
+-#define size_t unsigned
++#define size_t unsigned int
+ _ACEOF
+ fi
+ # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+ # for constant arguments.  Useless!
+-echo "$as_me:$LINENO: checking for working alloca.h" >&5
+-echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working alloca.h" >&5
++echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6; }
+ if test "${ac_cv_working_alloca_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6118,44 +6789,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (2 * sizeof (int));
++                        if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_working_alloca_h=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_working_alloca_h=no
++      ac_cv_working_alloca_h=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
+-echo "${ECHO_T}$ac_cv_working_alloca_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5
++echo "${ECHO_T}$ac_cv_working_alloca_h" >&6; }
+ if test $ac_cv_working_alloca_h = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -6164,8 +6833,8 @@ _ACEOF
+ fi
+-echo "$as_me:$LINENO: checking for alloca" >&5
+-echo $ECHO_N "checking for alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for alloca" >&5
++echo $ECHO_N "checking for alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_func_alloca_works+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6182,7 +6851,7 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #  include <malloc.h>
+ #  define alloca _alloca
+ # else
+-#  if HAVE_ALLOCA_H
++#  ifdef HAVE_ALLOCA_H
+ #   include <alloca.h>
+ #  else
+ #   ifdef _AIX
+@@ -6200,44 +6869,42 @@ int
+ main ()
+ {
+ char *p = (char *) alloca (1);
++                                  if (p) return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_func_alloca_works=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_func_alloca_works=no
++      ac_cv_func_alloca_works=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
+-echo "${ECHO_T}$ac_cv_func_alloca_works" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5
++echo "${ECHO_T}$ac_cv_func_alloca_works" >&6; }
+ if test $ac_cv_func_alloca_works = yes; then
+@@ -6251,15 +6918,15 @@ else
+ # contain a buggy version.  If you still want to use their alloca,
+ # use ar to extract alloca.o from them instead of compiling alloca.c.
+-ALLOCA=alloca.$ac_objext
++ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
+ cat >>confdefs.h <<\_ACEOF
+ #define C_ALLOCA 1
+ _ACEOF
+-echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
+-echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5
++echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6; }
+ if test "${ac_cv_os_cray+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6269,7 +6936,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#if defined(CRAY) && ! defined(CRAY2)
++#if defined CRAY && ! defined CRAY2
+ webecray
+ #else
+ wenotbecray
+@@ -6285,14 +6952,14 @@ fi
+ rm -f conftest*
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
+-echo "${ECHO_T}$ac_cv_os_cray" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5
++echo "${ECHO_T}$ac_cv_os_cray" >&6; }
+ if test $ac_cv_os_cray = yes; then
+   for ac_func in _getb67 GETB67 getb67; do
+     as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6318,68 +6985,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -6392,8 +7051,8 @@ fi
+   done
+ fi
+-echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
+-echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking stack direction for C alloca" >&5
++echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6; }
+ if test "${ac_cv_c_stack_direction+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6406,6 +7065,7 @@ _ACEOF
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
++$ac_includes_default
+ int
+ find_stack_direction ()
+ {
+@@ -6423,17 +7083,26 @@ find_stack_direction ()
+ int
+ main ()
+ {
+-  exit (find_stack_direction () < 0);
++  return find_stack_direction () < 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -6446,11 +7115,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_c_stack_direction=-1
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
+-echo "${ECHO_T}$ac_cv_c_stack_direction" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5
++echo "${ECHO_T}$ac_cv_c_stack_direction" >&6; }
+ cat >>confdefs.h <<_ACEOF
+ #define STACK_DIRECTION $ac_cv_c_stack_direction
+@@ -6464,18 +7135,19 @@ fi
+ for ac_header in stdlib.h unistd.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6486,41 +7158,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6529,24 +7197,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -6554,9 +7220,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -6580,25 +7247,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -6614,9 +7275,9 @@ done
+ for ac_func in getpagesize
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -6642,68 +7303,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -6712,8 +7365,8 @@ _ACEOF
+ fi
+ done
+-echo "$as_me:$LINENO: checking for working mmap" >&5
+-echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for working mmap" >&5
++echo $ECHO_N "checking for working mmap... $ECHO_C" >&6; }
+ if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -6755,21 +7408,21 @@ $ac_includes_default
+ #include <fcntl.h>
+ #include <sys/mman.h>
+-#if !STDC_HEADERS && !HAVE_STDLIB_H
++#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H
+ char *malloc ();
+ #endif
+ /* This mess was copied from the GNU getpagesize.h.  */
+-#if !HAVE_GETPAGESIZE
++#ifndef HAVE_GETPAGESIZE
+ /* Assume that all systems that can run configure have sys/param.h.  */
+-# if !HAVE_SYS_PARAM_H
++# ifndef HAVE_SYS_PARAM_H
+ #  define HAVE_SYS_PARAM_H 1
+ # endif
+ # ifdef _SC_PAGESIZE
+ #  define getpagesize() sysconf(_SC_PAGESIZE)
+ # else /* no _SC_PAGESIZE */
+-#  if HAVE_SYS_PARAM_H
++#  ifdef HAVE_SYS_PARAM_H
+ #   include <sys/param.h>
+ #   ifdef EXEC_PAGESIZE
+ #    define getpagesize() EXEC_PAGESIZE
+@@ -6808,15 +7461,15 @@ main ()
+   /* First, make a file with some known garbage in it. */
+   data = (char *) malloc (pagesize);
+   if (!data)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     *(data + i) = rand ();
+   umask (0);
+   fd = creat ("conftest.mmap", 0600);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   if (write (fd, data, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   close (fd);
+   /* Next, try to mmap the file at a fixed address which already has
+@@ -6824,17 +7477,17 @@ main ()
+      we see the same garbage.  */
+   fd = open ("conftest.mmap", O_RDWR);
+   if (fd < 0)
+-    exit (1);
++    return 1;
+   data2 = (char *) malloc (2 * pagesize);
+   if (!data2)
+-    exit (1);
+-  data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
++    return 1;
++  data2 += (pagesize - ((long int) data2 & (pagesize - 1))) & (pagesize - 1);
+   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_FIXED, fd, 0L))
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data2 + i))
+-      exit (1);
++      return 1;
+   /* Finally, make sure that changes to the mapped area do not
+      percolate back to the file as seen by read().  (This is a bug on
+@@ -6843,24 +7496,33 @@ main ()
+     *(data2 + i) = *(data2 + i) + 1;
+   data3 = (char *) malloc (pagesize);
+   if (!data3)
+-    exit (1);
++    return 1;
+   if (read (fd, data3, pagesize) != pagesize)
+-    exit (1);
++    return 1;
+   for (i = 0; i < pagesize; ++i)
+     if (*(data + i) != *(data3 + i))
+-      exit (1);
++      return 1;
+   close (fd);
+-  exit (0);
++  return 0;
+ }
+ _ACEOF
+ rm -f conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>&5
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
++  { (case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_try") 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; }; then
+@@ -6873,11 +7535,13 @@ sed 's/^/| /' conftest.$ac_ext >&5
+ ( exit $ac_status )
+ ac_cv_func_mmap_fixed_mapped=no
+ fi
+-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+ fi
++
++
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
+-echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
++echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6; }
+ if test $ac_cv_func_mmap_fixed_mapped = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -6901,18 +7565,19 @@ for ac_header in argz.h limits.h locale.
+ unistd.h values.h sys/param.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6923,41 +7588,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -6966,24 +7627,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -6991,9 +7650,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -7017,25 +7677,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -7061,9 +7715,9 @@ for ac_func in getcwd munmap putenv sete
+ __argz_count __argz_stringify __argz_next
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7089,68 +7743,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7165,9 +7811,9 @@ done
+ for ac_func in stpcpy
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7193,68 +7839,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7273,8 +7911,8 @@ _ACEOF
+    fi
+    if test $ac_cv_header_locale_h = yes; then
+-    echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
+-echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6
++    { echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5
++echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6; }
+ if test "${am_cv_val_LC_MESSAGES+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7294,39 +7932,36 @@ return LC_MESSAGES
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   am_cv_val_LC_MESSAGES=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-am_cv_val_LC_MESSAGES=no
++      am_cv_val_LC_MESSAGES=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
+-echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6
++{ echo "$as_me:$LINENO: result: $am_cv_val_LC_MESSAGES" >&5
++echo "${ECHO_T}$am_cv_val_LC_MESSAGES" >&6; }
+     if test $am_cv_val_LC_MESSAGES = yes; then
+ cat >>confdefs.h <<\_ACEOF
+@@ -7335,34 +7970,34 @@ _ACEOF
+     fi
+   fi
+-   echo "$as_me:$LINENO: checking whether NLS is requested" >&5
+-echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6
+-        # Check whether --enable-nls or --disable-nls was given.
++   { echo "$as_me:$LINENO: checking whether NLS is requested" >&5
++echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6; }
++        # Check whether --enable-nls was given.
+ if test "${enable_nls+set}" = set; then
+-  enableval="$enable_nls"
+-  USE_NLS=$enableval
++  enableval=$enable_nls; USE_NLS=$enableval
+ else
+   USE_NLS=yes
+-fi;
+-    echo "$as_me:$LINENO: result: $USE_NLS" >&5
+-echo "${ECHO_T}$USE_NLS" >&6
++fi
++
++    { echo "$as_me:$LINENO: result: $USE_NLS" >&5
++echo "${ECHO_T}$USE_NLS" >&6; }
+     USE_INCLUDED_LIBINTL=no
+         if test "$USE_NLS" = "yes"; then
+-      echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
+-echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6
++      { echo "$as_me:$LINENO: checking whether included gettext is requested" >&5
++echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6; }
+-# Check whether --with-included-gettext or --without-included-gettext was given.
++# Check whether --with-included-gettext was given.
+ if test "${with_included_gettext+set}" = set; then
+-  withval="$with_included_gettext"
+-  nls_cv_force_use_gnu_gettext=$withval
++  withval=$with_included_gettext; nls_cv_force_use_gnu_gettext=$withval
+ else
+   nls_cv_force_use_gnu_gettext=no
+-fi;
+-      echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
+-echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6
++fi
++
++      { echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5
++echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6; }
+       nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext"
+       if test "$nls_cv_force_use_gnu_gettext" != "yes"; then
+@@ -7371,17 +8006,17 @@ echo "${ECHO_T}$nls_cv_force_use_gnu_get
+       CATOBJEXT=
+       if test "${ac_cv_header_libintl_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking libintl.h usability" >&5
+-echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h usability" >&5
++echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7392,41 +8027,37 @@ $ac_includes_default
+ #include <libintl.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking libintl.h presence" >&5
+-echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking libintl.h presence" >&5
++echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -7435,24 +8066,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <libintl.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -7460,9 +8089,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -7486,30 +8116,23 @@ echo "$as_me: WARNING: libintl.h:     se
+ echo "$as_me: WARNING: libintl.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: libintl.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: libintl.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for libintl.h" >&5
+-echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for libintl.h" >&5
++echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_libintl_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_libintl_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
+-echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
++echo "${ECHO_T}$ac_cv_header_libintl_h" >&6; }
+ fi
+ if test $ac_cv_header_libintl_h = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libc" >&5
+-echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libc" >&5
++echo $ECHO_N "checking for gettext in libc... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libc+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7529,43 +8152,40 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libc=no
++      gt_cv_func_gettext_libc=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libc" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libc" >&6; }
+          if test "$gt_cv_func_gettext_libc" != "yes"; then
+-           echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
+-echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6
++           { echo "$as_me:$LINENO: checking for bindtextdomain in -lintl" >&5
++echo $ECHO_N "checking for bindtextdomain in -lintl... $ECHO_C" >&6; }
+ if test "${ac_cv_lib_intl_bindtextdomain+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7578,59 +8198,56 @@ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char bindtextdomain ();
+ int
+ main ()
+ {
+-bindtextdomain ();
++return bindtextdomain ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   ac_cv_lib_intl_bindtextdomain=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_lib_intl_bindtextdomain=no
++      ac_cv_lib_intl_bindtextdomain=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ LIBS=$ac_check_lib_save_LIBS
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
+-echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_lib_intl_bindtextdomain" >&5
++echo "${ECHO_T}$ac_cv_lib_intl_bindtextdomain" >&6; }
+ if test $ac_cv_lib_intl_bindtextdomain = yes; then
+-  echo "$as_me:$LINENO: checking for gettext in libintl" >&5
+-echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for gettext in libintl" >&5
++echo $ECHO_N "checking for gettext in libintl... $ECHO_C" >&6; }
+ if test "${gt_cv_func_gettext_libintl+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7650,39 +8267,36 @@ return (int) gettext ("")
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   gt_cv_func_gettext_libintl=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-gt_cv_func_gettext_libintl=no
++      gt_cv_func_gettext_libintl=no
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
+-echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6
++{ echo "$as_me:$LINENO: result: $gt_cv_func_gettext_libintl" >&5
++echo "${ECHO_T}$gt_cv_func_gettext_libintl" >&6; }
+ fi
+          fi
+@@ -7696,8 +8310,8 @@ _ACEOF
+             # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7723,20 +8337,20 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+             if test "$MSGFMT" != "no"; then
+ for ac_func in dcgettext
+ do
+ as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+-echo "$as_me:$LINENO: checking for $ac_func" >&5
+-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_var+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_func" >&5
++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   cat >conftest.$ac_ext <<_ACEOF
+@@ -7762,68 +8376,60 @@ cat >>conftest.$ac_ext <<_ACEOF
+ #undef $ac_func
+-/* Override any gcc2 internal prototype to avoid an error.  */
++/* Override any GCC internal prototype to avoid an error.
++   Use char because int might match the return type of a GCC
++   builtin and then its argument prototype would still apply.  */
+ #ifdef __cplusplus
+ extern "C"
+-{
+ #endif
+-/* We use char because int might match the return type of a gcc2
+-   builtin and then its argument prototype would still apply.  */
+ char $ac_func ();
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
++#if defined __stub_$ac_func || defined __stub___$ac_func
+ choke me
+-#else
+-char (*f) () = $ac_func;
+-#endif
+-#ifdef __cplusplus
+-}
+ #endif
+ int
+ main ()
+ {
+-return f != $ac_func;
++return $ac_func ();
+   ;
+   return 0;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   eval "$as_ac_var=yes"
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-eval "$as_ac_var=no"
++      eval "$as_ac_var=no"
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
++ac_res=`eval echo '${'$as_ac_var'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ if test `eval echo '${'$as_ac_var'}'` = yes; then
+   cat >>confdefs.h <<_ACEOF
+ #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+@@ -7834,8 +8440,8 @@ done
+               # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7850,32 +8456,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+               # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -7901,11 +8508,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+               cat >conftest.$ac_ext <<_ACEOF
+@@ -7925,37 +8532,34 @@ extern int _nl_msg_cat_cntr;
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext conftest$ac_exeext
+-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+-  (eval $ac_link) 2>conftest.er1
++if { (ac_try="$ac_link"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_link") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest$ac_exeext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest$ac_exeext &&
++       $as_test_x conftest$ac_exeext; then
+   CATOBJEXT=.gmo
+                  DATADIRNAME=share
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-CATOBJEXT=.mo
++      CATOBJEXT=.mo
+                  DATADIRNAME=lib
+ fi
+-rm -f conftest.err conftest.$ac_objext \
++
++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+       conftest$ac_exeext conftest.$ac_ext
+               INSTOBJEXT=.mo
+             fi
+@@ -7977,8 +8581,8 @@ fi
+                 INTLOBJS="\$(GETTOBJS)"
+         # Extract the first word of "msgfmt", so it can be a program name with args.
+ set dummy msgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_MSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8004,17 +8608,17 @@ esac
+ fi
+ MSGFMT="$ac_cv_path_MSGFMT"
+ if test -n "$MSGFMT"; then
+-  echo "$as_me:$LINENO: result: $MSGFMT" >&5
+-echo "${ECHO_T}$MSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $MSGFMT" >&5
++echo "${ECHO_T}$MSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+         # Extract the first word of "gmsgfmt", so it can be a program name with args.
+ set dummy gmsgfmt; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_GMSGFMT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8029,32 +8633,33 @@ do
+   IFS=$as_save_IFS
+   test -z "$as_dir" && as_dir=.
+   for ac_exec_ext in '' $ac_executable_extensions; do
+-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+     ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"
+     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+ done
++IFS=$as_save_IFS
+   test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"
+   ;;
+ esac
+ fi
+ GMSGFMT=$ac_cv_path_GMSGFMT
+-
+ if test -n "$GMSGFMT"; then
+-  echo "$as_me:$LINENO: result: $GMSGFMT" >&5
+-echo "${ECHO_T}$GMSGFMT" >&6
++  { echo "$as_me:$LINENO: result: $GMSGFMT" >&5
++echo "${ECHO_T}$GMSGFMT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
++
+         # Extract the first word of "xgettext", so it can be a program name with args.
+ set dummy xgettext; ac_word=$2
+-echo "$as_me:$LINENO: checking for $ac_word" >&5
+-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for $ac_word" >&5
++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+ if test "${ac_cv_path_XGETTEXT+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8080,11 +8685,11 @@ esac
+ fi
+ XGETTEXT="$ac_cv_path_XGETTEXT"
+ if test -n "$XGETTEXT"; then
+-  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
+-echo "${ECHO_T}$XGETTEXT" >&6
++  { echo "$as_me:$LINENO: result: $XGETTEXT" >&5
++echo "${ECHO_T}$XGETTEXT" >&6; }
+ else
+-  echo "$as_me:$LINENO: result: no" >&5
+-echo "${ECHO_T}no" >&6
++  { echo "$as_me:$LINENO: result: no" >&5
++echo "${ECHO_T}no" >&6; }
+ fi
+@@ -8103,8 +8708,8 @@ fi
+                       if $XGETTEXT --omit-header /dev/null 2> /dev/null; then
+         : ;
+       else
+-        echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
+-echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6
++        { echo "$as_me:$LINENO: result: found xgettext programs is not GNU xgettext; ignore it" >&5
++echo "${ECHO_T}found xgettext programs is not GNU xgettext; ignore it" >&6; }
+         XGETTEXT=":"
+       fi
+       fi
+@@ -8153,8 +8758,8 @@ _ACEOF
+      if test "x$ALL_LINGUAS" = "x"; then
+        LINGUAS=
+      else
+-       echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
+-echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6
++       { echo "$as_me:$LINENO: checking for catalogs to be installed" >&5
++echo $ECHO_N "checking for catalogs to be installed... $ECHO_C" >&6; }
+        NEW_LINGUAS=
+        for lang in ${LINGUAS=$ALL_LINGUAS}; do
+          case "$ALL_LINGUAS" in
+@@ -8162,8 +8767,8 @@ echo $ECHO_N "checking for catalogs to b
+          esac
+        done
+        LINGUAS=$NEW_LINGUAS
+-       echo "$as_me:$LINENO: result: $LINGUAS" >&5
+-echo "${ECHO_T}$LINGUAS" >&6
++       { echo "$as_me:$LINENO: result: $LINGUAS" >&5
++echo "${ECHO_T}$LINGUAS" >&6; }
+      fi
+           if test -n "$LINGUAS"; then
+@@ -8182,17 +8787,17 @@ echo "${ECHO_T}$LINGUAS" >&6
+             if test -f $srcdir/po2tbl.sed.in; then
+       if test "$CATOBJEXT" = ".cat"; then
+        if test "${ac_cv_header_linux_version_h+set}" = set; then
+-  echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking linux/version.h usability" >&5
+-echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h usability" >&5
++echo $ECHO_N "checking linux/version.h usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8203,41 +8808,37 @@ $ac_includes_default
+ #include <linux/version.h>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking linux/version.h presence" >&5
+-echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking linux/version.h presence" >&5
++echo $ECHO_N "checking linux/version.h presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8246,24 +8847,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <linux/version.h>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -8271,9 +8870,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -8297,25 +8897,18 @@ echo "$as_me: WARNING: linux/version.h: 
+ echo "$as_me: WARNING: linux/version.h: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: linux/version.h: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: linux/version.h: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for linux/version.h" >&5
+-echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for linux/version.h" >&5
++echo $ECHO_N "checking for linux/version.h... $ECHO_C" >&6; }
+ if test "${ac_cv_header_linux_version_h+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   ac_cv_header_linux_version_h=$ac_header_preproc
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
+-echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_header_linux_version_h" >&5
++echo "${ECHO_T}$ac_cv_header_linux_version_h" >&6; }
+ fi
+ if test $ac_cv_header_linux_version_h = yes; then
+@@ -8380,8 +8973,8 @@ fi
+ if test "x$cross_compiling" = "xno"; then
+   EXEEXT_FOR_BUILD='$(EXEEXT)'
+ else
+-  echo "$as_me:$LINENO: checking for build system executable suffix" >&5
+-echo $ECHO_N "checking for build system executable suffix... $ECHO_C" >&6
++  { echo "$as_me:$LINENO: checking for build system executable suffix" >&5
++echo $ECHO_N "checking for build system executable suffix... $ECHO_C" >&6; }
+ if test "${bfd_cv_build_exeext+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8398,8 +8991,8 @@ else
+      rm -f conftest*
+      test x"${bfd_cv_build_exeext}" = x && bfd_cv_build_exeext=no
+ fi
+-echo "$as_me:$LINENO: result: $bfd_cv_build_exeext" >&5
+-echo "${ECHO_T}$bfd_cv_build_exeext" >&6
++{ echo "$as_me:$LINENO: result: $bfd_cv_build_exeext" >&5
++echo "${ECHO_T}$bfd_cv_build_exeext" >&6; }
+   EXEEXT_FOR_BUILD=""
+   test x"${bfd_cv_build_exeext}" != xno && EXEEXT_FOR_BUILD=${bfd_cv_build_exeext}
+ fi
+@@ -8419,8 +9012,8 @@ fi
+ # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+ # OS/2's system install, which has a completely different semantic
+ # ./install, which can be erroneously created by make from ./install.sh.
+-echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+-echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+ if test -z "$INSTALL"; then
+ if test "${ac_cv_path_install+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+@@ -8442,7 +9035,7 @@ case $as_dir/ in
+     # by default.
+     for ac_prog in ginstall scoinst install; do
+       for ac_exec_ext in '' $ac_executable_extensions; do
+-      if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
++      if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+         if test $ac_prog = install &&
+           grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+           # AIX install.  It has an incompatible calling convention.
+@@ -8461,21 +9054,22 @@ case $as_dir/ in
+     ;;
+ esac
+ done
++IFS=$as_save_IFS
+ fi
+   if test "${ac_cv_path_install+set}" = set; then
+     INSTALL=$ac_cv_path_install
+   else
+-    # As a last resort, use the slow shell script.  We don't cache a
+-    # path for INSTALL within a source directory, because that will
++    # As a last resort, use the slow shell script.  Don't cache a
++    # value for INSTALL within a source directory, because that will
+     # break other packages using the cache if that directory is
+-    # removed, or if the path is relative.
++    # removed, or if the value is a relative name.
+     INSTALL=$ac_install_sh
+   fi
+ fi
+-echo "$as_me:$LINENO: result: $INSTALL" >&5
+-echo "${ECHO_T}$INSTALL" >&6
++{ echo "$as_me:$LINENO: result: $INSTALL" >&5
++echo "${ECHO_T}$INSTALL" >&6; }
+ # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+ # It thinks the first close brace ends the variable substitution.
+@@ -8492,18 +9086,19 @@ test -z "$INSTALL_DATA" && INSTALL_DATA=
+ for ac_header in string.h strings.h stdlib.h
+ do
+ as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
+-  echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ else
+   # Is the header compilable?
+-echo "$as_me:$LINENO: checking $ac_header usability" >&5
+-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8514,41 +9109,37 @@ $ac_includes_default
+ #include <$ac_header>
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_header_compiler=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_header_compiler=no
++      ac_header_compiler=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+-echo "${ECHO_T}$ac_header_compiler" >&6
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
+ # Is the header present?
+-echo "$as_me:$LINENO: checking $ac_header presence" >&5
+-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
+ cat >conftest.$ac_ext <<_ACEOF
+ /* confdefs.h.  */
+ _ACEOF
+@@ -8557,24 +9148,22 @@ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #include <$ac_header>
+ _ACEOF
+-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } >/dev/null; then
+-  if test -s conftest.err; then
+-    ac_cpp_err=$ac_c_preproc_warn_flag
+-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+-  else
+-    ac_cpp_err=
+-  fi
+-else
+-  ac_cpp_err=yes
+-fi
+-if test -z "$ac_cpp_err"; then
++  (exit $ac_status); } >/dev/null && {
++       test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       }; then
+   ac_header_preproc=yes
+ else
+   echo "$as_me: failed program was:" >&5
+@@ -8582,9 +9171,10 @@ sed 's/^/| /' conftest.$ac_ext >&5
+   ac_header_preproc=no
+ fi
++
+ rm -f conftest.err conftest.$ac_ext
+-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+-echo "${ECHO_T}$ac_header_preproc" >&6
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
+ # So?  What about this header?
+ case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+@@ -8608,25 +9198,19 @@ echo "$as_me: WARNING: $ac_header:     s
+ echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+ echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+-    (
+-      cat <<\_ASBOX
+-## ------------------------------------------ ##
+-## Report this to the AC_PACKAGE_NAME lists.  ##
+-## ------------------------------------------ ##
+-_ASBOX
+-    ) |
+-      sed "s/^/$as_me: WARNING:     /" >&2
++
+     ;;
+ esac
+-echo "$as_me:$LINENO: checking for $ac_header" >&5
+-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+-if eval "test \"\${$as_ac_Header+set}\" = set"; then
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+   eval "$as_ac_Header=\$ac_header_preproc"
+ fi
+-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
++ac_res=`eval echo '${'$as_ac_Header'}'`
++             { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
+ fi
+ if test `eval echo '${'$as_ac_Header'}'` = yes; then
+@@ -8639,8 +9223,8 @@ fi
+ done
+-echo "$as_me:$LINENO: checking whether basename is declared" >&5
+-echo $ECHO_N "checking whether basename is declared... $ECHO_C" >&6
++{ echo "$as_me:$LINENO: checking whether basename is declared" >&5
++echo $ECHO_N "checking whether basename is declared... $ECHO_C" >&6; }
+ if test "${ac_cv_have_decl_basename+set}" = set; then
+   echo $ECHO_N "(cached) $ECHO_C" >&6
+ else
+@@ -8655,7 +9239,7 @@ int
+ main ()
+ {
+ #ifndef basename
+-  char *p = (char *) basename;
++  (void) basename;
+ #endif
+   ;
+@@ -8663,38 +9247,34 @@ main ()
+ }
+ _ACEOF
+ rm -f conftest.$ac_objext
+-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+-  (eval $ac_compile) 2>conftest.er1
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
+   ac_status=$?
+   grep -v '^ *+' conftest.er1 >conftest.err
+   rm -f conftest.er1
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); } &&
+-       { ac_try='test -z "$ac_c_werror_flag"
+-                       || test ! -s conftest.err'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; } &&
+-       { ac_try='test -s conftest.$ac_objext'
+-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+-  (eval $ac_try) 2>&5
+-  ac_status=$?
+-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+-  (exit $ac_status); }; }; then
++  (exit $ac_status); } && {
++       test -z "$ac_c_werror_flag" ||
++       test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
+   ac_cv_have_decl_basename=yes
+ else
+   echo "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+-ac_cv_have_decl_basename=no
++      ac_cv_have_decl_basename=no
+ fi
+-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ fi
+-echo "$as_me:$LINENO: result: $ac_cv_have_decl_basename" >&5
+-echo "${ECHO_T}$ac_cv_have_decl_basename" >&6
++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_basename" >&5
++echo "${ECHO_T}$ac_cv_have_decl_basename" >&6; }
+ if test $ac_cv_have_decl_basename = yes; then
+ cat >>confdefs.h <<_ACEOF
+@@ -8715,10 +9295,9 @@ fi
+ cgen_maint=no
+ cgendir='$(srcdir)/../cgen'
+-# Check whether --enable-cgen-maint or --disable-cgen-maint was given.
++# Check whether --enable-cgen-maint was given.
+ if test "${enable_cgen_maint+set}" = set; then
+-  enableval="$enable_cgen_maint"
+-  case "${enableval}" in
++  enableval=$enable_cgen_maint; case "${enableval}" in
+   yes)        cgen_maint=yes ;;
+   no) cgen_maint=no ;;
+   *)
+@@ -8729,7 +9308,8 @@ if test "${enable_cgen_maint+set}" = set
+       cgendir=${cgen_maint}/lib/cgen
+       ;;
+ esac
+-fi;
++fi
++
+ if test x${cgen_maint} = xyes; then
+   CGEN_MAINT_TRUE=
+@@ -8805,6 +9385,7 @@ if test x${all_targets} = xfalse ; then
+       bfd_arc_arch)           ta="$ta arc-dis.lo arc-opc.lo arc-ext.lo" ;;
+       bfd_arm_arch)           ta="$ta arm-dis.lo" ;;
+       bfd_avr_arch)           ta="$ta avr-dis.lo" ;;
++      bfd_avr32_arch)         ta="$ta avr32-asm.lo avr32-dis.lo avr32-opc.lo" ;;
+       bfd_bfin_arch)          ta="$ta bfin-dis.lo" ;;
+       bfd_cris_arch)          ta="$ta cris-dis.lo cris-opc.lo cgen-bitset.lo" ;;
+       bfd_crx_arch)           ta="$ta crx-dis.lo crx-opc.lo" ;;
+@@ -8922,9 +9503,9 @@ fi
+-                    ac_config_files="$ac_config_files Makefile po/Makefile.in:po/Make-in"
++ac_config_files="$ac_config_files Makefile po/Makefile.in:po/Make-in"
+-          ac_config_commands="$ac_config_commands default"
++ac_config_commands="$ac_config_commands default"
+ cat >confcache <<\_ACEOF
+ # This file is a shell script that caches the results of configure
+@@ -8944,39 +9525,58 @@ _ACEOF
+ # The following way of writing the cache mishandles newlines in values,
+ # but we know of no workaround that is simple, portable, and efficient.
+-# So, don't put newlines in cache variables' values.
++# So, we kill variables containing newlines.
+ # Ultrix sh set writes to stderr and can't be redirected directly,
+ # and sets the high bit in the cache file unless we assign to the vars.
+-{
++(
++  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
++    eval ac_val=\$$ac_var
++    case $ac_val in #(
++    *${as_nl}*)
++      case $ac_var in #(
++      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
++echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
++      esac
++      case $ac_var in #(
++      _ | IFS | as_nl) ;; #(
++      *) $as_unset $ac_var ;;
++      esac ;;
++    esac
++  done
++
+   (set) 2>&1 |
+-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+-    *ac_space=\ *)
++    case $as_nl`(ac_space=' '; set) 2>&1` in #(
++    *${as_nl}ac_space=\ *)
+       # `set' does not quote correctly, so add quotes (double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \).
+       sed -n \
+       "s/'/'\\\\''/g;
+         s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+-      ;;
++      ;; #(
+     *)
+       # `set' quotes correctly as required by POSIX, so do not add quotes.
+-      sed -n \
+-      "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
++      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+-    esac;
+-} |
++    esac |
++    sort
++) |
+   sed '
++     /^ac_cv_env_/b end
+      t clear
+-     : clear
++     :clear
+      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+      t end
+-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+-     : end' >>confcache
+-if diff $cache_file confcache >/dev/null 2>&1; then :; else
+-  if test -w $cache_file; then
+-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
++     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
++     :end' >>confcache
++if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
++  if test -w "$cache_file"; then
++    test "x$cache_file" != "x/dev/null" &&
++      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
++echo "$as_me: updating cache $cache_file" >&6;}
+     cat confcache >$cache_file
+   else
+-    echo "not updating unwritable cache $cache_file"
++    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
++echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -8985,32 +9585,18 @@ test "x$prefix" = xNONE && prefix=$ac_de
+ # Let make expand exec_prefix.
+ test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+-# VPATH may cause trouble with some makes, so we remove $(srcdir),
+-# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+-# trailing colons and then remove the whole line if VPATH becomes empty
+-# (actually we leave an empty line to preserve line numbers).
+-if test "x$srcdir" = x.; then
+-  ac_vpsub='/^[        ]*VPATH[        ]*=/{
+-s/:*\$(srcdir):*/:/;
+-s/:*\${srcdir}:*/:/;
+-s/:*@srcdir@:*/:/;
+-s/^\([^=]*=[   ]*\):*/\1/;
+-s/:*$//;
+-s/^[^=]*=[     ]*$//;
+-}'
+-fi
+-
+ DEFS=-DHAVE_CONFIG_H
+ ac_libobjs=
+ ac_ltlibobjs=
+ for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+   # 1. Remove the extension, and $U if already installed.
+-  ac_i=`echo "$ac_i" |
+-       sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
+-  # 2. Add them.
+-  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
+-  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
++  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
++  ac_i=`echo "$ac_i" | sed "$ac_script"`
++  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
++  #    will be set to the directory where LIBOBJS objects are built.
++  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
++  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
+ done
+ LIBOBJS=$ac_libobjs
+@@ -9076,17 +9662,45 @@ cat >>$CONFIG_STATUS <<\_ACEOF
+ ## M4sh Initialization.  ##
+ ## --------------------- ##
+-# Be Bourne compatible
++# Be more Bourne compatible
++DUALCASE=1; export DUALCASE # for MKS sh
+ if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+   emulate sh
+   NULLCMD=:
+   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+-  set -o posix
++  setopt NO_GLOB_SUBST
++else
++  case `(set -o) 2>/dev/null` in
++  *posix*) set -o posix ;;
++esac
++
++fi
++
++
++
++
++# PATH needs CR
++# Avoid depending upon Character Ranges.
++as_cr_letters='abcdefghijklmnopqrstuvwxyz'
++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
++as_cr_Letters=$as_cr_letters$as_cr_LETTERS
++as_cr_digits='0123456789'
++as_cr_alnum=$as_cr_Letters$as_cr_digits
++
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
+ fi
+-DUALCASE=1; export DUALCASE # for MKS sh
+ # Support unset when possible.
+ if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+@@ -9096,8 +9710,43 @@ else
+ fi
++# IFS
++# We need space, tab and new line, in precisely that order.  Quoting is
++# there to prevent editors from complaining about space-tab.
++# (If _AS_PATH_WALK were called with IFS unset, it would disable word
++# splitting by setting IFS to empty value.)
++as_nl='
++'
++IFS=" ""      $as_nl"
++
++# Find who we are.  Look in the path if we contain no directory separator.
++case $0 in
++  *[\\/]* ) as_myself=$0 ;;
++  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++for as_dir in $PATH
++do
++  IFS=$as_save_IFS
++  test -z "$as_dir" && as_dir=.
++  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++done
++IFS=$as_save_IFS
++
++     ;;
++esac
++# We did not find ourselves, most probably we were run as `sh COMMAND'
++# in which case we are not to be found in the path.
++if test "x$as_myself" = x; then
++  as_myself=$0
++fi
++if test ! -f "$as_myself"; then
++  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  { (exit 1); exit 1; }
++fi
++
+ # Work around bugs in pre-3.0 UWIN ksh.
+-$as_unset ENV MAIL MAILPATH
++for as_var in ENV MAIL MAILPATH
++do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
++done
+ PS1='$ '
+ PS2='> '
+ PS4='+ '
+@@ -9111,18 +9760,19 @@ do
+   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+     eval $as_var=C; export $as_var
+   else
+-    $as_unset $as_var
++    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+   fi
+ done
+ # Required to use basename.
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+   as_basename=basename
+ else
+   as_basename=false
+@@ -9130,159 +9780,120 @@ fi
+ # Name of the executable.
+-as_me=`$as_basename "$0" ||
++as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+        X"$0" : 'X\(//\)$' \| \
+-       X"$0" : 'X\(/\)$' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X/"$0" |
+-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+-        /^X\/\(\/\/\)$/{ s//\1/; q; }
+-        /^X\/\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^.*\/\([^/][^/]*\)\/*$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\/\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++# CDPATH.
++$as_unset CDPATH
+-# PATH needs CR, and LINENO needs CR and PATH.
+-# Avoid depending upon Character Ranges.
+-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+-as_cr_digits='0123456789'
+-as_cr_alnum=$as_cr_Letters$as_cr_digits
+-
+-# The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
+-  echo "#! /bin/sh" >conf$$.sh
+-  echo  "exit 0"   >>conf$$.sh
+-  chmod +x conf$$.sh
+-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+-    PATH_SEPARATOR=';'
+-  else
+-    PATH_SEPARATOR=:
+-  fi
+-  rm -f conf$$.sh
+-fi
+   as_lineno_1=$LINENO
+   as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+   test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+-  # Find who we are.  Look in the path if we contain no path at all
+-  # relative or not.
+-  case $0 in
+-    *[\\/]* ) as_myself=$0 ;;
+-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in $PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+-done
+-
+-       ;;
+-  esac
+-  # We did not find ourselves, most probably we were run as `sh COMMAND'
+-  # in which case we are not to be found in the path.
+-  if test "x$as_myself" = x; then
+-    as_myself=$0
+-  fi
+-  if test ! -f "$as_myself"; then
+-    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+-echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+-   { (exit 1); exit 1; }; }
+-  fi
+-  case $CONFIG_SHELL in
+-  '')
+-    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+-do
+-  IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-  for as_base in sh bash ksh sh5; do
+-       case $as_dir in
+-       /*)
+-         if ("$as_dir/$as_base" -c '
+-  as_lineno_1=$LINENO
+-  as_lineno_2=$LINENO
+-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+-  test "x$as_lineno_1" != "x$as_lineno_2" &&
+-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+-           $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+-           $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+-           CONFIG_SHELL=$as_dir/$as_base
+-           export CONFIG_SHELL
+-           exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+-         fi;;
+-       esac
+-       done
+-done
+-;;
+-  esac
++  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+   # uniformly replaced by the line number.  The first 'sed' inserts a
+-  # line-number line before each line; the second 'sed' does the real
+-  # work.  The second script uses 'N' to pair each line-number line
+-  # with the numbered line, and appends trailing '-' during
+-  # substitution so that $LINENO is not a special case at line end.
++  # line-number line after each line using $LINENO; the second 'sed'
++  # does the real work.  The second script uses 'N' to pair each
++  # line-number line with the line containing $LINENO, and appends
++  # trailing '-' during substitution so that $LINENO is not a special
++  # case at line end.
+   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+-  sed '=' <$as_myself |
++  # scripts with optimization help from Paolo Bonzini.  Blame Lee
++  # E. McMahon (1931-1989) for sed's syntax.  :-)
++  sed -n '
++    p
++    /[$]LINENO/=
++  ' <$as_myself |
+     sed '
++      s/[$]LINENO.*/&-/
++      t lineno
++      b
++      :lineno
+       N
+-      s,$,-,
+-      : loop
+-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
++      :loop
++      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+       t loop
+-      s,-$,,
+-      s,^['$as_cr_digits']*\n,,
++      s/-\n.*//
+     ' >$as_me.lineno &&
+-  chmod +x $as_me.lineno ||
+-    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+-echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
++  chmod +x "$as_me.lineno" ||
++    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+    { (exit 1); exit 1; }; }
+   # Don't try to exec as it changes $[0], causing all sort of problems
+   # (the dirname of $[0] is not the place where we might find the
+-  # original and so on.  Autoconf is especially sensible to this).
+-  . ./$as_me.lineno
++  # original and so on.  Autoconf is especially sensitive to this).
++  . "./$as_me.lineno"
+   # Exit status is that of the last command.
+   exit
+ }
+-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+-  *c*,-n*) ECHO_N= ECHO_C='
+-' ECHO_T='    ' ;;
+-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
++  as_dirname=dirname
++else
++  as_dirname=false
++fi
++
++ECHO_C= ECHO_N= ECHO_T=
++case `echo -n x` in
++-n*)
++  case `echo 'x\c'` in
++  *c*) ECHO_T='       ';;     # ECHO_T is single tab character.
++  *)   ECHO_C='\c';;
++  esac;;
++*)
++  ECHO_N='-n';;
+ esac
+-if expr a : '\(a\)' >/dev/null 2>&1; then
++if expr a : '\(a\)' >/dev/null 2>&1 &&
++   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+   as_expr=expr
+ else
+   as_expr=false
+ fi
+ rm -f conf$$ conf$$.exe conf$$.file
++if test -d conf$$.dir; then
++  rm -f conf$$.dir/conf$$.file
++else
++  rm -f conf$$.dir
++  mkdir conf$$.dir
++fi
+ echo >conf$$.file
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+-  # We could just check for DJGPP; but this test a) works b) is more generic
+-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+-  if test -f conf$$.exe; then
+-    # Don't use ln at all; we don't have any links
++  as_ln_s='ln -s'
++  # ... but there are two gotchas:
++  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
++  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
++  # In both cases, we have to default to `cp -p'.
++  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+     as_ln_s='cp -p'
+-  else
+-    as_ln_s='ln -s'
+-  fi
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+   as_ln_s=ln
+ else
+   as_ln_s='cp -p'
+ fi
+-rm -f conf$$ conf$$.exe conf$$.file
++rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
++rmdir conf$$.dir 2>/dev/null
+ if mkdir -p . 2>/dev/null; then
+   as_mkdir_p=:
+@@ -9291,7 +9902,28 @@ else
+   as_mkdir_p=false
+ fi
+-as_executable_p="test -f"
++if test -x / >/dev/null 2>&1; then
++  as_test_x='test -x'
++else
++  if ls -dL / >/dev/null 2>&1; then
++    as_ls_L_option=L
++  else
++    as_ls_L_option=
++  fi
++  as_test_x='
++    eval sh -c '\''
++      if test -d "$1"; then
++        test -d "$1/.";
++      else
++      case $1 in
++        -*)set "./$1";;
++      esac;
++      case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
++      ???[sx]*):;;*)false;;esac;fi
++    '\'' sh
++  '
++fi
++as_executable_p=$as_test_x
+ # Sed expression to map a string onto a valid CPP name.
+ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+@@ -9300,31 +9932,14 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P
+ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+-# IFS
+-# We need space, tab and new line, in precisely that order.
+-as_nl='
+-'
+-IFS="         $as_nl"
+-
+-# CDPATH.
+-$as_unset CDPATH
+-
+ exec 6>&1
+-# Open the log real soon, to keep \$[0] and so on meaningful, and to
++# Save the log message, to keep $[0] and so on meaningful, and to
+ # report actual input values of CONFIG_FILES etc. instead of their
+-# values after options handling.  Logging --version etc. is OK.
+-exec 5>>config.log
+-{
+-  echo
+-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+-## Running $as_me. ##
+-_ASBOX
+-} >&5
+-cat >&5 <<_CSEOF
+-
++# values after options handling.
++ac_log="
+ This file was extended by $as_me, which was
+-generated by GNU Autoconf 2.59.  Invocation command line was
++generated by GNU Autoconf 2.61.  Invocation command line was
+   CONFIG_FILES    = $CONFIG_FILES
+   CONFIG_HEADERS  = $CONFIG_HEADERS
+@@ -9332,30 +9947,20 @@ generated by GNU Autoconf 2.59.  Invocat
+   CONFIG_COMMANDS = $CONFIG_COMMANDS
+   $ $0 $@
+-_CSEOF
+-echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+-echo >&5
++on `(hostname || uname -n) 2>/dev/null | sed 1q`
++"
++
+ _ACEOF
++cat >>$CONFIG_STATUS <<_ACEOF
+ # Files that config.status was made for.
+-if test -n "$ac_config_files"; then
+-  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_headers"; then
+-  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
+-fi
+-
+-if test -n "$ac_config_links"; then
+-  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
+-fi
++config_files="$ac_config_files"
++config_headers="$ac_config_headers"
++config_commands="$ac_config_commands"
+-if test -n "$ac_config_commands"; then
+-  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
+-fi
++_ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-
+ ac_cs_usage="\
+ \`$as_me' instantiates files from templates according to the
+ current configuration.
+@@ -9363,7 +9968,7 @@ current configuration.
+ Usage: $0 [OPTIONS] [FILE]...
+   -h, --help       print this help, then exit
+-  -V, --version    print version number, then exit
++  -V, --version    print version number and configuration settings, then exit
+   -q, --quiet      do not print progress messages
+   -d, --debug      don't remove temporary files
+       --recheck    update $as_me by reconfiguring in the same conditions
+@@ -9382,19 +9987,21 @@ Configuration commands:
+ $config_commands
+ Report bugs to <bug-autoconf@gnu.org>."
+-_ACEOF
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ ac_cs_version="\\
+ config.status
+-configured by $0, generated by GNU Autoconf 2.59,
+-  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
++configured by $0, generated by GNU Autoconf 2.61,
++  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
+-Copyright (C) 2003 Free Software Foundation, Inc.
++Copyright (C) 2006 Free Software Foundation, Inc.
+ This config.status script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it."
+-srcdir=$srcdir
+-INSTALL="$INSTALL"
++
++ac_pwd='$ac_pwd'
++srcdir='$srcdir'
++INSTALL='$INSTALL'
+ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+@@ -9405,39 +10012,24 @@ while test $# != 0
+ do
+   case $1 in
+   --*=*)
+-    ac_option=`expr "x$1" : 'x\([^=]*\)='`
+-    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
++    ac_option=`expr "X$1" : 'X\([^=]*\)='`
++    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+     ac_shift=:
+     ;;
+-  -*)
++  *)
+     ac_option=$1
+     ac_optarg=$2
+     ac_shift=shift
+     ;;
+-  *) # This is not an option, so the user has probably given explicit
+-     # arguments.
+-     ac_option=$1
+-     ac_need_defaults=false;;
+   esac
+   case $ac_option in
+   # Handling of the options.
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+     ac_cs_recheck=: ;;
+-  --version | --vers* | -V )
+-    echo "$ac_cs_version"; exit 0 ;;
+-  --he | --h)
+-    # Conflict between --help and --header
+-    { { echo "$as_me:$LINENO: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: ambiguous option: $1
+-Try \`$0 --help' for more information." >&2;}
+-   { (exit 1); exit 1; }; };;
+-  --help | --hel | -h )
+-    echo "$ac_cs_usage"; exit 0 ;;
+-  --debug | --d* | -d )
++  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
++    echo "$ac_cs_version"; exit ;;
++  --debug | --debu | --deb | --de | --d | -d )
+     debug=: ;;
+   --file | --fil | --fi | --f )
+     $ac_shift
+@@ -9447,18 +10039,24 @@ Try \`$0 --help' for more information." 
+     $ac_shift
+     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+     ac_need_defaults=false;;
++  --he | --h)
++    # Conflict between --help and --header
++    { echo "$as_me: error: ambiguous option: $1
++Try \`$0 --help' for more information." >&2
++   { (exit 1); exit 1; }; };;
++  --help | --hel | -h )
++    echo "$ac_cs_usage"; exit ;;
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil | --si | --s)
+     ac_cs_silent=: ;;
+   # This is an error.
+-  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&5
+-echo "$as_me: error: unrecognized option: $1
+-Try \`$0 --help' for more information." >&2;}
++  -*) { echo "$as_me: error: unrecognized option: $1
++Try \`$0 --help' for more information." >&2
+    { (exit 1); exit 1; }; } ;;
+-  *) ac_config_targets="$ac_config_targets $1" ;;
++  *) ac_config_targets="$ac_config_targets $1"
++     ac_need_defaults=false ;;
+   esac
+   shift
+@@ -9474,40 +10072,52 @@ fi
+ _ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ if \$ac_cs_recheck; then
+-  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
+-  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
++  echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
++  CONFIG_SHELL=$SHELL
++  export CONFIG_SHELL
++  exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+ fi
+ _ACEOF
++cat >>$CONFIG_STATUS <<\_ACEOF
++exec 5>>config.log
++{
++  echo
++  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
++## Running $as_me. ##
++_ASBOX
++  echo "$ac_log"
++} >&5
++_ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
+ #
+-# INIT-COMMANDS section.
++# INIT-COMMANDS
+ #
+-
+ AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+ _ACEOF
+-
+-
+ cat >>$CONFIG_STATUS <<\_ACEOF
++
++# Handling of arguments.
+ for ac_config_target in $ac_config_targets
+ do
+-  case "$ac_config_target" in
+-  # Handling of arguments.
+-  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+-  "po/Makefile.in" ) CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
+-  "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+-  "default" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
+-  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++  case $ac_config_target in
++    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
++    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
++    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
++    "po/Makefile.in") CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
++    "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
++
+   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+ echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+    { (exit 1); exit 1; }; };;
+   esac
+ done
++
+ # If the user did not use the arguments to specify the items to instantiate,
+ # then the envvar interface is used.  Set only those that are not.
+ # We use the long form for the default assignment because of an extremely
+@@ -9519,635 +10129,623 @@ if $ac_need_defaults; then
+ fi
+ # Have a temporary directory for convenience.  Make it in the build tree
+-# simply because there is no reason to put it here, and in addition,
++# simply because there is no reason against having it here, and in addition,
+ # creating and moving files from /tmp can sometimes cause problems.
+-# Create a temporary directory, and hook for its removal unless debugging.
++# Hook for its removal unless debugging.
++# Note that there is a small window in which the directory will not be cleaned:
++# after its creation but before its name has been assigned to `$tmp'.
+ $debug ||
+ {
+-  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
++  tmp=
++  trap 'exit_status=$?
++  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
++' 0
+   trap '{ (exit 1); exit 1; }' 1 2 13 15
+ }
+-
+ # Create a (secure) tmp directory for tmp files.
+ {
+-  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
++  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+   test -n "$tmp" && test -d "$tmp"
+ }  ||
+ {
+-  tmp=./confstat$$-$RANDOM
+-  (umask 077 && mkdir $tmp)
++  tmp=./conf$$-$RANDOM
++  (umask 077 && mkdir "$tmp")
+ } ||
+ {
+    echo "$me: cannot create a temporary directory in ." >&2
+    { (exit 1); exit 1; }
+ }
+-_ACEOF
+-
+-cat >>$CONFIG_STATUS <<_ACEOF
+-
+ #
+-# CONFIG_FILES section.
++# Set up the sed scripts for CONFIG_FILES section.
+ #
+ # No need to generate the scripts if there are no CONFIG_FILES.
+ # This happens for instance when ./config.status config.h
+-if test -n "\$CONFIG_FILES"; then
+-  # Protect against being on the right side of a sed subst in config.status.
+-  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
+-   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
+-s,@SHELL@,$SHELL,;t t
+-s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
+-s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
+-s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
+-s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
+-s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
+-s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
+-s,@exec_prefix@,$exec_prefix,;t t
+-s,@prefix@,$prefix,;t t
+-s,@program_transform_name@,$program_transform_name,;t t
+-s,@bindir@,$bindir,;t t
+-s,@sbindir@,$sbindir,;t t
+-s,@libexecdir@,$libexecdir,;t t
+-s,@datadir@,$datadir,;t t
+-s,@sysconfdir@,$sysconfdir,;t t
+-s,@sharedstatedir@,$sharedstatedir,;t t
+-s,@localstatedir@,$localstatedir,;t t
+-s,@libdir@,$libdir,;t t
+-s,@includedir@,$includedir,;t t
+-s,@oldincludedir@,$oldincludedir,;t t
+-s,@infodir@,$infodir,;t t
+-s,@mandir@,$mandir,;t t
+-s,@build_alias@,$build_alias,;t t
+-s,@host_alias@,$host_alias,;t t
+-s,@target_alias@,$target_alias,;t t
+-s,@DEFS@,$DEFS,;t t
+-s,@ECHO_C@,$ECHO_C,;t t
+-s,@ECHO_N@,$ECHO_N,;t t
+-s,@ECHO_T@,$ECHO_T,;t t
+-s,@LIBS@,$LIBS,;t t
+-s,@build@,$build,;t t
+-s,@build_cpu@,$build_cpu,;t t
+-s,@build_vendor@,$build_vendor,;t t
+-s,@build_os@,$build_os,;t t
+-s,@host@,$host,;t t
+-s,@host_cpu@,$host_cpu,;t t
+-s,@host_vendor@,$host_vendor,;t t
+-s,@host_os@,$host_os,;t t
+-s,@target@,$target,;t t
+-s,@target_cpu@,$target_cpu,;t t
+-s,@target_vendor@,$target_vendor,;t t
+-s,@target_os@,$target_os,;t t
+-s,@CC@,$CC,;t t
+-s,@CFLAGS@,$CFLAGS,;t t
+-s,@LDFLAGS@,$LDFLAGS,;t t
+-s,@CPPFLAGS@,$CPPFLAGS,;t t
+-s,@ac_ct_CC@,$ac_ct_CC,;t t
+-s,@EXEEXT@,$EXEEXT,;t t
+-s,@OBJEXT@,$OBJEXT,;t t
+-s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
+-s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
+-s,@INSTALL_DATA@,$INSTALL_DATA,;t t
+-s,@CYGPATH_W@,$CYGPATH_W,;t t
+-s,@PACKAGE@,$PACKAGE,;t t
+-s,@VERSION@,$VERSION,;t t
+-s,@ACLOCAL@,$ACLOCAL,;t t
+-s,@AUTOCONF@,$AUTOCONF,;t t
+-s,@AUTOMAKE@,$AUTOMAKE,;t t
+-s,@AUTOHEADER@,$AUTOHEADER,;t t
+-s,@MAKEINFO@,$MAKEINFO,;t t
+-s,@install_sh@,$install_sh,;t t
+-s,@STRIP@,$STRIP,;t t
+-s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
+-s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
+-s,@mkdir_p@,$mkdir_p,;t t
+-s,@AWK@,$AWK,;t t
+-s,@SET_MAKE@,$SET_MAKE,;t t
+-s,@am__leading_dot@,$am__leading_dot,;t t
+-s,@AMTAR@,$AMTAR,;t t
+-s,@am__tar@,$am__tar,;t t
+-s,@am__untar@,$am__untar,;t t
+-s,@DEPDIR@,$DEPDIR,;t t
+-s,@am__include@,$am__include,;t t
+-s,@am__quote@,$am__quote,;t t
+-s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
+-s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
+-s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
+-s,@CCDEPMODE@,$CCDEPMODE,;t t
+-s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
+-s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
+-s,@AR@,$AR,;t t
+-s,@ac_ct_AR@,$ac_ct_AR,;t t
+-s,@RANLIB@,$RANLIB,;t t
+-s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
+-s,@LN_S@,$LN_S,;t t
+-s,@LIBTOOL@,$LIBTOOL,;t t
+-s,@WARN_CFLAGS@,$WARN_CFLAGS,;t t
+-s,@NO_WERROR@,$NO_WERROR,;t t
+-s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
+-s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
+-s,@MAINT@,$MAINT,;t t
+-s,@INSTALL_LIBBFD_TRUE@,$INSTALL_LIBBFD_TRUE,;t t
+-s,@INSTALL_LIBBFD_FALSE@,$INSTALL_LIBBFD_FALSE,;t t
+-s,@host_noncanonical@,$host_noncanonical,;t t
+-s,@target_noncanonical@,$target_noncanonical,;t t
+-s,@bfdlibdir@,$bfdlibdir,;t t
+-s,@bfdincludedir@,$bfdincludedir,;t t
+-s,@CPP@,$CPP,;t t
+-s,@EGREP@,$EGREP,;t t
+-s,@ALLOCA@,$ALLOCA,;t t
+-s,@USE_NLS@,$USE_NLS,;t t
+-s,@MSGFMT@,$MSGFMT,;t t
+-s,@GMSGFMT@,$GMSGFMT,;t t
+-s,@XGETTEXT@,$XGETTEXT,;t t
+-s,@USE_INCLUDED_LIBINTL@,$USE_INCLUDED_LIBINTL,;t t
+-s,@CATALOGS@,$CATALOGS,;t t
+-s,@CATOBJEXT@,$CATOBJEXT,;t t
+-s,@DATADIRNAME@,$DATADIRNAME,;t t
+-s,@GMOFILES@,$GMOFILES,;t t
+-s,@INSTOBJEXT@,$INSTOBJEXT,;t t
+-s,@INTLDEPS@,$INTLDEPS,;t t
+-s,@INTLLIBS@,$INTLLIBS,;t t
+-s,@INTLOBJS@,$INTLOBJS,;t t
+-s,@POFILES@,$POFILES,;t t
+-s,@POSUB@,$POSUB,;t t
+-s,@INCLUDE_LOCALE_H@,$INCLUDE_LOCALE_H,;t t
+-s,@GT_NO@,$GT_NO,;t t
+-s,@GT_YES@,$GT_YES,;t t
+-s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t
+-s,@l@,$l,;t t
+-s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
+-s,@EXEEXT_FOR_BUILD@,$EXEEXT_FOR_BUILD,;t t
+-s,@HDEFINES@,$HDEFINES,;t t
+-s,@CGEN_MAINT_TRUE@,$CGEN_MAINT_TRUE,;t t
+-s,@CGEN_MAINT_FALSE@,$CGEN_MAINT_FALSE,;t t
+-s,@cgendir@,$cgendir,;t t
+-s,@WIN32LDFLAGS@,$WIN32LDFLAGS,;t t
+-s,@WIN32LIBADD@,$WIN32LIBADD,;t t
+-s,@archdefs@,$archdefs,;t t
+-s,@BFD_MACHINES@,$BFD_MACHINES,;t t
+-s,@LIBOBJS@,$LIBOBJS,;t t
+-s,@LTLIBOBJS@,$LTLIBOBJS,;t t
+-CEOF
+-
+-_ACEOF
+-
+-  cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Split the substitutions into bite-sized pieces for seds with
+-  # small command number limits, like on Digital OSF/1 and HP-UX.
+-  ac_max_sed_lines=48
+-  ac_sed_frag=1 # Number of current file.
+-  ac_beg=1 # First line for current file.
+-  ac_end=$ac_max_sed_lines # Line after last line for current file.
+-  ac_more_lines=:
+-  ac_sed_cmds=
+-  while $ac_more_lines; do
+-    if test $ac_beg -gt 1; then
+-      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    else
+-      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+-    fi
+-    if test ! -s $tmp/subs.frag; then
+-      ac_more_lines=false
+-    else
+-      # The purpose of the label and of the branching condition is to
+-      # speed up the sed processing (if there are no `@' at all, there
+-      # is no need to browse any of the substitutions).
+-      # These are the two extra sed commands mentioned above.
+-      (echo ':t
+-  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
+-      if test -z "$ac_sed_cmds"; then
+-      ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
+-      else
+-      ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
+-      fi
+-      ac_sed_frag=`expr $ac_sed_frag + 1`
+-      ac_beg=$ac_end
+-      ac_end=`expr $ac_end + $ac_max_sed_lines`
+-    fi
+-  done
+-  if test -z "$ac_sed_cmds"; then
+-    ac_sed_cmds=cat
++if test -n "$CONFIG_FILES"; then
++
++_ACEOF
++
++
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++SHELL!$SHELL$ac_delim
++PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim
++PACKAGE_NAME!$PACKAGE_NAME$ac_delim
++PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim
++PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim
++PACKAGE_STRING!$PACKAGE_STRING$ac_delim
++PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim
++exec_prefix!$exec_prefix$ac_delim
++prefix!$prefix$ac_delim
++program_transform_name!$program_transform_name$ac_delim
++bindir!$bindir$ac_delim
++sbindir!$sbindir$ac_delim
++libexecdir!$libexecdir$ac_delim
++datarootdir!$datarootdir$ac_delim
++datadir!$datadir$ac_delim
++sysconfdir!$sysconfdir$ac_delim
++sharedstatedir!$sharedstatedir$ac_delim
++localstatedir!$localstatedir$ac_delim
++includedir!$includedir$ac_delim
++oldincludedir!$oldincludedir$ac_delim
++docdir!$docdir$ac_delim
++infodir!$infodir$ac_delim
++htmldir!$htmldir$ac_delim
++dvidir!$dvidir$ac_delim
++pdfdir!$pdfdir$ac_delim
++psdir!$psdir$ac_delim
++libdir!$libdir$ac_delim
++localedir!$localedir$ac_delim
++mandir!$mandir$ac_delim
++DEFS!$DEFS$ac_delim
++ECHO_C!$ECHO_C$ac_delim
++ECHO_N!$ECHO_N$ac_delim
++ECHO_T!$ECHO_T$ac_delim
++LIBS!$LIBS$ac_delim
++build_alias!$build_alias$ac_delim
++host_alias!$host_alias$ac_delim
++target_alias!$target_alias$ac_delim
++build!$build$ac_delim
++build_cpu!$build_cpu$ac_delim
++build_vendor!$build_vendor$ac_delim
++build_os!$build_os$ac_delim
++host!$host$ac_delim
++host_cpu!$host_cpu$ac_delim
++host_vendor!$host_vendor$ac_delim
++host_os!$host_os$ac_delim
++target!$target$ac_delim
++target_cpu!$target_cpu$ac_delim
++target_vendor!$target_vendor$ac_delim
++target_os!$target_os$ac_delim
++CC!$CC$ac_delim
++CFLAGS!$CFLAGS$ac_delim
++LDFLAGS!$LDFLAGS$ac_delim
++CPPFLAGS!$CPPFLAGS$ac_delim
++ac_ct_CC!$ac_ct_CC$ac_delim
++EXEEXT!$EXEEXT$ac_delim
++OBJEXT!$OBJEXT$ac_delim
++INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
++INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim
++INSTALL_DATA!$INSTALL_DATA$ac_delim
++CYGPATH_W!$CYGPATH_W$ac_delim
++PACKAGE!$PACKAGE$ac_delim
++VERSION!$VERSION$ac_delim
++ACLOCAL!$ACLOCAL$ac_delim
++AUTOCONF!$AUTOCONF$ac_delim
++AUTOMAKE!$AUTOMAKE$ac_delim
++AUTOHEADER!$AUTOHEADER$ac_delim
++MAKEINFO!$MAKEINFO$ac_delim
++install_sh!$install_sh$ac_delim
++STRIP!$STRIP$ac_delim
++INSTALL_STRIP_PROGRAM!$INSTALL_STRIP_PROGRAM$ac_delim
++mkdir_p!$mkdir_p$ac_delim
++AWK!$AWK$ac_delim
++SET_MAKE!$SET_MAKE$ac_delim
++am__leading_dot!$am__leading_dot$ac_delim
++AMTAR!$AMTAR$ac_delim
++am__tar!$am__tar$ac_delim
++am__untar!$am__untar$ac_delim
++DEPDIR!$DEPDIR$ac_delim
++am__include!$am__include$ac_delim
++am__quote!$am__quote$ac_delim
++AMDEP_TRUE!$AMDEP_TRUE$ac_delim
++AMDEP_FALSE!$AMDEP_FALSE$ac_delim
++AMDEPBACKSLASH!$AMDEPBACKSLASH$ac_delim
++CCDEPMODE!$CCDEPMODE$ac_delim
++am__fastdepCC_TRUE!$am__fastdepCC_TRUE$ac_delim
++am__fastdepCC_FALSE!$am__fastdepCC_FALSE$ac_delim
++AR!$AR$ac_delim
++RANLIB!$RANLIB$ac_delim
++LN_S!$LN_S$ac_delim
++LIBTOOL!$LIBTOOL$ac_delim
++WARN_CFLAGS!$WARN_CFLAGS$ac_delim
++NO_WERROR!$NO_WERROR$ac_delim
++MAINTAINER_MODE_TRUE!$MAINTAINER_MODE_TRUE$ac_delim
++MAINTAINER_MODE_FALSE!$MAINTAINER_MODE_FALSE$ac_delim
++MAINT!$MAINT$ac_delim
++INSTALL_LIBBFD_TRUE!$INSTALL_LIBBFD_TRUE$ac_delim
++INSTALL_LIBBFD_FALSE!$INSTALL_LIBBFD_FALSE$ac_delim
++_ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+   fi
+-fi # test -n "$CONFIG_FILES"
++done
++
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
++_ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++CEOF$ac_eof
++_ACEOF
++
++ac_delim='%!_!# '
++for ac_last_try in false false false false false :; do
++  cat >conf$$subs.sed <<_ACEOF
++host_noncanonical!$host_noncanonical$ac_delim
++target_noncanonical!$target_noncanonical$ac_delim
++bfdlibdir!$bfdlibdir$ac_delim
++bfdincludedir!$bfdincludedir$ac_delim
++CPP!$CPP$ac_delim
++GREP!$GREP$ac_delim
++EGREP!$EGREP$ac_delim
++ALLOCA!$ALLOCA$ac_delim
++USE_NLS!$USE_NLS$ac_delim
++MSGFMT!$MSGFMT$ac_delim
++GMSGFMT!$GMSGFMT$ac_delim
++XGETTEXT!$XGETTEXT$ac_delim
++USE_INCLUDED_LIBINTL!$USE_INCLUDED_LIBINTL$ac_delim
++CATALOGS!$CATALOGS$ac_delim
++CATOBJEXT!$CATOBJEXT$ac_delim
++DATADIRNAME!$DATADIRNAME$ac_delim
++GMOFILES!$GMOFILES$ac_delim
++INSTOBJEXT!$INSTOBJEXT$ac_delim
++INTLDEPS!$INTLDEPS$ac_delim
++INTLLIBS!$INTLLIBS$ac_delim
++INTLOBJS!$INTLOBJS$ac_delim
++POFILES!$POFILES$ac_delim
++POSUB!$POSUB$ac_delim
++INCLUDE_LOCALE_H!$INCLUDE_LOCALE_H$ac_delim
++GT_NO!$GT_NO$ac_delim
++GT_YES!$GT_YES$ac_delim
++MKINSTALLDIRS!$MKINSTALLDIRS$ac_delim
++l!$l$ac_delim
++CC_FOR_BUILD!$CC_FOR_BUILD$ac_delim
++EXEEXT_FOR_BUILD!$EXEEXT_FOR_BUILD$ac_delim
++HDEFINES!$HDEFINES$ac_delim
++CGEN_MAINT_TRUE!$CGEN_MAINT_TRUE$ac_delim
++CGEN_MAINT_FALSE!$CGEN_MAINT_FALSE$ac_delim
++cgendir!$cgendir$ac_delim
++WIN32LDFLAGS!$WIN32LDFLAGS$ac_delim
++WIN32LIBADD!$WIN32LIBADD$ac_delim
++archdefs!$archdefs$ac_delim
++BFD_MACHINES!$BFD_MACHINES$ac_delim
++LIBOBJS!$LIBOBJS$ac_delim
++LTLIBOBJS!$LTLIBOBJS$ac_delim
++_ACEOF
++
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 40; then
++    break
++  elif $ac_last_try; then
++    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
++echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
++   { (exit 1); exit 1; }; }
++  else
++    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
++  fi
++done
++
++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
++if test -n "$ac_eof"; then
++  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
++  ac_eof=`expr $ac_eof + 1`
++fi
++
++cat >>$CONFIG_STATUS <<_ACEOF
++cat >"\$tmp/subs-2.sed" <<\CEOF$ac_eof
++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end
+ _ACEOF
++sed '
++s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
++s/^/s,@/; s/!/@,|#_!!_#|/
++:n
++t n
++s/'"$ac_delim"'$/,g/; t
++s/$/\\/; p
++N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
++' >>$CONFIG_STATUS <conf$$subs.sed
++rm -f conf$$subs.sed
++cat >>$CONFIG_STATUS <<_ACEOF
++:end
++s/|#_!!_#|//g
++CEOF$ac_eof
++_ACEOF
++
++
++# VPATH may cause trouble with some makes, so we remove $(srcdir),
++# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
++# trailing colons and then remove the whole line if VPATH becomes empty
++# (actually we leave an empty line to preserve line numbers).
++if test "x$srcdir" = x.; then
++  ac_vpsub='/^[        ]*VPATH[        ]*=/{
++s/:*\$(srcdir):*/:/
++s/:*\${srcdir}:*/:/
++s/:*@srcdir@:*/:/
++s/^\([^=]*=[   ]*\):*/\1/
++s/:*$//
++s/^[^=]*=[     ]*$//
++}'
++fi
++
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+-  case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++fi # test -n "$CONFIG_FILES"
++
++
++for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS
++do
++  case $ac_tag in
++  :[FHLC]) ac_mode=$ac_tag; continue;;
++  esac
++  case $ac_mode$ac_tag in
++  :[FHL]*:*);;
++  :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
++echo "$as_me: error: Invalid tag $ac_tag." >&2;}
++   { (exit 1); exit 1; }; };;
++  :[FH]-) ac_tag=-:-;;
++  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+   esac
++  ac_save_IFS=$IFS
++  IFS=:
++  set x $ac_tag
++  IFS=$ac_save_IFS
++  shift
++  ac_file=$1
++  shift
++
++  case $ac_mode in
++  :L) ac_source=$1;;
++  :[FH])
++    ac_file_inputs=
++    for ac_f
++    do
++      case $ac_f in
++      -) ac_f="$tmp/stdin";;
++      *) # Look for the file first in the build tree, then in the source tree
++       # (if the path is not absolute).  The absolute path cannot be DOS-style,
++       # because $ac_f cannot contain `:'.
++       test -f "$ac_f" ||
++         case $ac_f in
++         [\\/$]*) false;;
++         *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
++         esac ||
++         { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
++echo "$as_me: error: cannot find input file: $ac_f" >&2;}
++   { (exit 1); exit 1; }; };;
++      esac
++      ac_file_inputs="$ac_file_inputs $ac_f"
++    done
++
++    # Let's still pretend it is `configure' which instantiates (i.e., don't
++    # use $as_me), people would be surprised to read:
++    #    /* config.h.  Generated by config.status.  */
++    configure_input="Generated from "`IFS=:
++        echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."
++    if test x"$ac_file" != x-; then
++      configure_input="$ac_file.  $configure_input"
++      { echo "$as_me:$LINENO: creating $ac_file" >&5
++echo "$as_me: creating $ac_file" >&6;}
++    fi
+-  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
+-  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
++    case $ac_tag in
++    *:-:* | *:-) cat >"$tmp/stdin";;
++    esac
++    ;;
++  esac
++
++  ac_dir=`$as_dirname -- "$ac_file" ||
+ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$ac_file" : 'X\(//\)[^/]' \| \
+        X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++  { as_dir="$ac_dir"
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+   ac_builddir=.
+-if test "$ac_dir" != .; then
++case "$ac_dir" in
++.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
++*)
+   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
++  # A ".." for each directory in $ac_dir_suffix.
++  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
++  case $ac_top_builddir_sub in
++  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
++  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
++  esac ;;
++esac
++ac_abs_top_builddir=$ac_pwd
++ac_abs_builddir=$ac_pwd$ac_dir_suffix
++# for backward compatibility:
++ac_top_builddir=$ac_top_build_prefix
+ case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
++  .)  # We are building in place.
+     ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
++    ac_top_srcdir=$ac_top_builddir_sub
++    ac_abs_top_srcdir=$ac_pwd ;;
++  [\\/]* | ?:[\\/]* )  # Absolute name.
+     ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    ac_top_srcdir=$srcdir
++    ac_abs_top_srcdir=$srcdir ;;
++  *) # Relative name.
++    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
++    ac_top_srcdir=$ac_top_build_prefix$srcdir
++    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
++esac
++ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  case $ac_mode in
++  :F)
++  #
++  # CONFIG_FILE
++  #
+   case $INSTALL in
+   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+-  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
++  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+   esac
++_ACEOF
+-  if test x"$ac_file" != x-; then
+-    { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-    rm -f "$ac_file"
+-  fi
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    configure_input=
+-  else
+-    configure_input="$ac_file.  "
+-  fi
+-  configure_input=$configure_input"Generated from `echo $ac_file_in |
+-                                   sed 's,.*/,,'` by configure."
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
++cat >>$CONFIG_STATUS <<\_ACEOF
++# If the template does not know about datarootdir, expand it.
++# FIXME: This hack should be removed a few years after 2.60.
++ac_datarootdir_hack=; ac_datarootdir_seen=
++
++case `sed -n '/datarootdir/ {
++  p
++  q
++}
++/@datadir@/p
++/@docdir@/p
++/@infodir@/p
++/@localedir@/p
++/@mandir@/p
++' $ac_file_inputs` in
++*datarootdir*) ac_datarootdir_seen=yes;;
++*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
++  { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
++echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+ _ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF
++  ac_datarootdir_hack='
++  s&@datadir@&$datadir&g
++  s&@docdir@&$docdir&g
++  s&@infodir@&$infodir&g
++  s&@localedir@&$localedir&g
++  s&@mandir@&$mandir&g
++    s&\\\${datarootdir}&$datarootdir&g' ;;
++esac
++_ACEOF
++
++# Neutralize VPATH when `$srcdir' = `.'.
++# Shell code in configure.ac might set extrasub.
++# FIXME: do we really want to maintain this feature?
++cat >>$CONFIG_STATUS <<_ACEOF
+   sed "$ac_vpsub
+ $extrasub
+ _ACEOF
+ cat >>$CONFIG_STATUS <<\_ACEOF
+ :t
+ /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+-s,@configure_input@,$configure_input,;t t
+-s,@srcdir@,$ac_srcdir,;t t
+-s,@abs_srcdir@,$ac_abs_srcdir,;t t
+-s,@top_srcdir@,$ac_top_srcdir,;t t
+-s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+-s,@builddir@,$ac_builddir,;t t
+-s,@abs_builddir@,$ac_abs_builddir,;t t
+-s,@top_builddir@,$ac_top_builddir,;t t
+-s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
+-s,@INSTALL@,$ac_INSTALL,;t t
+-" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
+-  rm -f $tmp/stdin
+-  if test x"$ac_file" != x-; then
+-    mv $tmp/out $ac_file
+-  else
+-    cat $tmp/out
+-    rm -f $tmp/out
+-  fi
++s&@configure_input@&$configure_input&;t t
++s&@top_builddir@&$ac_top_builddir_sub&;t t
++s&@srcdir@&$ac_srcdir&;t t
++s&@abs_srcdir@&$ac_abs_srcdir&;t t
++s&@top_srcdir@&$ac_top_srcdir&;t t
++s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
++s&@builddir@&$ac_builddir&;t t
++s&@abs_builddir@&$ac_abs_builddir&;t t
++s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
++s&@INSTALL@&$ac_INSTALL&;t t
++$ac_datarootdir_hack
++" $ac_file_inputs | sed -f "$tmp/subs-1.sed" | sed -f "$tmp/subs-2.sed" >$tmp/out
++
++test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
++  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
++  { ac_out=`sed -n '/^[        ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
++  { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&5
++echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++which seems to be undefined.  Please make sure it is defined." >&2;}
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_HEADER section.
+-#
+-
+-# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
+-# NAME is the cpp macro being defined and VALUE is the value it is being given.
+-#
+-# ac_d sets the value in "#define NAME VALUE" lines.
+-ac_dA='s,^\([  ]*\)#\([        ]*define[       ][      ]*\)'
+-ac_dB='[       ].*$,\1#\2'
+-ac_dC=' '
+-ac_dD=',;t'
+-# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
+-ac_uA='s,^\([  ]*\)#\([        ]*\)undef\([    ][      ]*\)'
+-ac_uB='$,\1#\2define\3'
+-ac_uC=' '
+-ac_uD=',;t'
+-
+-for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
+-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
++  rm -f "$tmp/stdin"
+   case $ac_file in
+-  - | *:- | *:-:* ) # input from stdin
+-      cat >$tmp/stdin
+-      ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-      ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+-  * )   ac_file_in=$ac_file.in ;;
++  -) cat "$tmp/out"; rm -f "$tmp/out";;
++  *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;
+   esac
++ ;;
++  :H)
++  #
++  # CONFIG_HEADER
++  #
++_ACEOF
++
++# Transform confdefs.h into a sed script `conftest.defines', that
++# substitutes the proper values into config.h.in to produce config.h.
++rm -f conftest.defines conftest.tail
++# First, append a space to every undef/define line, to ease matching.
++echo 's/$/ /' >conftest.defines
++# Then, protect against being on the right side of a sed subst, or in
++# an unquoted here document, in config.status.  If some macros were
++# called several times there might be several #defines for the same
++# symbol, which is useless.  But do not sort them, since the last
++# AC_DEFINE must be honored.
++ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
++# These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where
++# NAME is the cpp macro being defined, VALUE is the value it is being given.
++# PARAMS is the parameter list in the macro definition--in most cases, it's
++# just an empty string.
++ac_dA='s,^\\([         #]*\\)[^        ]*\\([  ]*'
++ac_dB='\\)[    (].*,\\1define\\2'
++ac_dC=' '
++ac_dD=' ,'
+-  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
+-echo "$as_me: creating $ac_file" >&6;}
+-
+-  # First look for the input files in the build tree, otherwise in the
+-  # src tree.
+-  ac_file_inputs=`IFS=:
+-    for f in $ac_file_in; do
+-      case $f in
+-      -) echo $tmp/stdin ;;
+-      [\\/$]*)
+-       # Absolute (can't be DOS-style, as IFS=:)
+-       test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       # Do quote $f, to prevent DOS paths from being IFS'd.
+-       echo "$f";;
+-      *) # Relative
+-       if test -f "$f"; then
+-         # Build tree
+-         echo "$f"
+-       elif test -f "$srcdir/$f"; then
+-         # Source tree
+-         echo "$srcdir/$f"
+-       else
+-         # /dev/null tree
+-         { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+-echo "$as_me: error: cannot find input file: $f" >&2;}
+-   { (exit 1); exit 1; }; }
+-       fi;;
+-      esac
+-    done` || { (exit 1); exit 1; }
+-  # Remove the trailing spaces.
+-  sed 's/[     ]*$//' $ac_file_inputs >$tmp/in
+-
+-_ACEOF
++uniq confdefs.h |
++  sed -n '
++      t rset
++      :rset
++      s/^[     ]*#[    ]*define[       ][      ]*//
++      t ok
++      d
++      :ok
++      s/[\\&,]/\\&/g
++      s/^\('"$ac_word_re"'\)\(([^()]*)\)[      ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p
++      s/^\('"$ac_word_re"'\)[  ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p
++  ' >>conftest.defines
+-# Transform confdefs.h into two sed scripts, `conftest.defines' and
+-# `conftest.undefs', that substitutes the proper values into
+-# config.h.in to produce config.h.  The first handles `#define'
+-# templates, and the second `#undef' templates.
+-# And first: Protect against being on the right side of a sed subst in
+-# config.status.  Protect against being in an unquoted here document
+-# in config.status.
+-rm -f conftest.defines conftest.undefs
+-# Using a here document instead of a string reduces the quoting nightmare.
+-# Putting comments in sed scripts is not portable.
+-#
+-# `end' is used to avoid that the second main sed command (meant for
+-# 0-ary CPP macros) applies to n-ary macro definitions.
+-# See the Autoconf documentation for `clear'.
+-cat >confdef2sed.sed <<\_ACEOF
+-s/[\\&,]/\\&/g
+-s,[\\$`],\\&,g
+-t clear
+-: clear
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
+-t end
+-s,^[   ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
+-: end
+-_ACEOF
+-# If some macros were called several times there might be several times
+-# the same #defines, which is useless.  Nevertheless, we may not want to
+-# sort them, since we want the *last* AC-DEFINE to be honored.
+-uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
+-sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
+-rm -f confdef2sed.sed
+-
+-# This sed command replaces #undef with comments.  This is necessary, for
++# Remove the space that was appended to ease matching.
++# Then replace #undef with comments.  This is necessary, for
+ # example, in the case of _POSIX_SOURCE, which is predefined and required
+ # on some systems where configure will not decide to define it.
+-cat >>conftest.undefs <<\_ACEOF
+-s,^[   ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
++# (The regexp can be short, since the line contains either #define or #undef.)
++echo 's/ $//
++s,^[   #]*u.*,/* & */,' >>conftest.defines
++
++# Break up conftest.defines:
++ac_max_sed_lines=50
++
++# First sed command is:        sed -f defines.sed $ac_file_inputs >"$tmp/out1"
++# Second one is:       sed -f defines.sed "$tmp/out1" >"$tmp/out2"
++# Third one will be:   sed -f defines.sed "$tmp/out2" >"$tmp/out1"
++# et cetera.
++ac_in='$ac_file_inputs'
++ac_out='"$tmp/out1"'
++ac_nxt='"$tmp/out2"'
++
++while :
++do
++  # Write a here document:
++    cat >>$CONFIG_STATUS <<_ACEOF
++    # First, check the format of the line:
++    cat >"\$tmp/defines.sed" <<\\CEOF
++/^[    ]*#[    ]*undef[        ][      ]*$ac_word_re[  ]*\$/b def
++/^[    ]*#[    ]*define[       ][      ]*$ac_word_re[(         ]/b def
++b
++:def
+ _ACEOF
+-
+-# Break up conftest.defines because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
+-echo '  if grep "^[    ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
+-echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
+-echo '  :' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.defines >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/defines.sed.
+-  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#define' lines.
+-  echo '/^[    ]*#[    ]*define/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
++  sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS
+   echo 'CEOF
+-  sed -f $tmp/defines.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
++    sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS
++  ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in
++  sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail
++  grep . conftest.tail >/dev/null || break
+   rm -f conftest.defines
+   mv conftest.tail conftest.defines
+ done
+-rm -f conftest.defines
+-echo '  fi # grep' >>$CONFIG_STATUS
+-echo >>$CONFIG_STATUS
+-
+-# Break up conftest.undefs because some shells have a limit on the size
+-# of here documents, and old seds have small limits too (100 cmds).
+-echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
+-rm -f conftest.tail
+-while grep . conftest.undefs >/dev/null
+-do
+-  # Write a limited-size here document to $tmp/undefs.sed.
+-  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
+-  # Speed up: don't consider the non `#undef'
+-  echo '/^[    ]*#[    ]*undef/!b' >>$CONFIG_STATUS
+-  # Work around the forget-to-reset-the-flag bug.
+-  echo 't clr' >>$CONFIG_STATUS
+-  echo ': clr' >>$CONFIG_STATUS
+-  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
+-  echo 'CEOF
+-  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
+-  rm -f $tmp/in
+-  mv $tmp/out $tmp/in
+-' >>$CONFIG_STATUS
+-  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
+-  rm -f conftest.undefs
+-  mv conftest.tail conftest.undefs
+-done
+-rm -f conftest.undefs
++rm -f conftest.defines conftest.tail
++echo "ac_result=$ac_in" >>$CONFIG_STATUS
+ cat >>$CONFIG_STATUS <<\_ACEOF
+-  # Let's still pretend it is `configure' which instantiates (i.e., don't
+-  # use $as_me), people would be surprised to read:
+-  #    /* config.h.  Generated by config.status.  */
+-  if test x"$ac_file" = x-; then
+-    echo "/* Generated by configure.  */" >$tmp/config.h
+-  else
+-    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
+-  fi
+-  cat $tmp/in >>$tmp/config.h
+-  rm -f $tmp/in
+   if test x"$ac_file" != x-; then
+-    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
++    echo "/* $configure_input  */" >"$tmp/config.h"
++    cat "$ac_result" >>"$tmp/config.h"
++    if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then
+       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
+ echo "$as_me: $ac_file is unchanged" >&6;}
+     else
+-      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_file" : 'X\(//\)[^/]' \| \
+-       X"$ac_file" : 'X\(//\)$' \| \
+-       X"$ac_file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-      { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+       rm -f $ac_file
+-      mv $tmp/config.h $ac_file
++      mv "$tmp/config.h" $ac_file
+     fi
+   else
+-    cat $tmp/config.h
+-    rm -f $tmp/config.h
++    echo "/* $configure_input  */"
++    cat "$ac_result"
+   fi
++  rm -f "$tmp/out12"
+ # Compute $ac_file's index in $config_headers.
+ _am_stamp_count=1
+ for _am_header in $config_headers :; do
+@@ -10158,135 +10756,39 @@ for _am_header in $config_headers :; do
+       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+   esac
+ done
+-echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
++echo "timestamp for $ac_file" >`$as_dirname -- $ac_file ||
+ $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X$ac_file : 'X\(//\)[^/]' \| \
+        X$ac_file : 'X\(//\)$' \| \
+-       X$ac_file : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X$ac_file : 'X\(/\)' \| . 2>/dev/null ||
+ echo X$ac_file |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`/stamp-h$_am_stamp_count
+-done
+-_ACEOF
+-cat >>$CONFIG_STATUS <<\_ACEOF
+-
+-#
+-# CONFIG_COMMANDS section.
+-#
+-for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
+-  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
+-  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
+-  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
+-$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$ac_dest" : 'X\(//\)[^/]' \| \
+-       X"$ac_dest" : 'X\(//\)$' \| \
+-       X"$ac_dest" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$ac_dest" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-  { if $as_mkdir_p; then
+-    mkdir -p "$ac_dir"
+-  else
+-    as_dir="$ac_dir"
+-    as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+-       X"$as_dir" : 'X\(//\)[^/]' \| \
+-       X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
+-echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+-   { (exit 1); exit 1; }; }; }
+-
+-  ac_builddir=.
+-
+-if test "$ac_dir" != .; then
+-  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+-  # A "../" for each directory in $ac_dir_suffix.
+-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+-else
+-  ac_dir_suffix= ac_top_builddir=
+-fi
+-
+-case $srcdir in
+-  .)  # No --srcdir option.  We are building in place.
+-    ac_srcdir=.
+-    if test -z "$ac_top_builddir"; then
+-       ac_top_srcdir=.
+-    else
+-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+-    fi ;;
+-  [\\/]* | ?:[\\/]* )  # Absolute path.
+-    ac_srcdir=$srcdir$ac_dir_suffix;
+-    ac_top_srcdir=$srcdir ;;
+-  *) # Relative path.
+-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+-esac
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`/stamp-h$_am_stamp_count
++ ;;
+-# Do not use `cd foo && pwd` to compute absolute paths, because
+-# the directories may not exist.
+-case `pwd` in
+-.) ac_abs_builddir="$ac_dir";;
+-*)
+-  case "$ac_dir" in
+-  .) ac_abs_builddir=`pwd`;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_builddir=${ac_top_builddir}.;;
+-*)
+-  case ${ac_top_builddir}. in
+-  .) ac_abs_top_builddir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_srcdir=$ac_srcdir;;
+-*)
+-  case $ac_srcdir in
+-  .) ac_abs_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+-  esac;;
+-esac
+-case $ac_abs_builddir in
+-.) ac_abs_top_srcdir=$ac_top_srcdir;;
+-*)
+-  case $ac_top_srcdir in
+-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+-  esac;;
+-esac
++  :C)  { echo "$as_me:$LINENO: executing $ac_file commands" >&5
++echo "$as_me: executing $ac_file commands" >&6;}
++ ;;
++  esac
+-  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
+-echo "$as_me: executing $ac_dest commands" >&6;}
+-  case $ac_dest in
+-    depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
++  case $ac_file$ac_mode in
++    "depfiles":C) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
+   # Strip MF so we end up with the name of the file.
+   mf=`echo "$mf" | sed -e 's/:.*$//'`
+   # Check whether this is an Automake generated Makefile or not.
+@@ -10296,18 +10798,29 @@ echo "$as_me: executing $ac_dest command
+   # each Makefile.in and add a new line on top of each file to say so.
+   # So let's grep whole file.
+   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
+-    dirpart=`(dirname "$mf") 2>/dev/null ||
++    dirpart=`$as_dirname -- "$mf" ||
+ $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$mf" : 'X\(//\)[^/]' \| \
+        X"$mf" : 'X\(//\)$' \| \
+-       X"$mf" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$mf" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
+   else
+     continue
+   fi
+@@ -10329,54 +10842,80 @@ echo X"$mf" |
+        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+     # Make sure the directory exists.
+     test -f "$dirpart/$file" && continue
+-    fdir=`(dirname "$file") 2>/dev/null ||
++    fdir=`$as_dirname -- "$file" ||
+ $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$file" : 'X\(//\)[^/]' \| \
+        X"$file" : 'X\(//\)$' \| \
+-       X"$file" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$file" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$file" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
+-    { if $as_mkdir_p; then
+-    mkdir -p $dirpart/$fdir
+-  else
+-    as_dir=$dirpart/$fdir
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++    { as_dir=$dirpart/$fdir
++  case $as_dir in #(
++  -*) as_dir=./$as_dir;;
++  esac
++  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+     as_dirs=
+-    while test ! -d "$as_dir"; do
+-      as_dirs="$as_dir $as_dirs"
+-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
++    while :; do
++      case $as_dir in #(
++      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
++      *) as_qdir=$as_dir;;
++      esac
++      as_dirs="'$as_qdir' $as_dirs"
++      as_dir=`$as_dirname -- "$as_dir" ||
+ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+        X"$as_dir" : 'X\(//\)[^/]' \| \
+        X"$as_dir" : 'X\(//\)$' \| \
+-       X"$as_dir" : 'X\(/\)' \| \
+-       .     : '\(.\)' 2>/dev/null ||
++       X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$as_dir" |
+-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+-        /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+-        /^X\(\/\/\)$/{ s//\1/; q; }
+-        /^X\(\/\).*/{ s//\1/; q; }
+-        s/.*/./; q'`
++    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)[^/].*/{
++          s//\1/
++          q
++        }
++        /^X\(\/\/\)$/{
++          s//\1/
++          q
++        }
++        /^X\(\/\).*/{
++          s//\1/
++          q
++        }
++        s/.*/./; q'`
++      test -d "$as_dir" && break
+     done
+-    test ! -n "$as_dirs" || mkdir $as_dirs
+-  fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
+-echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
++    test -z "$as_dirs" || eval "mkdir $as_dirs"
++  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
++echo "$as_me: error: cannot create directory $as_dir" >&2;}
+    { (exit 1); exit 1; }; }; }
+-
+     # echo "creating $dirpart/$file"
+     echo '# dummy' > "$dirpart/$file"
+   done
+ done
+  ;;
+-    default ) sed -e '/POTFILES =/r po/POTFILES' po/Makefile.in > po/Makefile ;;
++    "default":C) sed -e '/POTFILES =/r po/POTFILES' po/Makefile.in > po/Makefile ;;
++
+   esac
+-done
+-_ACEOF
++done # for ac_tag
+-cat >>$CONFIG_STATUS <<\_ACEOF
+ { (exit 0); exit 0; }
+ _ACEOF
+diff -Nrup binutils-2.17/opcodes/configure.in binutils-2.17-atmel/opcodes/configure.in
+--- binutils-2.17/opcodes/configure.in 2006-02-17 15:36:28.000000000 +0100
++++ binutils-2.17-atmel/opcodes/configure.in   2007-02-12 15:37:09.000000000 +0100
+@@ -157,6 +157,7 @@ if test x${all_targets} = xfalse ; then
+       bfd_arc_arch)           ta="$ta arc-dis.lo arc-opc.lo arc-ext.lo" ;;
+       bfd_arm_arch)           ta="$ta arm-dis.lo" ;;
+       bfd_avr_arch)           ta="$ta avr-dis.lo" ;;
++      bfd_avr32_arch)         ta="$ta avr32-asm.lo avr32-dis.lo avr32-opc.lo" ;;
+       bfd_bfin_arch)          ta="$ta bfin-dis.lo" ;;
+       bfd_cris_arch)          ta="$ta cris-dis.lo cris-opc.lo cgen-bitset.lo" ;;
+       bfd_crx_arch)           ta="$ta crx-dis.lo crx-opc.lo" ;;
+diff -Nrup binutils-2.17/opcodes/disassemble.c binutils-2.17-atmel/opcodes/disassemble.c
+--- binutils-2.17/opcodes/disassemble.c        2006-02-17 15:36:28.000000000 +0100
++++ binutils-2.17-atmel/opcodes/disassemble.c  2007-02-12 15:37:09.000000000 +0100
+@@ -24,6 +24,7 @@
+ #define ARCH_arc
+ #define ARCH_arm
+ #define ARCH_avr
++#define ARCH_avr32
+ #define ARCH_bfin
+ #define ARCH_cris
+ #define ARCH_crx
+@@ -121,6 +122,11 @@ disassembler (abfd)
+       disassemble = print_insn_avr;
+       break;
+ #endif
++#ifdef ARCH_avr32
++    case bfd_arch_avr32:
++      disassemble = print_insn_avr32;
++      break;
++#endif
+ #ifdef ARCH_bfin
+     case bfd_arch_bfin:
+       disassemble = print_insn_bfin;
+@@ -433,6 +439,9 @@ disassembler_usage (stream)
+ #ifdef ARCH_powerpc
+   print_ppc_disassembler_options (stream);
+ #endif
++#ifdef ARCH_avr32
++  print_avr32_disassembler_options (stream);
++#endif
+   return;
+ }
+diff -Nrup binutils-2.17/opcodes/Makefile.am binutils-2.17-atmel/opcodes/Makefile.am
+--- binutils-2.17/opcodes/Makefile.am  2006-04-06 23:49:35.000000000 +0200
++++ binutils-2.17-atmel/opcodes/Makefile.am    2007-02-12 15:37:09.000000000 +0100
+@@ -29,6 +29,7 @@ LIBIBERTY = ../libiberty/libiberty.a
+ # Header files.
+ HFILES = \
+       cgen-ops.h cgen-types.h \
++      avr32-asm.h avr32-opc.h \
+       fr30-desc.h fr30-opc.h \
+       frv-desc.h frv-opc.h \
+       h8500-opc.h \
+@@ -58,6 +59,9 @@ CFILES = \
+       arc-ext.c \
+       arm-dis.c \
+       avr-dis.c \
++      avr32-asm.c \
++      avr32-dis.c \
++      avr32-opc.c \
+       bfin-dis.c \
+       cgen-asm.c \
+       cgen-bitset.c \
+@@ -200,6 +204,9 @@ ALL_MACHINES = \
+       arc-ext.lo \
+       arm-dis.lo \
+       avr-dis.lo \
++      avr32-asm.lo \
++      avr32-dis.lo \
++      avr32-opc.lo \
+       bfin-dis.lo \
+       cgen-asm.lo \
+       cgen-bitset.lo \
+@@ -624,6 +631,15 @@ arm-dis.lo: arm-dis.c sysdep.h config.h 
+ avr-dis.lo: avr-dis.c sysdep.h config.h $(INCDIR)/ansidecl.h \
+   $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/symcat.h opintl.h \
+   $(INCDIR)/libiberty.h $(INCDIR)/opcode/avr.h
++avr32-asm.lo: avr32-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \
++  $(BFD_H) $(INCDIR)/symcat.h avr32-opc.h opintl.h \
++  $(INCDIR)/xregex.h $(INCDIR)/xregex2.h \
++  $(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h
++avr32-dis.lo: avr32-dis.c sysdep.h config.h $(INCDIR)/ansidecl.h \
++  $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/symcat.h $(INCDIR)/libiberty.h \
++  avr32-opc.h opintl.h
++avr32-opc.lo: avr32-opc.c sysdep.h config.h $(INCDIR)/ansidecl.h \
++  $(BFD_H) $(INCDIR)/symcat.h avr32-opc.h $(INCDIR)/libiberty.h
+ bfin-dis.lo: bfin-dis.c $(INCDIR)/opcode/bfin.h $(INCDIR)/dis-asm.h \
+   $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h
+ cgen-asm.lo: cgen-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \
+diff -Nrup binutils-2.17/opcodes/Makefile.in binutils-2.17-atmel/opcodes/Makefile.in
+--- binutils-2.17/opcodes/Makefile.in  2006-04-06 23:49:35.000000000 +0200
++++ binutils-2.17-atmel/opcodes/Makefile.in    2007-02-20 16:07:47.000000000 +0100
+@@ -1,4 +1,4 @@
+-# Makefile.in generated by automake 1.9.5 from Makefile.am.
++# Makefile.in generated by automake 1.9.6 from Makefile.am.
+ # @configure_input@
+ # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+@@ -15,8 +15,6 @@
+ @SET_MAKE@
+-SOURCES = libopcodes.c $(libopcodes_la_SOURCES)
+-
+ srcdir = @srcdir@
+ top_srcdir = @top_srcdir@
+ VPATH = @srcdir@
+@@ -132,6 +130,7 @@ EXEEXT = @EXEEXT@
+ EXEEXT_FOR_BUILD = @EXEEXT_FOR_BUILD@
+ GMOFILES = @GMOFILES@
+ GMSGFMT = @GMSGFMT@
++GREP = @GREP@
+ GT_NO = @GT_NO@
+ GT_YES = @GT_YES@
+ HDEFINES = @HDEFINES@
+@@ -180,10 +179,7 @@ WARN_CFLAGS = @WARN_CFLAGS@
+ WIN32LDFLAGS = @WIN32LDFLAGS@
+ WIN32LIBADD = @WIN32LIBADD@
+ XGETTEXT = @XGETTEXT@
+-ac_ct_AR = @ac_ct_AR@
+ ac_ct_CC = @ac_ct_CC@
+-ac_ct_RANLIB = @ac_ct_RANLIB@
+-ac_ct_STRIP = @ac_ct_STRIP@
+ am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+ am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+ am__include = @am__include@
+@@ -202,6 +198,9 @@ build_os = @build_os@
+ build_vendor = @build_vendor@
+ cgendir = @cgendir@
+ datadir = @datadir@
++datarootdir = @datarootdir@
++docdir = @docdir@
++dvidir = @dvidir@
+ exec_prefix = @exec_prefix@
+ host = @host@
+ host_alias = @host_alias@
+@@ -209,18 +208,22 @@ host_cpu = @host_cpu@
+ host_noncanonical = @host_noncanonical@
+ host_os = @host_os@
+ host_vendor = @host_vendor@
++htmldir = @htmldir@
+ includedir = @includedir@
+ infodir = @infodir@
+ install_sh = @install_sh@
+ l = @l@
+ libdir = @libdir@
+ libexecdir = @libexecdir@
++localedir = @localedir@
+ localstatedir = @localstatedir@
+ mandir = @mandir@
+ mkdir_p = @mkdir_p@
+ oldincludedir = @oldincludedir@
++pdfdir = @pdfdir@
+ prefix = @prefix@
+ program_transform_name = @program_transform_name@
++psdir = @psdir@
+ sbindir = @sbindir@
+ sharedstatedir = @sharedstatedir@
+ sysconfdir = @sysconfdir@
+@@ -247,6 +250,7 @@ LIBIBERTY = ../libiberty/libiberty.a
+ # Header files.
+ HFILES = \
+       cgen-ops.h cgen-types.h \
++      avr32-asm.h avr32-opc.h \
+       fr30-desc.h fr30-opc.h \
+       frv-desc.h frv-opc.h \
+       h8500-opc.h \
+@@ -277,6 +281,9 @@ CFILES = \
+       arc-ext.c \
+       arm-dis.c \
+       avr-dis.c \
++      avr32-asm.c \
++      avr32-dis.c \
++      avr32-opc.c \
+       bfin-dis.c \
+       cgen-asm.c \
+       cgen-bitset.c \
+@@ -419,6 +426,9 @@ ALL_MACHINES = \
+       arc-ext.lo \
+       arm-dis.lo \
+       avr-dis.lo \
++      avr32-asm.lo \
++      avr32-dis.lo \
++      avr32-opc.lo \
+       bfin-dis.lo \
+       cgen-asm.lo \
+       cgen-bitset.lo \
+@@ -1166,6 +1176,15 @@ arm-dis.lo: arm-dis.c sysdep.h config.h 
+ avr-dis.lo: avr-dis.c sysdep.h config.h $(INCDIR)/ansidecl.h \
+   $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/symcat.h opintl.h \
+   $(INCDIR)/libiberty.h $(INCDIR)/opcode/avr.h
++avr32-asm.lo: avr32-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \
++  $(BFD_H) $(INCDIR)/symcat.h avr32-opc.h opintl.h \
++  $(INCDIR)/xregex.h $(INCDIR)/xregex2.h \
++  $(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h
++avr32-dis.lo: avr32-dis.c sysdep.h config.h $(INCDIR)/ansidecl.h \
++  $(INCDIR)/dis-asm.h $(BFD_H) $(INCDIR)/symcat.h $(INCDIR)/libiberty.h \
++  avr32-opc.h opintl.h
++avr32-opc.lo: avr32-opc.c sysdep.h config.h $(INCDIR)/ansidecl.h \
++  $(BFD_H) $(INCDIR)/symcat.h avr32-opc.h $(INCDIR)/libiberty.h
+ bfin-dis.lo: bfin-dis.c $(INCDIR)/opcode/bfin.h $(INCDIR)/dis-asm.h \
+   $(BFD_H) $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h
+ cgen-asm.lo: cgen-asm.c sysdep.h config.h $(INCDIR)/ansidecl.h \
+diff -Nur binutils-2.17/config.sub binutils-2.17-owrt/config.sub
+--- binutils-2.17/config.sub   2006-01-16 18:34:37.000000000 +0100
++++ binutils-2.17-owrt/config.sub      2007-06-04 16:30:34.000000000 +0200
+@@ -241,6 +241,7 @@
+       | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+       | am33_2.0 \
+       | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
++      | avr32 \
+       | bfin \
+       | c4x | clipper \
+       | d10v | d30v | dlx | dsp16xx \
+@@ -317,7 +318,7 @@
+       | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+       | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+       | arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+-      | avr-* \
++      | avr-* | avr32-* \
+       | bfin-* | bs2000-* \
+       | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
+       | clipper-* | craynv-* | cydra-* \
diff --git a/toolchain/binutils/patches/2.17/501-avr32-sreldyn-fix.patch b/toolchain/binutils/patches/2.17/501-avr32-sreldyn-fix.patch
new file mode 100644 (file)
index 0000000..4331cb0
--- /dev/null
@@ -0,0 +1,103 @@
+Index: binutils/bfd/elf32-avr32.c
+===================================================================
+--- binutils/bfd/elf32-avr32.c (revision 8769)
++++ binutils/bfd/elf32-avr32.c (working copy)
+@@ -298,7 +298,7 @@
+   /* Shortcuts to get to dynamic linker sections.  */
+   asection *sgot;
+   asection *srelgot;
+-  asection *sreldyn;
++  /* asection *sreldyn; */
+   asection *sstub;
+   /* We use a variation of Pigeonhole Sort to sort the GOT.  After the
+@@ -506,14 +506,14 @@
+   if (!avr32_elf_create_got_section (dynobj, info))
+     return FALSE;
+-  if (!htab->sreldyn)
++  /* if (!htab->sreldyn)
+     htab->sreldyn = create_dynamic_section(dynobj, ".rela.dyn",
+-                                         flags | SEC_READONLY, 2);
++                                         flags | SEC_READONLY, 2); */
+   if (!htab->sstub)
+     htab->sstub = create_dynamic_section(dynobj, ".stub",
+                                        flags | SEC_READONLY | SEC_CODE, 2);
+-  if (!htab->sreldyn || !htab->sstub)
++  if (/* !htab->sreldyn || */ !htab->sstub)
+     return FALSE;
+   return TRUE;
+@@ -669,12 +669,12 @@
+         if ((info->shared || h != NULL)
+             && (sec->flags & SEC_ALLOC))
+           {
+-            if (htab->sreldyn == NULL)
++            if (htab->srelgot == NULL)
+               {
+-                htab->sreldyn = create_dynamic_section(dynobj, ".rela.dyn",
++                htab->srelgot = create_dynamic_section(dynobj, ".rela.got",
+                                                        bed->dynamic_sec_flags
+                                                        | SEC_READONLY, 2);
+-                if (htab->sreldyn == NULL)
++                if (htab->srelgot == NULL)
+                   return FALSE;
+               }
+@@ -1062,7 +1062,7 @@
+     {
+       pr_debug("Allocating %d dynamic reloc against symbol %s...\n",
+              havr->possibly_dynamic_relocs, h->root.root.string);
+-      htab->sreldyn->size += (havr->possibly_dynamic_relocs
++      htab->srelgot->size += (havr->possibly_dynamic_relocs
+                             * sizeof(Elf32_External_Rela));
+     }
+@@ -1156,7 +1156,7 @@
+   /* Allocate space for local sym dynamic relocs */
+   BFD_ASSERT(htab->local_dynamic_relocs == 0 || info->shared);
+   if (htab->local_dynamic_relocs)
+-    htab->sreldyn->size += (htab->local_dynamic_relocs
++    htab->srelgot->size += (htab->local_dynamic_relocs
+                           * sizeof(Elf32_External_Rela));
+   /* We now have determined the sizes of the various dynamic
+@@ -3191,7 +3191,6 @@
+   struct got_entry **local_got_ents;
+   asection *sgot;
+   asection *srelgot;
+-  asection *sreldyn;
+   pr_debug("(6) relocate section %s:<%s> (size 0x%lx)\n",
+          input_bfd->filename, input_section->name, input_section->size);
+@@ -3207,7 +3206,6 @@
+   local_got_ents = elf_local_got_ents(input_bfd);
+   sgot = htab->sgot;
+   srelgot = htab->srelgot;
+-  sreldyn = htab->sreldyn;
+   relend = relocs + input_section->reloc_count;
+   for (rel = relocs; rel < relend; rel++)
+@@ -3444,15 +3442,15 @@
+                   }
+               }
+-            pr_debug("sreldyn reloc_count: %d, size %lu\n",
+-                     sreldyn->reloc_count, sreldyn->size);
++            pr_debug("srelgot reloc_count: %d, size %lu\n",
++                     srelgot->reloc_count, srelgot->size);
+-            loc = sreldyn->contents;
+-            loc += sreldyn->reloc_count++ * sizeof(Elf32_External_Rela);
++            loc = srelgot->contents;
++            loc += srelgot->reloc_count++ * sizeof(Elf32_External_Rela);
+             bfd_elf32_swap_reloca_out(output_bfd, &outrel, loc);
+-            BFD_ASSERT(sreldyn->reloc_count * sizeof(Elf32_External_Rela)
+-                       <= sreldyn->size);
++            BFD_ASSERT(srelgot->reloc_count * sizeof(Elf32_External_Rela)
++                       <= srelgot->size);
+             if (!relocate)
+               continue;
diff --git a/toolchain/binutils/patches/2.17/502-avr32-bfd-dont-allow-direct-refs-to-bss.patch b/toolchain/binutils/patches/2.17/502-avr32-bfd-dont-allow-direct-refs-to-bss.patch
new file mode 100644 (file)
index 0000000..0a99091
--- /dev/null
@@ -0,0 +1,19 @@
+Index: binutils/bfd/elf32-avr32.c
+===================================================================
+--- binutils/bfd/elf32-avr32.c (revision 24565)
++++ binutils/bfd/elf32-avr32.c (working copy)
+@@ -2446,9 +2446,13 @@
+            after the relaxation code is done, so we can't really
+            trust that our "distance" is correct.  There's really no
+            easy solution to this problem, so we'll just disallow
+-           direct references to SEC_DATA sections.  */
++           direct references to SEC_DATA sections.
++           
++           Oh, and .bss isn't actually SEC_DATA, so we disallow
++           !SEC_HAS_CONTENTS as well. */
+         if (!dynamic && defined
+             && !(sym_sec->flags & SEC_DATA)
++            && (sym_sec->flags & SEC_HAS_CONTENTS)
+             && next_state->direct)
+           {
+             next_state = &relax_state[next_state->direct];
diff --git a/toolchain/binutils/patches/2.17/503-avr32-fix-got-offset-init.patch b/toolchain/binutils/patches/2.17/503-avr32-fix-got-offset-init.patch
new file mode 100644 (file)
index 0000000..d39492c
--- /dev/null
@@ -0,0 +1,11 @@
+--- a/bfd/elf32-avr32.c        2007-05-31 17:00:13.000000000 +0200
++++ b/bfd/elf32-avr32.c        2007-05-30 14:07:25.000000000 +0200
+@@ -395,6 +395,8 @@ avr32_elf_link_hash_table_create(bfd *ab
+   /* Prevent the BFD core from creating bogus got_entry pointers */
+   ret->root.init_got_refcount.glist = NULL;
+   ret->root.init_plt_refcount.glist = NULL;
++  ret->root.init_got_offset.glist = NULL;
++  ret->root.init_plt_offset.glist = NULL;
+   return &ret->root.root;
+ }
diff --git a/toolchain/gcc/patches/4.1.2/500-avr32.patch b/toolchain/gcc/patches/4.1.2/500-avr32.patch
new file mode 100644 (file)
index 0000000..b5bb346
--- /dev/null
@@ -0,0 +1,19726 @@
+diff -Nur gcc-4.1.2/config.sub gcc-4.1.2-owrt/config.sub
+--- gcc-4.1.2/config.sub       2005-12-16 13:57:40.000000000 +0100
++++ gcc-4.1.2-owrt/config.sub  2007-05-24 12:03:28.000000000 +0200
+@@ -239,7 +239,7 @@
+       | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+       | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+       | am33_2.0 \
+-      | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
++      | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \
+       | bfin \
+       | c4x | clipper \
+       | d10v | d30v | dlx | dsp16xx \
+@@ -316,7 +316,7 @@
+       | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+       | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+       | arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+-      | avr-* \
++      | avr-* | avr32-* \
+       | bfin-* | bs2000-* \
+       | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
+       | clipper-* | craynv-* | cydra-* \
+diff -Nur gcc-4.1.2/configure.in gcc-4.1.2-owrt/configure.in
+--- gcc-4.1.2/configure.in     2006-11-21 18:48:36.000000000 +0100
++++ gcc-4.1.2-owrt/configure.in        2007-05-24 12:03:28.000000000 +0200
+@@ -497,6 +497,9 @@
+   arm-*-riscix*)
+     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
+     ;;
++  avr32-*-*)
++    noconfigdirs="$noconfigdirs target-libiberty target-libmudflap target-libffi ${libgcj}"
++    ;;
+   avr-*-*)
+     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
+     ;;
+diff -Nur gcc-4.1.2/gcc/builtins.c gcc-4.1.2-owrt/gcc/builtins.c
+--- gcc-4.1.2/gcc/builtins.c   2006-10-06 19:06:52.000000000 +0200
++++ gcc-4.1.2-owrt/gcc/builtins.c      2007-05-24 12:03:28.000000000 +0200
+@@ -9228,7 +9228,7 @@
+   do
+     {
+-      code = va_arg (ap, enum tree_code);
++      code = va_arg (ap, int);
+       switch (code)
+       {
+       case 0:
+diff -Nur gcc-4.1.2/gcc/calls.c gcc-4.1.2-owrt/gcc/calls.c
+--- gcc-4.1.2/gcc/calls.c      2007-01-29 18:08:31.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/calls.c 2007-05-24 12:03:28.000000000 +0200
+@@ -3434,7 +3434,7 @@
+   for (; count < nargs; count++)
+     {
+       rtx val = va_arg (p, rtx);
+-      enum machine_mode mode = va_arg (p, enum machine_mode);
++      enum machine_mode mode = va_arg (p, int);
+       /* We cannot convert the arg value to the mode the library wants here;
+        must do it earlier where we know the signedness of the arg.  */
+diff -Nur gcc-4.1.2/gcc/config/avr32/avr32.c gcc-4.1.2-owrt/gcc/config/avr32/avr32.c
+--- gcc-4.1.2/gcc/config/avr32/avr32.c 1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/avr32.c    2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,7273 @@
++/*
++   Target hooks and helper functions for AVR32.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++   Initial porting by Anders ï¿½dland.
++
++   This file is part of GCC.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
++
++#include "config.h"
++#include "system.h"
++#include "coretypes.h"
++#include "tm.h"
++#include "rtl.h"
++#include "tree.h"
++#include "obstack.h"
++#include "regs.h"
++#include "hard-reg-set.h"
++#include "real.h"
++#include "insn-config.h"
++#include "conditions.h"
++#include "output.h"
++#include "insn-attr.h"
++#include "flags.h"
++#include "reload.h"
++#include "function.h"
++#include "expr.h"
++#include "optabs.h"
++#include "toplev.h"
++#include "recog.h"
++#include "ggc.h"
++#include "except.h"
++#include "c-pragma.h"
++#include "integrate.h"
++#include "tm_p.h"
++#include "langhooks.h"
++
++#include "target.h"
++#include "target-def.h"
++
++#include <ctype.h>
++
++/* Forward definitions of types.  */
++typedef struct minipool_node Mnode;
++typedef struct minipool_fixup Mfix;
++
++/* Obstack for minipool constant handling.  */
++static struct obstack minipool_obstack;
++static char *minipool_startobj;
++static rtx minipool_vector_label;
++
++/* True if we are currently building a constant table.  */
++int making_const_table;
++
++/* Some forward function declarations */
++static unsigned long avr32_isr_value (tree);
++static unsigned long avr32_compute_func_type (void);
++static tree avr32_handle_isr_attribute (tree *, tree, tree, int, bool *);
++static tree avr32_handle_acall_attribute (tree *, tree, tree, int, bool *);
++static tree avr32_handle_fndecl_attribute (tree * node, tree name, tree args,
++                                         int flags, bool * no_add_attrs);
++static void avr32_reorg (void);
++bool avr32_return_in_msb (tree type);
++bool avr32_vector_mode_supported (enum machine_mode mode);
++static void avr32_init_libfuncs (void);
++void avr32_load_pic_register (void);
++
++
++static void
++avr32_add_gc_roots (void)
++{
++  gcc_obstack_init (&minipool_obstack);
++  minipool_startobj = (char *) obstack_alloc (&minipool_obstack, 0);
++}
++
++
++/* List of all known AVR32 parts  */
++static const struct part_type_s avr32_part_types[] = {
++  /* name, part_type, architecture type, macro */
++  {"none", PART_TYPE_AVR32_NONE, ARCH_TYPE_AVR32_AP, "__AVR32__"},
++  {"ap7000", PART_TYPE_AVR32_AP7000, ARCH_TYPE_AVR32_AP, "__AVR32_AP7000__"},
++  {"ap7010", PART_TYPE_AVR32_AP7010, ARCH_TYPE_AVR32_AP, "__AVR32_AP7010__"},
++  {"ap7020", PART_TYPE_AVR32_AP7020, ARCH_TYPE_AVR32_AP, "__AVR32_AP7020__"},
++  {"uc3a0256", PART_TYPE_AVR32_UC3A0256, ARCH_TYPE_AVR32_UC, "__AVR32_UC3A0256__"},
++  {"uc3a0512", PART_TYPE_AVR32_UC3A0512, ARCH_TYPE_AVR32_UC, "__AVR32_UC3A0512__"},
++  {"uc3a1128", PART_TYPE_AVR32_UC3A1128, ARCH_TYPE_AVR32_UC, "__AVR32_UC3A1128__"},
++  {"uc3a1256", PART_TYPE_AVR32_UC3A1256, ARCH_TYPE_AVR32_UC, "__AVR32_UC3A1256__"},
++  {"uc3a1512", PART_TYPE_AVR32_UC3A1512, ARCH_TYPE_AVR32_UC, "__AVR32_UC3A1512__"},
++  {NULL, 0, 0, NULL}
++};
++
++/* List of all known AVR32 architectures  */
++static const struct arch_type_s avr32_arch_types[] = {
++  /* name, architecture type, microarchitecture type, feature flags, macro */
++  {"ap", ARCH_TYPE_AVR32_AP, UARCH_TYPE_AVR32B, FLAG_AVR32_HAS_DSP |
++   FLAG_AVR32_HAS_SIMD | FLAG_AVR32_HAS_UNALIGNED_WORD |
++   FLAG_AVR32_HAS_BRANCH_PRED, "__AVR32_AP__"},
++  {"uc", ARCH_TYPE_AVR32_UC, UARCH_TYPE_AVR32A,
++   FLAG_AVR32_HAS_DSP | FLAG_AVR32_HAS_RMW, "__AVR32_UC__"},
++  {NULL, 0, 0, 0, NULL}
++};
++
++/* Default arch name */
++const char *avr32_arch_name = "ap";
++const char *avr32_part_name = "none";
++
++const struct part_type_s *avr32_part;
++const struct arch_type_s *avr32_arch;
++
++
++/* Override command line options */
++void
++avr32_override_options (void)
++{
++  const struct part_type_s *part;
++  const struct arch_type_s *arch;
++
++  /* Check if part type is set. */
++  for (part = avr32_part_types; part->name; part++)
++    if (strcmp (part->name, avr32_part_name) == 0)
++      break;
++
++  avr32_part = part;
++
++  if (!part->name)
++    {
++      fprintf (stderr, "Unknown part `%s' specified\nKnown part names:\n",
++             avr32_part_name);
++      for (part = avr32_part_types; part->name; part++)
++      fprintf (stderr, "\t%s\n", part->name);
++      avr32_part = &avr32_part_types[PART_TYPE_AVR32_NONE];
++    }
++
++  avr32_arch = &avr32_arch_types[avr32_part->arch_type];
++
++  /* If part was set to "none" then check if arch was set. */
++  if (strcmp (avr32_part->name, "none") == 0)
++    {
++      /* Check if arch type is set. */
++      for (arch = avr32_arch_types; arch->name; arch++)
++      if (strcmp (arch->name, avr32_arch_name) == 0)
++        break;
++
++      avr32_arch = arch;
++
++      if (!arch->name)
++      {
++        fprintf (stderr, "Unknown arch `%s' specified\nKnown arch names:\n",
++                 avr32_arch_name);
++        for (arch = avr32_arch_types; arch->name; arch++)
++          fprintf (stderr, "\t%s\n", arch->name);
++        avr32_arch = &avr32_arch_types[ARCH_TYPE_AVR32_AP];
++      }
++    }
++
++  /* If optimization level is two or greater, then align start of loops to a
++     word boundary since this will allow folding the first insn of the loop.
++     Do this only for targets supporting branch prediction. */
++  if (optimize >= 2 && TARGET_BRANCH_PRED)
++    align_loops = 2;
++
++  if (AVR32_ALWAYS_PIC)
++    flag_pic = 1;
++
++  if (TARGET_NO_PIC)
++    flag_pic = 0;
++
++  avr32_add_gc_roots ();
++}
++
++
++/*
++If defined, a function that outputs the assembler code for entry to a
++function.  The prologue is responsible for setting up the stack frame,
++initializing the frame pointer register, saving registers that must be
++saved, and allocating size additional bytes of storage for the
++local variables.  size is an integer.  file is a stdio
++stream to which the assembler code should be output.
++
++The label for the beginning of the function need not be output by this
++macro.  That has already been done when the macro is run.
++
++To determine which registers to save, the macro can refer to the array
++regs_ever_live: element r is nonzero if hard register
++r is used anywhere within the function.  This implies the function
++prologue should save register r, provided it is not one of the
++call-used registers.  (TARGET_ASM_FUNCTION_EPILOGUE must likewise use
++regs_ever_live.)
++
++On machines that have ``register windows'', the function entry code does
++not save on the stack the registers that are in the windows, even if
++they are supposed to be preserved by function calls; instead it takes
++appropriate steps to ``push'' the register stack, if any non-call-used
++registers are used in the function.
++
++On machines where functions may or may not have frame-pointers, the
++function entry code must vary accordingly; it must set up the frame
++pointer if one is wanted, and not otherwise.  To determine whether a
++frame pointer is in wanted, the macro can refer to the variable
++frame_pointer_needed.  The variable's value will be 1 at run
++time in a function that needs a frame pointer.  (see Elimination).
++
++The function entry code is responsible for allocating any stack space
++required for the function.  This stack space consists of the regions
++listed below.  In most cases, these regions are allocated in the
++order listed, with the last listed region closest to the top of the
++stack (the lowest address if STACK_GROWS_DOWNWARD is defined, and
++the highest address if it is not defined).  You can use a different order
++for a machine if doing so is more convenient or required for
++compatibility reasons.  Except in cases where required by standard
++or by a debugger, there is no reason why the stack layout used by GCC
++need agree with that used by other compilers for a machine.
++*/
++
++#undef TARGET_ASM_FUNCTION_PROLOGUE
++#define TARGET_ASM_FUNCTION_PROLOGUE avr32_target_asm_function_prologue
++
++
++#undef TARGET_DEFAULT_SHORT_ENUMS
++#define TARGET_DEFAULT_SHORT_ENUMS hook_bool_void_false
++
++#undef TARGET_PROMOTE_FUNCTION_ARGS
++#define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
++
++#undef TARGET_PROMOTE_FUNCTION_RETURN
++#define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
++
++#undef TARGET_PROMOTE_PROTOTYPES
++#define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
++
++#undef TARGET_MUST_PASS_IN_STACK
++#define TARGET_MUST_PASS_IN_STACK avr32_must_pass_in_stack
++
++#undef TARGET_PASS_BY_REFERENCE
++#define TARGET_PASS_BY_REFERENCE avr32_pass_by_reference
++
++#undef TARGET_STRICT_ARGUMENT_NAMING
++#define TARGET_STRICT_ARGUMENT_NAMING avr32_strict_argument_naming
++
++#undef TARGET_VECTOR_MODE_SUPPORTED_P
++#define TARGET_VECTOR_MODE_SUPPORTED_P avr32_vector_mode_supported
++
++#undef TARGET_RETURN_IN_MEMORY
++#define TARGET_RETURN_IN_MEMORY avr32_return_in_memory
++
++#undef TARGET_RETURN_IN_MSB
++#define TARGET_RETURN_IN_MSB avr32_return_in_msb
++
++#undef TARGET_ARG_PARTIAL_BYTES
++#define TARGET_ARG_PARTIAL_BYTES avr32_arg_partial_bytes
++
++#undef TARGET_STRIP_NAME_ENCODING
++#define TARGET_STRIP_NAME_ENCODING avr32_strip_name_encoding
++
++#define streq(string1, string2) (strcmp (string1, string2) == 0)
++
++#undef  TARGET_ATTRIBUTE_TABLE
++#define TARGET_ATTRIBUTE_TABLE avr32_attribute_table
++
++#undef  TARGET_COMP_TYPE_ATTRIBUTES
++#define TARGET_COMP_TYPE_ATTRIBUTES avr32_comp_type_attributes
++
++
++#undef  TARGET_RTX_COSTS
++#define TARGET_RTX_COSTS avr32_rtx_costs
++
++#undef  TARGET_CANNOT_FORCE_CONST_MEM
++#define  TARGET_CANNOT_FORCE_CONST_MEM avr32_cannot_force_const_mem
++
++#undef  TARGET_ASM_INTEGER
++#define TARGET_ASM_INTEGER avr32_assemble_integer
++
++/*
++ * Switches to the appropriate section for output of constant pool
++ * entry x in mode. You can assume that x is some kind of constant in
++ * RTL. The argument mode is redundant except in the case of a
++ * const_int rtx. Select the section by calling readonly_data_ section
++ * or one of the alternatives for other sections. align is the
++ * constant alignment in bits.
++ *
++ * The default version of this function takes care of putting symbolic
++ * constants in flag_ pic mode in data_section and everything else in
++ * readonly_data_section.
++ */
++#undef TARGET_ASM_SELECT_RTX_SECTION
++#define TARGET_ASM_SELECT_RTX_SECTION avr32_select_rtx_section
++
++
++/*
++ * If non-null, this hook performs a target-specific pass over the
++ * instruction stream. The compiler will run it at all optimization
++ * levels, just before the point at which it normally does
++ * delayed-branch scheduling.
++ *
++ * The exact purpose of the hook varies from target to target. Some
++ * use it to do transformations that are necessary for correctness,
++ * such as laying out in-function constant pools or avoiding hardware
++ * hazards. Others use it as an opportunity to do some
++ * machine-dependent optimizations.
++ *
++ * You need not implement the hook if it has nothing to do. The
++ * default definition is null.
++ */
++#undef TARGET_MACHINE_DEPENDENT_REORG
++#define TARGET_MACHINE_DEPENDENT_REORG avr32_reorg
++
++/* Target hook for assembling integer objects.
++   Need to handle integer vectors */
++static bool
++avr32_assemble_integer (rtx x, unsigned int size, int aligned_p)
++{
++  if (avr32_vector_mode_supported (GET_MODE (x)))
++    {
++      int i, units;
++
++      if (GET_CODE (x) != CONST_VECTOR)
++      abort ();
++
++      units = CONST_VECTOR_NUNITS (x);
++
++      switch (GET_MODE (x))
++      {
++      case V2HImode:
++        size = 2;
++        break;
++      case V4QImode:
++        size = 1;
++        break;
++      default:
++        abort ();
++      }
++
++      for (i = 0; i < units; i++)
++      {
++        rtx elt;
++
++        elt = CONST_VECTOR_ELT (x, i);
++        assemble_integer (elt, size, i == 0 ? 32 : size * BITS_PER_UNIT, 1);
++      }
++
++      return true;
++    }
++
++  return default_assemble_integer (x, size, aligned_p);
++}
++
++/*
++ * This target hook describes the relative costs of RTL expressions.
++ *
++ * The cost may depend on the precise form of the expression, which is
++ * available for examination in x, and the rtx code of the expression
++ * in which it is contained, found in outer_code. code is the
++ * expression code--redundant, since it can be obtained with GET_CODE
++ * (x).
++ *
++ * In implementing this hook, you can use the construct COSTS_N_INSNS
++ * (n) to specify a cost equal to n fast instructions.
++ *
++ * On entry to the hook, *total contains a default estimate for the
++ * cost of the expression. The hook should modify this value as
++ * necessary. Traditionally, the default costs are COSTS_N_INSNS (5)
++ * for multiplications, COSTS_N_INSNS (7) for division and modulus
++ * operations, and COSTS_N_INSNS (1) for all other operations.
++ *
++ * When optimizing for code size, i.e. when optimize_size is non-zero,
++ * this target hook should be used to estimate the relative size cost
++ * of an expression, again relative to COSTS_N_INSNS.
++ *
++ * The hook returns true when all subexpressions of x have been
++ * processed, and false when rtx_cost should recurse.
++ */
++
++/* Worker routine for avr32_rtx_costs.  */
++static inline int
++avr32_rtx_costs_1 (rtx x, enum rtx_code code ATTRIBUTE_UNUSED,
++                 enum rtx_code outer ATTRIBUTE_UNUSED)
++{
++  enum machine_mode mode = GET_MODE (x);
++
++  switch (GET_CODE (x))
++    {
++    case MEM:
++      /* Using pre decrement / post increment memory operations on the
++         avr32_uc architecture means that two writebacks must be performed
++         and hence two cycles are needed. */
++      if (!optimize_size
++        && GET_MODE_SIZE (mode) <= 2 * UNITS_PER_WORD
++        && avr32_arch->arch_type == ARCH_TYPE_AVR32_UC
++        && (GET_CODE (XEXP (x, 0)) == PRE_DEC
++            || GET_CODE (XEXP (x, 0)) == POST_INC))
++      return COSTS_N_INSNS (4);
++
++      /* Memory costs quite a lot for the first word, but subsequent words
++         load at the equivalent of a single insn each.  */
++      if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
++      return COSTS_N_INSNS (2 + (GET_MODE_SIZE (mode) / UNITS_PER_WORD));
++
++      return COSTS_N_INSNS (3);
++    case SYMBOL_REF:
++    case CONST:
++      /* These are valid for the pseudo insns: lda.w and call which operates
++         on direct addresses. We assume that the cost of a lda.w is the same
++         as the cost of a ld.w insn. */
++      return (outer == SET) ? COSTS_N_INSNS (3) : COSTS_N_INSNS (1);
++    case DIV:
++    case MOD:
++    case UDIV:
++    case UMOD:
++      return optimize_size ? COSTS_N_INSNS (1) : COSTS_N_INSNS (16);
++
++    case ROTATE:
++    case ROTATERT:
++      if (mode == TImode)
++      return COSTS_N_INSNS (100);
++
++      if (mode == DImode)
++      return COSTS_N_INSNS (10);
++      return COSTS_N_INSNS (4);
++    case ASHIFT:
++    case LSHIFTRT:
++    case ASHIFTRT:
++    case NOT:
++      if (mode == TImode)
++      return COSTS_N_INSNS (10);
++
++      if (mode == DImode)
++      return COSTS_N_INSNS (4);
++      return COSTS_N_INSNS (1);
++    case PLUS:
++    case MINUS:
++    case NEG:
++    case COMPARE:
++    case ABS:
++      if (GET_MODE_CLASS (mode) == MODE_FLOAT)
++      return COSTS_N_INSNS (100);
++
++      if (mode == TImode)
++      return COSTS_N_INSNS (50);
++
++      if (mode == DImode)
++      return COSTS_N_INSNS (2);
++      return COSTS_N_INSNS (1);
++
++    case MULT:
++      {
++      if (GET_MODE_CLASS (mode) == MODE_FLOAT)
++        return COSTS_N_INSNS (300);
++
++      if (mode == TImode)
++        return COSTS_N_INSNS (16);
++
++      if (mode == DImode)
++        return COSTS_N_INSNS (4);
++
++      if (mode == HImode)
++        return COSTS_N_INSNS (2);
++
++      return COSTS_N_INSNS (3);
++      }
++    case IF_THEN_ELSE:
++      if (GET_CODE (XEXP (x, 1)) == PC || GET_CODE (XEXP (x, 2)) == PC)
++      return COSTS_N_INSNS (4);
++      return COSTS_N_INSNS (1);
++    case SIGN_EXTEND:
++    case ZERO_EXTEND:
++      /* Sign/Zero extensions of registers cost quite much since these
++         instrcutions only take one register operand which means that gcc
++         often must insert some move instrcutions */
++      if (mode == QImode || mode == HImode)
++      return (COSTS_N_INSNS (GET_CODE (XEXP (x, 0)) == MEM ? 0 : 1));
++      return COSTS_N_INSNS (4);
++    case UNSPEC:
++      /* divmod operations */
++      if (XINT (x, 1) == UNSPEC_UDIVMODSI4_INTERNAL
++        || XINT (x, 1) == UNSPEC_DIVMODSI4_INTERNAL)
++      {
++        return optimize_size ? COSTS_N_INSNS (1) : COSTS_N_INSNS (16);
++      }
++      /* Fallthrough */
++    default:
++      return COSTS_N_INSNS (1);
++    }
++}
++
++static bool
++avr32_rtx_costs (rtx x, int code, int outer_code, int *total)
++{
++  *total = avr32_rtx_costs_1 (x, code, outer_code);
++  return true;
++}
++
++
++bool
++avr32_cannot_force_const_mem (rtx x ATTRIBUTE_UNUSED)
++{
++  /* Do not want symbols in the constant pool when compiling pic or if using
++     address pseudo instructions. */
++  return ((flag_pic || TARGET_HAS_ASM_ADDR_PSEUDOS)
++        && avr32_find_symbol (x) != NULL_RTX);
++}
++
++
++/* Table of machine attributes.  */
++const struct attribute_spec avr32_attribute_table[] = {
++  /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
++  /* Interrupt Service Routines have special prologue and epilogue
++     requirements.  */
++  {"isr", 0, 1, false, false, false, avr32_handle_isr_attribute},
++  {"interrupt", 0, 1, false, false, false, avr32_handle_isr_attribute},
++  {"acall", 0, 1, false, true, true, avr32_handle_acall_attribute},
++  {"naked", 0, 0, true, false, false, avr32_handle_fndecl_attribute},
++  {NULL, 0, 0, false, false, false, NULL}
++};
++
++
++typedef struct
++{
++  const char *const arg;
++  const unsigned long return_value;
++}
++isr_attribute_arg;
++
++static const isr_attribute_arg isr_attribute_args[] = {
++  {"FULL", AVR32_FT_ISR_FULL},
++  {"full", AVR32_FT_ISR_FULL},
++  {"HALF", AVR32_FT_ISR_HALF},
++  {"half", AVR32_FT_ISR_HALF},
++  {"NONE", AVR32_FT_ISR_NONE},
++  {"none", AVR32_FT_ISR_NONE},
++  {"UNDEF", AVR32_FT_ISR_NONE},
++  {"undef", AVR32_FT_ISR_NONE},
++  {"SWI", AVR32_FT_ISR_NONE},
++  {"swi", AVR32_FT_ISR_NONE},
++  {NULL, AVR32_FT_ISR_NONE}
++};
++
++/* Returns the (interrupt) function type of the current
++   function, or AVR32_FT_UNKNOWN if the type cannot be determined.  */
++
++static unsigned long
++avr32_isr_value (tree argument)
++{
++  const isr_attribute_arg *ptr;
++  const char *arg;
++
++  /* No argument - default to ISR_NONE.  */
++  if (argument == NULL_TREE)
++    return AVR32_FT_ISR_NONE;
++
++  /* Get the value of the argument.  */
++  if (TREE_VALUE (argument) == NULL_TREE
++      || TREE_CODE (TREE_VALUE (argument)) != STRING_CST)
++    return AVR32_FT_UNKNOWN;
++
++  arg = TREE_STRING_POINTER (TREE_VALUE (argument));
++
++  /* Check it against the list of known arguments.  */
++  for (ptr = isr_attribute_args; ptr->arg != NULL; ptr++)
++    if (streq (arg, ptr->arg))
++      return ptr->return_value;
++
++  /* An unrecognized interrupt type.  */
++  return AVR32_FT_UNKNOWN;
++}
++
++
++
++/*
++These hooks specify assembly directives for creating certain kinds
++of integer object.  The TARGET_ASM_BYTE_OP directive creates a
++byte-sized object, the TARGET_ASM_ALIGNED_HI_OP one creates an
++aligned two-byte object, and so on.  Any of the hooks may be
++NULL, indicating that no suitable directive is available.
++
++The compiler will print these strings at the start of a new line,
++followed immediately by the object's initial value.  In most cases,
++the string should contain a tab, a pseudo-op, and then another tab.
++*/
++#undef  TARGET_ASM_BYTE_OP
++#define TARGET_ASM_BYTE_OP "\t.byte\t"
++#undef  TARGET_ASM_ALIGNED_HI_OP
++#define TARGET_ASM_ALIGNED_HI_OP "\t.align 1\n\t.short\t"
++#undef  TARGET_ASM_ALIGNED_SI_OP
++#define TARGET_ASM_ALIGNED_SI_OP "\t.align 2\n\t.int\t"
++#undef  TARGET_ASM_ALIGNED_DI_OP
++#define TARGET_ASM_ALIGNED_DI_OP NULL
++#undef  TARGET_ASM_ALIGNED_TI_OP
++#define TARGET_ASM_ALIGNED_TI_OP NULL
++#undef  TARGET_ASM_UNALIGNED_HI_OP
++#define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
++#undef  TARGET_ASM_UNALIGNED_SI_OP
++#define TARGET_ASM_UNALIGNED_SI_OP "\t.int\t"
++#undef  TARGET_ASM_UNALIGNED_DI_OP
++#define TARGET_ASM_UNALIGNED_DI_OP NULL
++#undef  TARGET_ASM_UNALIGNED_TI_OP
++#define TARGET_ASM_UNALIGNED_TI_OP NULL
++
++#undef TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE
++#define TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE avr32_sched_use_dfa_pipeline_interface
++
++#undef TARGET_ASM_OUTPUT_MI_THUNK
++#define TARGET_ASM_OUTPUT_MI_THUNK avr32_output_mi_thunk
++
++
++static void
++avr32_output_mi_thunk (FILE * file,
++                     tree thunk ATTRIBUTE_UNUSED,
++                     HOST_WIDE_INT delta,
++                     HOST_WIDE_INT vcall_offset, tree function)
++{
++  int mi_delta = delta;
++  int this_regno =
++    (avr32_return_in_memory (DECL_RESULT (function), TREE_TYPE (function)) ?
++     INTERNAL_REGNUM (11) : INTERNAL_REGNUM (12));
++
++
++  if (!avr32_const_ok_for_constraint_p (mi_delta, 'I', "Is21")
++      || vcall_offset)
++    {
++      fprintf (file, "\tpushm\tr10\n");
++    }
++
++
++  if (mi_delta != 0)
++    {
++      if (avr32_const_ok_for_constraint_p (mi_delta, 'I', "Is21"))
++      {
++        fprintf (file, "\tsub\t%s, -0x%x\n", reg_names[this_regno],
++                 mi_delta);
++      }
++      else
++      {
++        /* Immediate is larger than k21 we must make us a temp register by
++           pushing a register to the stack. */
++        fprintf (file, "\tmov\tr10, lo(%x)\n", mi_delta);
++        fprintf (file, "\torh\tr10, hi(%x)\n", mi_delta);
++        fprintf (file, "\tadd\t%s, r10\n", reg_names[this_regno]);
++      }
++    }
++
++
++  if (vcall_offset != 0)
++    {
++      fprintf (file, "\tld.w\tr10, %s[0]\n", reg_names[this_regno]);
++      fprintf (file, "\tld.w\tr10, r10[%i]\n", (int) vcall_offset);
++      fprintf (file, "\tadd\t%s, r10\n", reg_names[this_regno]);
++    }
++
++
++  if (!avr32_const_ok_for_constraint_p (mi_delta, 'I', "Is21")
++      || vcall_offset)
++    {
++      fprintf (file, "\tpopm\tr10\n");
++    }
++
++  if (flag_pic)
++    {
++      /* Don't know how we should do this!!! For now we'll just use an
++         extended branch instruction and hope that the function will be
++         reached. */
++      fprintf (file, "\tbral\t");
++      assemble_name (file, XSTR (XEXP (DECL_RTL (function), 0), 0));
++      fputc ('\n', file);
++    }
++  else
++    {
++      fprintf (file, "\tlddpc\tpc, 0f\n");
++      fprintf (file, "\t.align 2\n");
++      fputs ("0:\t.long\t", file);
++      assemble_name (file, XSTR (XEXP (DECL_RTL (function), 0), 0));
++      fputc ('\n', file);
++    }
++}
++
++/* Implements target hook vector_mode_supported.  */
++bool
++avr32_vector_mode_supported (enum machine_mode mode)
++{
++  if ((mode == V2HImode) || (mode == V4QImode))
++    return true;
++
++  return false;
++}
++
++
++#undef TARGET_INIT_LIBFUNCS
++#define TARGET_INIT_LIBFUNCS avr32_init_libfuncs
++
++#undef  TARGET_INIT_BUILTINS
++#define TARGET_INIT_BUILTINS avr32_init_builtins
++
++#undef  TARGET_EXPAND_BUILTIN
++#define TARGET_EXPAND_BUILTIN avr32_expand_builtin
++
++tree int_ftype_int, int_ftype_void, short_ftype_short, void_ftype_int_int,
++  void_ftype_ptr_int;
++tree void_ftype_int, void_ftype_void, int_ftype_ptr_int;
++tree short_ftype_short, int_ftype_int_short, int_ftype_short_short,
++  short_ftype_short_short;
++tree int_ftype_int_int, longlong_ftype_int_short, longlong_ftype_short_short;
++tree void_ftype_int_int_int_int_int, void_ftype_int_int_int;
++tree longlong_ftype_int_int, void_ftype_int_int_longlong;
++tree int_ftype_int_int_int, longlong_ftype_longlong_int_short;
++tree longlong_ftype_longlong_short_short, int_ftype_int_short_short;
++
++#define def_builtin(NAME, TYPE, CODE)                                 \
++  lang_hooks.builtin_function ((NAME), (TYPE), (CODE),                        \
++                             BUILT_IN_MD, NULL, NULL_TREE)
++
++#define def_mbuiltin(MASK, NAME, TYPE, CODE)                          \
++  do                                                                  \
++    {                                                                 \
++      if ((MASK))                                                     \
++      lang_hooks.builtin_function ((NAME), (TYPE), (CODE),            \
++                                   BUILT_IN_MD, NULL, NULL_TREE);     \
++    }                                                                 \
++  while (0)
++
++struct builtin_description
++{
++  const unsigned int mask;
++  const enum insn_code icode;
++  const char *const name;
++  const int code;
++  const enum rtx_code comparison;
++  const unsigned int flag;
++  const tree *ftype;
++};
++
++static const struct builtin_description bdesc_2arg[] = {
++#define DSP_BUILTIN(code, builtin, ftype) \
++  { 1, CODE_FOR_##code, "__builtin_" #code , \
++    AVR32_BUILTIN_##builtin, 0, 0, ftype }
++
++  DSP_BUILTIN (mulsathh_h, MULSATHH_H, &short_ftype_short_short),
++  DSP_BUILTIN (mulsathh_w, MULSATHH_W, &int_ftype_short_short),
++  DSP_BUILTIN (mulsatrndhh_h, MULSATRNDHH_H, &short_ftype_short_short),
++  DSP_BUILTIN (mulsatrndwh_w, MULSATRNDWH_W, &int_ftype_int_short),
++  DSP_BUILTIN (mulsatwh_w, MULSATWH_W, &int_ftype_int_short),
++  DSP_BUILTIN (satadd_h, SATADD_H, &short_ftype_short_short),
++  DSP_BUILTIN (satsub_h, SATSUB_H, &short_ftype_short_short),
++  DSP_BUILTIN (satadd_w, SATADD_W, &int_ftype_int_int),
++  DSP_BUILTIN (satsub_w, SATSUB_W, &int_ftype_int_int),
++  DSP_BUILTIN (mulwh_d, MULWH_D, &longlong_ftype_int_short),
++  DSP_BUILTIN (mulnwh_d, MULNWH_D, &longlong_ftype_int_short)
++};
++
++
++void
++avr32_init_builtins (void)
++{
++  unsigned int i;
++  const struct builtin_description *d;
++  tree endlink = void_list_node;
++  tree int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
++  tree longlong_endlink =
++    tree_cons (NULL_TREE, long_long_integer_type_node, endlink);
++  tree short_endlink =
++    tree_cons (NULL_TREE, short_integer_type_node, endlink);
++  tree void_endlink = tree_cons (NULL_TREE, void_type_node, endlink);
++
++  /* int func (int) */
++  int_ftype_int = build_function_type (integer_type_node, int_endlink);
++
++  /* short func (short) */
++  short_ftype_short
++    = build_function_type (short_integer_type_node, short_endlink);
++
++  /* short func (short, short) */
++  short_ftype_short_short
++    = build_function_type (short_integer_type_node,
++                         tree_cons (NULL_TREE, short_integer_type_node,
++                                    short_endlink));
++
++  /* long long func (long long, short, short) */
++  longlong_ftype_longlong_short_short
++    = build_function_type (long_long_integer_type_node,
++                         tree_cons (NULL_TREE, long_long_integer_type_node,
++                                    tree_cons (NULL_TREE,
++                                               short_integer_type_node,
++                                               short_endlink)));
++
++  /* long long func (short, short) */
++  longlong_ftype_short_short
++    = build_function_type (long_long_integer_type_node,
++                         tree_cons (NULL_TREE, short_integer_type_node,
++                                    short_endlink));
++
++  /* int func (int, int) */
++  int_ftype_int_int
++    = build_function_type (integer_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    int_endlink));
++
++  /* long long func (int, int) */
++  longlong_ftype_int_int
++    = build_function_type (long_long_integer_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    int_endlink));
++
++  /* long long int func (long long, int, short) */
++  longlong_ftype_longlong_int_short
++    = build_function_type (long_long_integer_type_node,
++                         tree_cons (NULL_TREE, long_long_integer_type_node,
++                                    tree_cons (NULL_TREE, integer_type_node,
++                                               short_endlink)));
++
++  /* long long int func (int, short) */
++  longlong_ftype_int_short
++    = build_function_type (long_long_integer_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    short_endlink));
++
++  /* int func (int, short, short) */
++  int_ftype_int_short_short
++    = build_function_type (integer_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    tree_cons (NULL_TREE,
++                                               short_integer_type_node,
++                                               short_endlink)));
++
++  /* int func (short, short) */
++  int_ftype_short_short
++    = build_function_type (integer_type_node,
++                         tree_cons (NULL_TREE, short_integer_type_node,
++                                    short_endlink));
++
++  /* int func (int, short) */
++  int_ftype_int_short
++    = build_function_type (integer_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    short_endlink));
++
++  /* void func (int, int) */
++  void_ftype_int_int
++    = build_function_type (void_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    int_endlink));
++
++  /* void func (int, int, int) */
++  void_ftype_int_int_int
++    = build_function_type (void_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    tree_cons (NULL_TREE, integer_type_node,
++                                               int_endlink)));
++
++  /* void func (int, int, long long) */
++  void_ftype_int_int_longlong
++    = build_function_type (void_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    tree_cons (NULL_TREE, integer_type_node,
++                                               longlong_endlink)));
++
++  /* void func (int, int, int, int, int) */
++  void_ftype_int_int_int_int_int
++    = build_function_type (void_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    tree_cons (NULL_TREE, integer_type_node,
++                                               tree_cons (NULL_TREE,
++                                                          integer_type_node,
++                                                          tree_cons
++                                                          (NULL_TREE,
++                                                           integer_type_node,
++                                                           int_endlink)))));
++
++  /* void func (void *, int) */
++  void_ftype_ptr_int
++    = build_function_type (void_type_node,
++                         tree_cons (NULL_TREE, ptr_type_node, int_endlink));
++
++  /* void func (int) */
++  void_ftype_int = build_function_type (void_type_node, int_endlink);
++
++  /* void func (void) */
++  void_ftype_void = build_function_type (void_type_node, void_endlink);
++
++  /* int func (void) */
++  int_ftype_void = build_function_type (integer_type_node, void_endlink);
++
++  /* int func (void *, int) */
++  int_ftype_ptr_int
++    = build_function_type (integer_type_node,
++                         tree_cons (NULL_TREE, ptr_type_node, int_endlink));
++
++  /* int func (int, int, int) */
++  int_ftype_int_int_int
++    = build_function_type (integer_type_node,
++                         tree_cons (NULL_TREE, integer_type_node,
++                                    tree_cons (NULL_TREE, integer_type_node,
++                                               int_endlink)));
++
++  /* Initialize avr32 builtins.  */
++  def_builtin ("__builtin_mfsr", int_ftype_int, AVR32_BUILTIN_MFSR);
++  def_builtin ("__builtin_mtsr", void_ftype_int_int, AVR32_BUILTIN_MTSR);
++  def_builtin ("__builtin_mfdr", int_ftype_int, AVR32_BUILTIN_MFDR);
++  def_builtin ("__builtin_mtdr", void_ftype_int_int, AVR32_BUILTIN_MTDR);
++  def_builtin ("__builtin_cache", void_ftype_ptr_int, AVR32_BUILTIN_CACHE);
++  def_builtin ("__builtin_sync", void_ftype_int, AVR32_BUILTIN_SYNC);
++  def_builtin ("__builtin_tlbr", void_ftype_void, AVR32_BUILTIN_TLBR);
++  def_builtin ("__builtin_tlbs", void_ftype_void, AVR32_BUILTIN_TLBS);
++  def_builtin ("__builtin_tlbw", void_ftype_void, AVR32_BUILTIN_TLBW);
++  def_builtin ("__builtin_breakpoint", void_ftype_void,
++             AVR32_BUILTIN_BREAKPOINT);
++  def_builtin ("__builtin_xchg", int_ftype_ptr_int, AVR32_BUILTIN_XCHG);
++  def_builtin ("__builtin_ldxi", int_ftype_ptr_int, AVR32_BUILTIN_LDXI);
++  def_builtin ("__builtin_bswap_16", short_ftype_short,
++             AVR32_BUILTIN_BSWAP16);
++  def_builtin ("__builtin_bswap_32", int_ftype_int, AVR32_BUILTIN_BSWAP32);
++  def_builtin ("__builtin_cop", void_ftype_int_int_int_int_int,
++             AVR32_BUILTIN_COP);
++  def_builtin ("__builtin_mvcr_w", int_ftype_int_int, AVR32_BUILTIN_MVCR_W);
++  def_builtin ("__builtin_mvrc_w", void_ftype_int_int_int,
++             AVR32_BUILTIN_MVRC_W);
++  def_builtin ("__builtin_mvcr_d", longlong_ftype_int_int,
++             AVR32_BUILTIN_MVCR_D);
++  def_builtin ("__builtin_mvrc_d", void_ftype_int_int_longlong,
++             AVR32_BUILTIN_MVRC_D);
++  def_builtin ("__builtin_sats", int_ftype_int_int_int, AVR32_BUILTIN_SATS);
++  def_builtin ("__builtin_satu", int_ftype_int_int_int, AVR32_BUILTIN_SATU);
++  def_builtin ("__builtin_satrnds", int_ftype_int_int_int,
++             AVR32_BUILTIN_SATRNDS);
++  def_builtin ("__builtin_satrndu", int_ftype_int_int_int,
++             AVR32_BUILTIN_SATRNDU);
++  def_builtin ("__builtin_musfr", void_ftype_int, AVR32_BUILTIN_MUSFR);
++  def_builtin ("__builtin_mustr", int_ftype_void, AVR32_BUILTIN_MUSTR);
++  def_builtin ("__builtin_macsathh_w", int_ftype_int_short_short,
++             AVR32_BUILTIN_MACSATHH_W);
++  def_builtin ("__builtin_macwh_d", longlong_ftype_longlong_int_short,
++             AVR32_BUILTIN_MACWH_D);
++  def_builtin ("__builtin_machh_d", longlong_ftype_longlong_short_short,
++             AVR32_BUILTIN_MACHH_D);
++
++  /* Add all builtins that are more or less simple operations on two
++     operands.  */
++  for (i = 0, d = bdesc_2arg; i < ARRAY_SIZE (bdesc_2arg); i++, d++)
++    {
++      /* Use one of the operands; the target can have a different mode for
++         mask-generating compares.  */
++
++      if (d->name == 0)
++      continue;
++
++      def_mbuiltin (d->mask, d->name, *(d->ftype), d->code);
++    }
++}
++
++
++/* Subroutine of avr32_expand_builtin to take care of binop insns.  */
++
++static rtx
++avr32_expand_binop_builtin (enum insn_code icode, tree arglist, rtx target)
++{
++  rtx pat;
++  tree arg0 = TREE_VALUE (arglist);
++  tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++  rtx op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++  rtx op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++  enum machine_mode tmode = insn_data[icode].operand[0].mode;
++  enum machine_mode mode0 = insn_data[icode].operand[1].mode;
++  enum machine_mode mode1 = insn_data[icode].operand[2].mode;
++
++  if (!target
++      || GET_MODE (target) != tmode
++      || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++    target = gen_reg_rtx (tmode);
++
++  /* In case the insn wants input operands in modes different from the
++     result, abort.  */
++  if (!(*insn_data[icode].operand[1].predicate) (op0, mode0))
++    {
++      /* If op0 is already a reg we must cast it to the correct mode. */
++      if (REG_P (op0))
++      op0 = convert_to_mode (mode0, op0, 1);
++      else
++      op0 = copy_to_mode_reg (mode0, op0);
++    }
++  if (!(*insn_data[icode].operand[2].predicate) (op1, mode1))
++    {
++      /* If op1 is already a reg we must cast it to the correct mode. */
++      if (REG_P (op1))
++      op1 = convert_to_mode (mode1, op1, 1);
++      else
++      op1 = copy_to_mode_reg (mode1, op1);
++    }
++  pat = GEN_FCN (icode) (target, op0, op1);
++  if (!pat)
++    return 0;
++  emit_insn (pat);
++  return target;
++}
++
++/* Expand an expression EXP that calls a built-in function,
++   with result going to TARGET if that's convenient
++   (and in mode MODE if that's convenient).
++   SUBTARGET may be used as the target for computing one of EXP's operands.
++   IGNORE is nonzero if the value is to be ignored.  */
++
++rtx
++avr32_expand_builtin (tree exp,
++                    rtx target,
++                    rtx subtarget ATTRIBUTE_UNUSED,
++                    enum machine_mode mode ATTRIBUTE_UNUSED,
++                    int ignore ATTRIBUTE_UNUSED)
++{
++  const struct builtin_description *d;
++  unsigned int i;
++  enum insn_code icode;
++  tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
++  tree arglist = TREE_OPERAND (exp, 1);
++  tree arg0, arg1, arg2;
++  rtx op0, op1, op2, pat;
++  enum machine_mode tmode, mode0, mode1;
++  enum machine_mode arg0_mode;
++  int fcode = DECL_FUNCTION_CODE (fndecl);
++
++  switch (fcode)
++    {
++    default:
++      break;
++
++    case AVR32_BUILTIN_SATS:
++    case AVR32_BUILTIN_SATU:
++    case AVR32_BUILTIN_SATRNDS:
++    case AVR32_BUILTIN_SATRNDU:
++      {
++      const char *fname;
++      switch (fcode)
++        {
++        default:
++        case AVR32_BUILTIN_SATS:
++          icode = CODE_FOR_sats;
++          fname = "sats";
++          break;
++        case AVR32_BUILTIN_SATU:
++          icode = CODE_FOR_satu;
++          fname = "satu";
++          break;
++        case AVR32_BUILTIN_SATRNDS:
++          icode = CODE_FOR_satrnds;
++          fname = "satrnds";
++          break;
++        case AVR32_BUILTIN_SATRNDU:
++          icode = CODE_FOR_satrndu;
++          fname = "satrndu";
++          break;
++        }
++
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++      op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
++
++      tmode = insn_data[icode].operand[0].mode;
++
++
++      if (target == 0
++          || GET_MODE (target) != tmode
++          || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++        target = gen_reg_rtx (tmode);
++
++
++      if (!(*insn_data[icode].operand[0].predicate) (op0, GET_MODE (op0)))
++        {
++          op0 = copy_to_mode_reg (insn_data[icode].operand[0].mode, op0);
++        }
++
++      if (!(*insn_data[icode].operand[1].predicate) (op1, SImode))
++        {
++          error ("Parameter 2 to __builtin_%s should be a constant number.",
++                 fname);
++          return NULL_RTX;
++        }
++
++      if (!(*insn_data[icode].operand[1].predicate) (op2, SImode))
++        {
++          error ("Parameter 3 to __builtin_%s should be a constant number.",
++                 fname);
++          return NULL_RTX;
++        }
++
++      emit_move_insn (target, op0);
++      pat = GEN_FCN (icode) (target, op1, op2);
++      if (!pat)
++        return 0;
++      emit_insn (pat);
++
++      return target;
++      }
++    case AVR32_BUILTIN_MUSTR:
++      icode = CODE_FOR_mustr;
++      tmode = insn_data[icode].operand[0].mode;
++
++      if (target == 0
++        || GET_MODE (target) != tmode
++        || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++      target = gen_reg_rtx (tmode);
++      pat = GEN_FCN (icode) (target);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return target;
++
++    case AVR32_BUILTIN_MFSR:
++      icode = CODE_FOR_mfsr;
++      arg0 = TREE_VALUE (arglist);
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      tmode = insn_data[icode].operand[0].mode;
++      mode0 = insn_data[icode].operand[1].mode;
++
++      if (!(*insn_data[icode].operand[1].predicate) (op0, mode0))
++      {
++        error ("Parameter 1 to __builtin_mfsr must be a constant number");
++      }
++
++      if (target == 0
++        || GET_MODE (target) != tmode
++        || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++      target = gen_reg_rtx (tmode);
++      pat = GEN_FCN (icode) (target, op0);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return target;
++    case AVR32_BUILTIN_MTSR:
++      icode = CODE_FOR_mtsr;
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++      mode0 = insn_data[icode].operand[0].mode;
++      mode1 = insn_data[icode].operand[1].mode;
++
++      if (!(*insn_data[icode].operand[0].predicate) (op0, mode0))
++      {
++        error ("Parameter 1 to __builtin_mtsr must be a constant number");
++        return gen_reg_rtx (mode0);
++      }
++      if (!(*insn_data[icode].operand[1].predicate) (op1, mode1))
++      op1 = copy_to_mode_reg (mode1, op1);
++      pat = GEN_FCN (icode) (op0, op1);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return NULL_RTX;
++    case AVR32_BUILTIN_MFDR:
++      icode = CODE_FOR_mfdr;
++      arg0 = TREE_VALUE (arglist);
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      tmode = insn_data[icode].operand[0].mode;
++      mode0 = insn_data[icode].operand[1].mode;
++
++      if (!(*insn_data[icode].operand[1].predicate) (op0, mode0))
++      {
++        error ("Parameter 1 to __builtin_mfdr must be a constant number");
++      }
++
++      if (target == 0
++        || GET_MODE (target) != tmode
++        || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++      target = gen_reg_rtx (tmode);
++      pat = GEN_FCN (icode) (target, op0);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return target;
++    case AVR32_BUILTIN_MTDR:
++      icode = CODE_FOR_mtdr;
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++      mode0 = insn_data[icode].operand[0].mode;
++      mode1 = insn_data[icode].operand[1].mode;
++
++      if (!(*insn_data[icode].operand[0].predicate) (op0, mode0))
++      {
++        error ("Parameter 1 to __builtin_mtdr must be a constant number");
++        return gen_reg_rtx (mode0);
++      }
++      if (!(*insn_data[icode].operand[1].predicate) (op1, mode1))
++      op1 = copy_to_mode_reg (mode1, op1);
++      pat = GEN_FCN (icode) (op0, op1);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return NULL_RTX;
++    case AVR32_BUILTIN_CACHE:
++      icode = CODE_FOR_cache;
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++      mode0 = insn_data[icode].operand[0].mode;
++      mode1 = insn_data[icode].operand[1].mode;
++
++      if (!(*insn_data[icode].operand[1].predicate) (op1, mode1))
++      {
++        error ("Parameter 2 to __builtin_cache must be a constant number");
++        return gen_reg_rtx (mode1);
++      }
++
++      if (!(*insn_data[icode].operand[0].predicate) (op0, mode0))
++      op0 = copy_to_mode_reg (mode0, op0);
++
++      pat = GEN_FCN (icode) (op0, op1);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return NULL_RTX;
++    case AVR32_BUILTIN_SYNC:
++    case AVR32_BUILTIN_MUSFR:
++      {
++      const char *fname;
++      switch (fcode)
++        {
++        default:
++        case AVR32_BUILTIN_SYNC:
++          icode = CODE_FOR_sync;
++          fname = "sync";
++          break;
++        case AVR32_BUILTIN_MUSFR:
++          icode = CODE_FOR_musfr;
++          fname = "musfr";
++          break;
++        }
++
++      arg0 = TREE_VALUE (arglist);
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      mode0 = insn_data[icode].operand[0].mode;
++
++      if (!(*insn_data[icode].operand[0].predicate) (op0, mode0))
++        {
++          if (icode == CODE_FOR_musfr)
++            op0 = copy_to_mode_reg (mode0, op0);
++          else
++            {
++              error ("Parameter to __builtin_%s is illegal.", fname);
++              return gen_reg_rtx (mode0);
++            }
++        }
++      pat = GEN_FCN (icode) (op0);
++      if (!pat)
++        return 0;
++      emit_insn (pat);
++      return NULL_RTX;
++      }
++    case AVR32_BUILTIN_TLBR:
++      icode = CODE_FOR_tlbr;
++      pat = GEN_FCN (icode) (NULL_RTX);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return NULL_RTX;
++    case AVR32_BUILTIN_TLBS:
++      icode = CODE_FOR_tlbs;
++      pat = GEN_FCN (icode) (NULL_RTX);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return NULL_RTX;
++    case AVR32_BUILTIN_TLBW:
++      icode = CODE_FOR_tlbw;
++      pat = GEN_FCN (icode) (NULL_RTX);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return NULL_RTX;
++    case AVR32_BUILTIN_BREAKPOINT:
++      icode = CODE_FOR_breakpoint;
++      pat = GEN_FCN (icode) (NULL_RTX);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return NULL_RTX;
++    case AVR32_BUILTIN_XCHG:
++      icode = CODE_FOR_xchg;
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++      tmode = insn_data[icode].operand[0].mode;
++      mode0 = insn_data[icode].operand[1].mode;
++      mode1 = insn_data[icode].operand[3].mode;
++
++      if (!(*insn_data[icode].operand[3].predicate) (op1, mode1))
++      {
++        op1 = copy_to_mode_reg (mode1, op1);
++      }
++
++      if (!(*insn_data[icode].operand[2].predicate) (op0, mode0))
++      {
++        op0 = copy_to_mode_reg (mode0, op0);
++      }
++
++      if (target == 0
++        || GET_MODE (target) != tmode
++        || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++      target = gen_reg_rtx (tmode);
++      pat = GEN_FCN (icode) (target, op0, op0, op1);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return target;
++    case AVR32_BUILTIN_LDXI:
++      icode = CODE_FOR_ldxi;
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++      op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
++      tmode = insn_data[icode].operand[0].mode;
++      mode0 = insn_data[icode].operand[1].mode;
++      mode1 = insn_data[icode].operand[2].mode;
++
++      if (!(*insn_data[icode].operand[1].predicate) (op0, mode0))
++      {
++        op0 = copy_to_mode_reg (mode0, op0);
++      }
++
++      if (!(*insn_data[icode].operand[2].predicate) (op1, mode1))
++      {
++        op1 = copy_to_mode_reg (mode1, op1);
++      }
++
++      if (!(*insn_data[icode].operand[3].predicate) (op2, SImode))
++      {
++        error
++          ("Parameter 3 to __builtin_ldxi must be a valid extract shift operand: (0|8|16|24)");
++        return gen_reg_rtx (mode0);
++      }
++
++      if (target == 0
++        || GET_MODE (target) != tmode
++        || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++      target = gen_reg_rtx (tmode);
++      pat = GEN_FCN (icode) (target, op0, op1, op2);
++      if (!pat)
++      return 0;
++      emit_insn (pat);
++      return target;
++    case AVR32_BUILTIN_BSWAP16:
++      {
++      icode = CODE_FOR_bswap_16;
++      arg0 = TREE_VALUE (arglist);
++      arg0_mode = TYPE_MODE (TREE_TYPE (arg0));
++      mode0 = insn_data[icode].operand[1].mode;
++      if (arg0_mode != mode0)
++        arg0 = build1 (NOP_EXPR,
++                       (*lang_hooks.types.type_for_mode) (mode0, 0), arg0);
++
++      op0 = expand_expr (arg0, NULL_RTX, HImode, 0);
++      tmode = insn_data[icode].operand[0].mode;
++
++
++      if (!(*insn_data[icode].operand[1].predicate) (op0, mode0))
++        {
++          op0 = copy_to_mode_reg (mode0, op0);
++        }
++
++      if (target == 0
++          || GET_MODE (target) != tmode
++          || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++        {
++          target = gen_reg_rtx (tmode);
++        }
++
++
++      pat = GEN_FCN (icode) (target, op0);
++      if (!pat)
++        return 0;
++      emit_insn (pat);
++
++      return target;
++      }
++    case AVR32_BUILTIN_BSWAP32:
++      {
++      icode = CODE_FOR_bswap_32;
++      arg0 = TREE_VALUE (arglist);
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      tmode = insn_data[icode].operand[0].mode;
++      mode0 = insn_data[icode].operand[1].mode;
++
++      if (!(*insn_data[icode].operand[1].predicate) (op0, mode0))
++        {
++          op0 = copy_to_mode_reg (mode0, op0);
++        }
++
++      if (target == 0
++          || GET_MODE (target) != tmode
++          || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++        target = gen_reg_rtx (tmode);
++
++
++      pat = GEN_FCN (icode) (target, op0);
++      if (!pat)
++        return 0;
++      emit_insn (pat);
++
++      return target;
++      }
++    case AVR32_BUILTIN_MVCR_W:
++    case AVR32_BUILTIN_MVCR_D:
++      {
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++
++      if (fcode == AVR32_BUILTIN_MVCR_W)
++        icode = CODE_FOR_mvcrsi;
++      else
++        icode = CODE_FOR_mvcrdi;
++
++      tmode = insn_data[icode].operand[0].mode;
++
++      if (target == 0
++          || GET_MODE (target) != tmode
++          || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++        target = gen_reg_rtx (tmode);
++
++      if (!(*insn_data[icode].operand[1].predicate) (op0, SImode))
++        {
++          error
++            ("Parameter 1 to __builtin_cop is not a valid coprocessor number.");
++          error ("Number should be between 0 and 7.");
++          return NULL_RTX;
++        }
++
++      if (!(*insn_data[icode].operand[2].predicate) (op1, SImode))
++        {
++          error
++            ("Parameter 2 to __builtin_cop is not a valid coprocessor register number.");
++          error ("Number should be between 0 and 15.");
++          return NULL_RTX;
++        }
++
++      pat = GEN_FCN (icode) (target, op0, op1);
++      if (!pat)
++        return 0;
++      emit_insn (pat);
++
++      return target;
++      }
++    case AVR32_BUILTIN_MACSATHH_W:
++    case AVR32_BUILTIN_MACWH_D:
++    case AVR32_BUILTIN_MACHH_D:
++      {
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++      op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
++
++      icode = ((fcode == AVR32_BUILTIN_MACSATHH_W) ? CODE_FOR_macsathh_w :
++               (fcode == AVR32_BUILTIN_MACWH_D) ? CODE_FOR_macwh_d :
++               CODE_FOR_machh_d);
++
++      tmode = insn_data[icode].operand[0].mode;
++      mode0 = insn_data[icode].operand[1].mode;
++      mode1 = insn_data[icode].operand[2].mode;
++
++
++      if (!target
++          || GET_MODE (target) != tmode
++          || !(*insn_data[icode].operand[0].predicate) (target, tmode))
++        target = gen_reg_rtx (tmode);
++
++      if (!(*insn_data[icode].operand[0].predicate) (op0, tmode))
++        {
++          /* If op0 is already a reg we must cast it to the correct mode. */
++          if (REG_P (op0))
++            op0 = convert_to_mode (tmode, op0, 1);
++          else
++            op0 = copy_to_mode_reg (tmode, op0);
++        }
++
++      if (!(*insn_data[icode].operand[1].predicate) (op1, mode0))
++        {
++          /* If op1 is already a reg we must cast it to the correct mode. */
++          if (REG_P (op1))
++            op1 = convert_to_mode (mode0, op1, 1);
++          else
++            op1 = copy_to_mode_reg (mode0, op1);
++        }
++
++      if (!(*insn_data[icode].operand[2].predicate) (op2, mode1))
++        {
++          /* If op1 is already a reg we must cast it to the correct mode. */
++          if (REG_P (op2))
++            op2 = convert_to_mode (mode1, op2, 1);
++          else
++            op2 = copy_to_mode_reg (mode1, op2);
++        }
++
++      emit_move_insn (target, op0);
++
++      pat = GEN_FCN (icode) (target, op1, op2);
++      if (!pat)
++        return 0;
++      emit_insn (pat);
++      return target;
++      }
++    case AVR32_BUILTIN_MVRC_W:
++    case AVR32_BUILTIN_MVRC_D:
++      {
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++      op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
++
++      if (fcode == AVR32_BUILTIN_MVRC_W)
++        icode = CODE_FOR_mvrcsi;
++      else
++        icode = CODE_FOR_mvrcdi;
++
++      if (!(*insn_data[icode].operand[0].predicate) (op0, SImode))
++        {
++          error ("Parameter 1 is not a valid coprocessor number.");
++          error ("Number should be between 0 and 7.");
++          return NULL_RTX;
++        }
++
++      if (!(*insn_data[icode].operand[1].predicate) (op1, SImode))
++        {
++          error ("Parameter 2 is not a valid coprocessor register number.");
++          error ("Number should be between 0 and 15.");
++          return NULL_RTX;
++        }
++
++      if (GET_CODE (op2) == CONST_INT
++          || GET_CODE (op2) == CONST
++          || GET_CODE (op2) == SYMBOL_REF || GET_CODE (op2) == LABEL_REF)
++        {
++          op2 = force_const_mem (insn_data[icode].operand[2].mode, op2);
++        }
++
++      if (!(*insn_data[icode].operand[2].predicate) (op2, GET_MODE (op2)))
++        op2 = copy_to_mode_reg (insn_data[icode].operand[2].mode, op2);
++
++
++      pat = GEN_FCN (icode) (op0, op1, op2);
++      if (!pat)
++        return 0;
++      emit_insn (pat);
++
++      return NULL_RTX;
++      }
++    case AVR32_BUILTIN_COP:
++      {
++      rtx op3, op4;
++      tree arg3, arg4;
++      icode = CODE_FOR_cop;
++      arg0 = TREE_VALUE (arglist);
++      arg1 = TREE_VALUE (TREE_CHAIN (arglist));
++      arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
++      arg3 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
++      arg4 =
++        TREE_VALUE (TREE_CHAIN
++                    (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist)))));
++      op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
++      op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
++      op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
++      op3 = expand_expr (arg3, NULL_RTX, VOIDmode, 0);
++      op4 = expand_expr (arg4, NULL_RTX, VOIDmode, 0);
++
++      if (!(*insn_data[icode].operand[0].predicate) (op0, SImode))
++        {
++          error
++            ("Parameter 1 to __builtin_cop is not a valid coprocessor number.");
++          error ("Number should be between 0 and 7.");
++          return NULL_RTX;
++        }
++
++      if (!(*insn_data[icode].operand[1].predicate) (op1, SImode))
++        {
++          error
++            ("Parameter 2 to __builtin_cop is not a valid coprocessor register number.");
++          error ("Number should be between 0 and 15.");
++          return NULL_RTX;
++        }
++
++      if (!(*insn_data[icode].operand[2].predicate) (op2, SImode))
++        {
++          error
++            ("Parameter 3 to __builtin_cop is not a valid coprocessor register number.");
++          error ("Number should be between 0 and 15.");
++          return NULL_RTX;
++        }
++
++      if (!(*insn_data[icode].operand[3].predicate) (op3, SImode))
++        {
++          error
++            ("Parameter 4 to __builtin_cop is not a valid coprocessor register number.");
++          error ("Number should be between 0 and 15.");
++          return NULL_RTX;
++        }
++
++      if (!(*insn_data[icode].operand[4].predicate) (op4, SImode))
++        {
++          error
++            ("Parameter 5 to __builtin_cop is not a valid coprocessor operation.");
++          error ("Number should be between 0 and 127.");
++          return NULL_RTX;
++        }
++
++      pat = GEN_FCN (icode) (op0, op1, op2, op3, op4);
++      if (!pat)
++        return 0;
++      emit_insn (pat);
++
++      return target;
++      }
++    }
++
++  for (i = 0, d = bdesc_2arg; i < ARRAY_SIZE (bdesc_2arg); i++, d++)
++    if (d->code == fcode)
++      return avr32_expand_binop_builtin (d->icode, arglist, target);
++
++
++  /* @@@ Should really do something sensible here.  */
++  return NULL_RTX;
++}
++
++
++/* Handle an "interrupt" or "isr" attribute;
++   arguments as in struct attribute_spec.handler.  */
++
++static tree
++avr32_handle_isr_attribute (tree * node, tree name, tree args,
++                          int flags, bool * no_add_attrs)
++{
++  if (DECL_P (*node))
++    {
++      if (TREE_CODE (*node) != FUNCTION_DECL)
++      {
++        warning ("`%s' attribute only applies to functions",
++                 IDENTIFIER_POINTER (name));
++        *no_add_attrs = true;
++      }
++      /* FIXME: the argument if any is checked for type attributes; should it
++         be checked for decl ones? */
++    }
++  else
++    {
++      if (TREE_CODE (*node) == FUNCTION_TYPE
++        || TREE_CODE (*node) == METHOD_TYPE)
++      {
++        if (avr32_isr_value (args) == AVR32_FT_UNKNOWN)
++          {
++            warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
++            *no_add_attrs = true;
++          }
++      }
++      else if (TREE_CODE (*node) == POINTER_TYPE
++             && (TREE_CODE (TREE_TYPE (*node)) == FUNCTION_TYPE
++                 || TREE_CODE (TREE_TYPE (*node)) == METHOD_TYPE)
++             && avr32_isr_value (args) != AVR32_FT_UNKNOWN)
++      {
++        *node = build_variant_type_copy (*node);
++        TREE_TYPE (*node) = build_type_attribute_variant
++          (TREE_TYPE (*node),
++           tree_cons (name, args, TYPE_ATTRIBUTES (TREE_TYPE (*node))));
++        *no_add_attrs = true;
++      }
++      else
++      {
++        /* Possibly pass this attribute on from the type to a decl.  */
++        if (flags & ((int) ATTR_FLAG_DECL_NEXT
++                     | (int) ATTR_FLAG_FUNCTION_NEXT
++                     | (int) ATTR_FLAG_ARRAY_NEXT))
++          {
++            *no_add_attrs = true;
++            return tree_cons (name, args, NULL_TREE);
++          }
++        else
++          {
++            warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
++          }
++      }
++    }
++
++  return NULL_TREE;
++}
++
++/* Handle an attribute requiring a FUNCTION_DECL;
++   arguments as in struct attribute_spec.handler.  */
++static tree
++avr32_handle_fndecl_attribute (tree * node, tree name,
++                             tree args ATTRIBUTE_UNUSED,
++                             int flags ATTRIBUTE_UNUSED,
++                             bool * no_add_attrs)
++{
++  if (TREE_CODE (*node) != FUNCTION_DECL)
++    {
++      warning ("%qs attribute only applies to functions",
++             IDENTIFIER_POINTER (name));
++      *no_add_attrs = true;
++    }
++
++  return NULL_TREE;
++}
++
++
++/* Handle an acall attribute;
++   arguments as in struct attribute_spec.handler.  */
++
++static tree
++avr32_handle_acall_attribute (tree * node, tree name,
++                            tree args ATTRIBUTE_UNUSED,
++                            int flags ATTRIBUTE_UNUSED, bool * no_add_attrs)
++{
++  if (TREE_CODE (*node) == FUNCTION_TYPE || TREE_CODE (*node) == METHOD_TYPE)
++    {
++      warning ("`%s' attribute not yet supported...",
++             IDENTIFIER_POINTER (name));
++      *no_add_attrs = true;
++      return NULL_TREE;
++    }
++
++  warning ("`%s' attribute only applies to functions",
++         IDENTIFIER_POINTER (name));
++  *no_add_attrs = true;
++  return NULL_TREE;
++}
++
++
++/* Return 0 if the attributes for two types are incompatible, 1 if they
++   are compatible, and 2 if they are nearly compatible (which causes a
++   warning to be generated).  */
++
++static int
++avr32_comp_type_attributes (tree type1, tree type2)
++{
++  int acall1, acall2, isr1, isr2, naked1, naked2;
++
++  /* Check for mismatch of non-default calling convention.  */
++  if (TREE_CODE (type1) != FUNCTION_TYPE)
++    return 1;
++
++  /* Check for mismatched call attributes.  */
++  acall1 = lookup_attribute ("acall", TYPE_ATTRIBUTES (type1)) != NULL;
++  acall2 = lookup_attribute ("acall", TYPE_ATTRIBUTES (type2)) != NULL;
++  naked1 = lookup_attribute ("naked", TYPE_ATTRIBUTES (type1)) != NULL;
++  naked2 = lookup_attribute ("naked", TYPE_ATTRIBUTES (type2)) != NULL;
++  isr1 = lookup_attribute ("isr", TYPE_ATTRIBUTES (type1)) != NULL;
++  if (!isr1)
++    isr1 = lookup_attribute ("interrupt", TYPE_ATTRIBUTES (type1)) != NULL;
++
++  isr2 = lookup_attribute ("isr", TYPE_ATTRIBUTES (type2)) != NULL;
++  if (!isr2)
++    isr2 = lookup_attribute ("interrupt", TYPE_ATTRIBUTES (type2)) != NULL;
++
++  if ((acall1 && isr2)
++      || (acall2 && isr1) || (naked1 && isr2) || (naked2 && isr1))
++    return 0;
++
++  return 1;
++}
++
++
++/* Computes the type of the current function.  */
++
++static unsigned long
++avr32_compute_func_type (void)
++{
++  unsigned long type = AVR32_FT_UNKNOWN;
++  tree a;
++  tree attr;
++
++  if (TREE_CODE (current_function_decl) != FUNCTION_DECL)
++    abort ();
++
++  /* Decide if the current function is volatile.  Such functions never
++     return, and many memory cycles can be saved by not storing register
++     values that will never be needed again.  This optimization was added to
++     speed up context switching in a kernel application.  */
++  if (optimize > 0
++      && TREE_NOTHROW (current_function_decl)
++      && TREE_THIS_VOLATILE (current_function_decl))
++    type |= AVR32_FT_VOLATILE;
++
++  if (cfun->static_chain_decl != NULL)
++    type |= AVR32_FT_NESTED;
++
++  attr = DECL_ATTRIBUTES (current_function_decl);
++
++  a = lookup_attribute ("isr", attr);
++  if (a == NULL_TREE)
++    a = lookup_attribute ("interrupt", attr);
++
++  if (a == NULL_TREE)
++    type |= AVR32_FT_NORMAL;
++  else
++    type |= avr32_isr_value (TREE_VALUE (a));
++
++
++  a = lookup_attribute ("acall", attr);
++  if (a != NULL_TREE)
++    type |= AVR32_FT_ACALL;
++
++  a = lookup_attribute ("naked", attr);
++  if (a != NULL_TREE)
++    type |= AVR32_FT_NAKED;
++
++  return type;
++}
++
++/* Returns the type of the current function.  */
++
++static unsigned long
++avr32_current_func_type (void)
++{
++  if (AVR32_FUNC_TYPE (cfun->machine->func_type) == AVR32_FT_UNKNOWN)
++    cfun->machine->func_type = avr32_compute_func_type ();
++
++  return cfun->machine->func_type;
++}
++
++/*
++   This target hook should return true if we should not pass type solely
++   in registers. The file expr.h defines a definition that is usually appropriate,
++   refer to expr.h for additional documentation.
++*/
++bool
++avr32_must_pass_in_stack (enum machine_mode mode ATTRIBUTE_UNUSED, tree type)
++{
++  if (type && AGGREGATE_TYPE_P (type)
++      /* If the alignment is less than the size then pass in the struct on
++         the stack. */
++      && ((unsigned int) TYPE_ALIGN_UNIT (type) <
++        (unsigned int) int_size_in_bytes (type))
++      /* If we support unaligned word accesses then structs of size 4 and 8
++         can have any alignment and still be passed in registers. */
++      && !(TARGET_UNALIGNED_WORD
++         && (int_size_in_bytes (type) == 4
++             || int_size_in_bytes (type) == 8))
++      /* Double word structs need only a word alignment. */
++      && !(int_size_in_bytes (type) == 8 && TYPE_ALIGN_UNIT (type) >= 4))
++    return true;
++
++  if (type && AGGREGATE_TYPE_P (type)
++      /* Structs of size 3,5,6,7 are always passed in registers. */
++      && (int_size_in_bytes (type) == 3
++        || int_size_in_bytes (type) == 5
++        || int_size_in_bytes (type) == 6 || int_size_in_bytes (type) == 7))
++    return true;
++
++
++  return (type && TREE_ADDRESSABLE (type));
++}
++
++
++bool
++avr32_strict_argument_naming (CUMULATIVE_ARGS * ca ATTRIBUTE_UNUSED)
++{
++  return true;
++}
++
++/*
++   This target hook should return true if an argument at the position indicated
++   by cum should be passed by reference. This predicate is queried after target
++   independent reasons for being passed by reference, such as TREE_ADDRESSABLE (type).
++
++   If the hook returns true, a copy of that argument is made in memory and a
++   pointer to the argument is passed instead of the argument itself. The pointer
++   is passed in whatever way is appropriate for passing a pointer to that type.
++*/
++bool
++avr32_pass_by_reference (CUMULATIVE_ARGS * cum ATTRIBUTE_UNUSED,
++                       enum machine_mode mode ATTRIBUTE_UNUSED,
++                       tree type, bool named ATTRIBUTE_UNUSED)
++{
++  return (type && (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST));
++}
++
++static int
++avr32_arg_partial_bytes (CUMULATIVE_ARGS * pcum ATTRIBUTE_UNUSED,
++                       enum machine_mode mode ATTRIBUTE_UNUSED,
++                       tree type ATTRIBUTE_UNUSED,
++                       bool named ATTRIBUTE_UNUSED)
++{
++  return 0;
++}
++
++
++struct gcc_target targetm = TARGET_INITIALIZER;
++
++/*
++  Table used to convert from register number in the assembler instructions and
++  the register numbers used in gcc.
++*/
++const int avr32_function_arg_reglist[] =
++{
++  INTERNAL_REGNUM (12),
++  INTERNAL_REGNUM (11),
++  INTERNAL_REGNUM (10),
++  INTERNAL_REGNUM (9),
++  INTERNAL_REGNUM (8)
++};
++
++rtx avr32_compare_op0 = NULL_RTX;
++rtx avr32_compare_op1 = NULL_RTX;
++rtx avr32_compare_operator = NULL_RTX;
++rtx avr32_acc_cache = NULL_RTX;
++
++/*
++  Returns nonzero if it is allowed to store a value of mode mode in hard
++  register number regno.
++*/
++int
++avr32_hard_regno_mode_ok (int regnr, enum machine_mode mode)
++{
++  /* We allow only float modes in the fp-registers */
++  if (regnr >= FIRST_FP_REGNUM
++      && regnr <= LAST_FP_REGNUM && GET_MODE_CLASS (mode) != MODE_FLOAT)
++    {
++      return 0;
++    }
++
++  switch (mode)
++    {
++    case DImode:              /* long long */
++    case DFmode:              /* double */
++    case SCmode:              /* __complex__ float */
++    case CSImode:             /* __complex__ int */
++      if (regnr < 4)
++      {                       /* long long int not supported in r12, sp, lr
++                                 or pc. */
++        return 0;
++      }
++      else
++      {
++        if (regnr % 2)        /* long long int has to be refered in even
++                                 registers. */
++          return 0;
++        else
++          return 1;
++      }
++    case CDImode:             /* __complex__ long long */
++    case DCmode:              /* __complex__ double */
++    case TImode:              /* 16 bytes */
++      if (regnr < 7)
++      return 0;
++      else if (regnr % 2)
++      return 0;
++      else
++      return 1;
++    default:
++      return 1;
++    }
++}
++
++
++int
++avr32_rnd_operands (rtx add, rtx shift)
++{
++  if (GET_CODE (shift) == CONST_INT &&
++      GET_CODE (add) == CONST_INT && INTVAL (shift) > 0)
++    {
++      if ((1 << (INTVAL (shift) - 1)) == INTVAL (add))
++      return TRUE;
++    }
++
++  return FALSE;
++}
++
++
++
++int
++avr32_const_ok_for_constraint_p (HOST_WIDE_INT value, char c, const char *str)
++{
++  switch (c)
++    {
++    case 'K':
++    case 'I':
++      {
++      HOST_WIDE_INT min_value = 0, max_value = 0;
++      char size_str[3];
++      int const_size;
++
++      size_str[0] = str[2];
++      size_str[1] = str[3];
++      size_str[2] = '\0';
++      const_size = atoi (size_str);
++
++      if (toupper (str[1]) == 'U')
++        {
++          min_value = 0;
++          max_value = (1 << const_size) - 1;
++        }
++      else if (toupper (str[1]) == 'S')
++        {
++          min_value = -(1 << (const_size - 1));
++          max_value = (1 << (const_size - 1)) - 1;
++        }
++
++      if (c == 'I')
++        {
++          value = -value;
++        }
++
++      if (value >= min_value && value <= max_value)
++        {
++          return 1;
++        }
++      break;
++      }
++    case 'M':
++      return avr32_mask_upper_bits_operand (GEN_INT (value), VOIDmode);
++    }
++
++  return 0;
++}
++
++
++/*Compute mask of which floating-point registers needs saving upon
++  entry to this function*/
++static unsigned long
++avr32_compute_save_fp_reg_mask (void)
++{
++  unsigned long func_type = avr32_current_func_type ();
++  unsigned int save_reg_mask = 0;
++  unsigned int reg;
++  unsigned int max_reg = 7;
++  int save_all_call_used_regs = FALSE;
++
++  /* This only applies for hardware floating-point implementation. */
++  if (!TARGET_HARD_FLOAT)
++    return 0;
++
++  if (IS_INTERRUPT (func_type))
++    {
++
++      /* Interrupt functions must not corrupt any registers, even call
++         clobbered ones.  If this is a leaf function we can just examine the
++         registers used by the RTL, but otherwise we have to assume that
++         whatever function is called might clobber anything, and so we have
++         to save all the call-clobbered registers as well.  */
++      max_reg = 13;
++      save_all_call_used_regs = !current_function_is_leaf;
++    }
++
++  /* All used registers used must be saved */
++  for (reg = 0; reg <= max_reg; reg++)
++    if (regs_ever_live[INTERNAL_FP_REGNUM (reg)]
++      || (save_all_call_used_regs
++          && call_used_regs[INTERNAL_FP_REGNUM (reg)]))
++      save_reg_mask |= (1 << reg);
++
++  return save_reg_mask;
++}
++
++/*Compute mask of registers which needs saving upon function entry */
++static unsigned long
++avr32_compute_save_reg_mask (int push)
++{
++  unsigned long func_type;
++  unsigned int save_reg_mask = 0;
++  unsigned int reg;
++
++  func_type = avr32_current_func_type ();
++
++  if (IS_INTERRUPT (func_type))
++    {
++      unsigned int max_reg = 12;
++
++
++      /* Get the banking scheme for the interrupt */
++      switch (func_type)
++      {
++      case AVR32_FT_ISR_FULL:
++        max_reg = 0;
++        break;
++      case AVR32_FT_ISR_HALF:
++        max_reg = 7;
++        break;
++      case AVR32_FT_ISR_NONE:
++        max_reg = 12;
++        break;
++      }
++
++      /* Interrupt functions must not corrupt any registers, even call
++         clobbered ones.  If this is a leaf function we can just examine the
++         registers used by the RTL, but otherwise we have to assume that
++         whatever function is called might clobber anything, and so we have
++         to save all the call-clobbered registers as well.  */
++
++      /* Need not push the registers r8-r12 for AVR32A architectures, as this
++         is automatially done in hardware. We also do not have any shadow
++         registers. */
++      if (avr32_arch->uarch_type == UARCH_TYPE_AVR32A)
++      {
++        max_reg = 7;
++        func_type = AVR32_FT_ISR_NONE;
++      }
++
++      /* All registers which are used and is not shadowed must be saved */
++      for (reg = 0; reg <= max_reg; reg++)
++      if (regs_ever_live[INTERNAL_REGNUM (reg)]
++          || (!current_function_is_leaf
++              && call_used_regs[INTERNAL_REGNUM (reg)]))
++        save_reg_mask |= (1 << reg);
++
++      /* Check LR */
++      if ((regs_ever_live[LR_REGNUM] || !current_function_is_leaf || frame_pointer_needed) && (func_type == AVR32_FT_ISR_NONE)        /* Only
++                                                                                                                                 non-shadowed
++                                                                                                                                 register
++                                                                                                                                 models
++                                                                                                                               */ )
++      save_reg_mask |= (1 << ASM_REGNUM (LR_REGNUM));
++
++      /* Make sure that the GOT register is pushed. */
++      if (max_reg >= ASM_REGNUM (PIC_OFFSET_TABLE_REGNUM)
++        && current_function_uses_pic_offset_table)
++      save_reg_mask |= (1 << ASM_REGNUM (PIC_OFFSET_TABLE_REGNUM));
++
++    }
++  else
++    {
++      int use_pushm = optimize_size;
++
++      /* In the normal case we only need to save those registers which are
++         call saved and which are used by this function.  */
++      for (reg = 0; reg <= 7; reg++)
++      if (regs_ever_live[INTERNAL_REGNUM (reg)]
++          && !call_used_regs[INTERNAL_REGNUM (reg)])
++        save_reg_mask |= (1 << reg);
++
++      /* Make sure that the GOT register is pushed. */
++      if (current_function_uses_pic_offset_table)
++      save_reg_mask |= (1 << ASM_REGNUM (PIC_OFFSET_TABLE_REGNUM));
++
++
++      /* If we optimize for size and do not have anonymous arguments: use
++         popm/pushm always */
++      if (use_pushm)
++      {
++        if ((save_reg_mask & (1 << 0))
++            || (save_reg_mask & (1 << 1))
++            || (save_reg_mask & (1 << 2)) || (save_reg_mask & (1 << 3)))
++          save_reg_mask |= 0xf;
++
++        if ((save_reg_mask & (1 << 4))
++            || (save_reg_mask & (1 << 5))
++            || (save_reg_mask & (1 << 6)) || (save_reg_mask & (1 << 7)))
++          save_reg_mask |= 0xf0;
++
++        if ((save_reg_mask & (1 << 8)) || (save_reg_mask & (1 << 9)))
++          save_reg_mask |= 0x300;
++      }
++
++
++      /* Check LR */
++      if ((regs_ever_live[LR_REGNUM] || !current_function_is_leaf ||
++         (optimize_size && save_reg_mask) || frame_pointer_needed))
++      {
++        if (push)
++          {
++            /* Push/Pop LR */
++            save_reg_mask |= (1 << ASM_REGNUM (LR_REGNUM));
++          }
++        else
++          {
++            /* Pop PC */
++            save_reg_mask |= (1 << ASM_REGNUM (PC_REGNUM));
++          }
++      }
++    }
++
++  return save_reg_mask;
++}
++
++/*Compute total size in bytes of all saved registers  */
++static int
++avr32_get_reg_mask_size (int reg_mask)
++{
++  int reg, size;
++  size = 0;
++
++  for (reg = 0; reg <= 15; reg++)
++    if (reg_mask & (1 << reg))
++      size += 4;
++
++  return size;
++}
++
++/*Get a register from one of the registers which are saved onto the stack
++  upon function entry */
++
++static int
++avr32_get_saved_reg (int save_reg_mask)
++{
++  unsigned int reg;
++
++  /* Find the first register which is saved in the saved_reg_mask */
++  for (reg = 0; reg <= 15; reg++)
++    if (save_reg_mask & (1 << reg))
++      return reg;
++
++  return -1;
++}
++
++/* Return 1 if it is possible to return using a single instruction.  */
++int
++avr32_use_return_insn (int iscond)
++{
++  unsigned int func_type = avr32_current_func_type ();
++  unsigned long saved_int_regs;
++  unsigned long saved_fp_regs;
++
++  /* Never use a return instruction before reload has run.  */
++  if (!reload_completed)
++    return 0;
++
++  /* Must adjust the stack for vararg functions. */
++  if (current_function_args_info.uses_anonymous_args)
++    return 0;
++
++  /* If there a stack adjstment.  */
++  if (get_frame_size ())
++    return 0;
++
++  saved_int_regs = avr32_compute_save_reg_mask (TRUE);
++  saved_fp_regs = avr32_compute_save_fp_reg_mask ();
++
++  /* Functions which have saved fp-regs on the stack can not be performed in
++     one instruction */
++  if (saved_fp_regs)
++    return 0;
++
++  /* Conditional returns can not be performed in one instruction if we need
++     to restore registers from the stack */
++  if (iscond && saved_int_regs)
++    return 0;
++
++  /* Conditional return can not be used for interrupt handlers. */
++  if (iscond && IS_INTERRUPT (func_type))
++    return 0;
++
++  /* For interrupt handlers which needs to pop registers */
++  if (saved_int_regs && IS_INTERRUPT (func_type))
++    return 0;
++
++
++  /* If there are saved registers but the LR isn't saved, then we need two
++     instructions for the return.  */
++  if (saved_int_regs && !(saved_int_regs & (1 << ASM_REGNUM (LR_REGNUM))))
++    return 0;
++
++
++  return 1;
++}
++
++
++/*Generate some function prologue info in the assembly file*/
++
++void
++avr32_target_asm_function_prologue (FILE * f, HOST_WIDE_INT frame_size)
++{
++  if (IS_NAKED (avr32_current_func_type ()))
++    fprintf (f,
++           "\t# Function is naked: Prologue and epilogue provided by programmer\n");
++
++  if (IS_INTERRUPT (avr32_current_func_type ()))
++    {
++      switch (avr32_current_func_type ())
++      {
++      case AVR32_FT_ISR_FULL:
++        fprintf (f,
++                 "\t# Interrupt Function: Fully shadowed register file\n");
++        break;
++      case AVR32_FT_ISR_HALF:
++        fprintf (f,
++                 "\t# Interrupt Function: Half shadowed register file\n");
++        break;
++      default:
++      case AVR32_FT_ISR_NONE:
++        fprintf (f, "\t# Interrupt Function: No shadowed register file\n");
++        break;
++      }
++    }
++
++
++  fprintf (f, "\t# args = %i, frame = %li, pretend = %i\n",
++         current_function_args_size, frame_size,
++         current_function_pretend_args_size);
++
++  fprintf (f, "\t# frame_needed = %i, leaf_function = %i\n",
++         frame_pointer_needed, current_function_is_leaf);
++
++  fprintf (f, "\t# uses_anonymous_args = %i\n",
++         current_function_args_info.uses_anonymous_args);
++}
++
++
++/* Generate and emit an insn that we will recognize as a pushm or stm.
++   Unfortunately, since this insn does not reflect very well the actual
++   semantics of the operation, we need to annotate the insn for the benefit
++   of DWARF2 frame unwind information.  */
++
++int avr32_convert_to_reglist16 (int reglist8_vect);
++
++static rtx
++emit_multi_reg_push (int reglist, int usePUSHM)
++{
++  rtx insn;
++  rtx dwarf;
++  rtx tmp;
++  rtx reg;
++  int i;
++  int nr_regs;
++  int index = 0;
++
++  if (usePUSHM)
++    {
++      insn = emit_insn (gen_pushm (gen_rtx_CONST_INT (SImode, reglist)));
++      reglist = avr32_convert_to_reglist16 (reglist);
++    }
++  else
++    {
++      insn = emit_insn (gen_stm (stack_pointer_rtx,
++                               gen_rtx_CONST_INT (SImode, reglist),
++                               gen_rtx_CONST_INT (SImode, 1)));
++    }
++
++  nr_regs = avr32_get_reg_mask_size (reglist) / 4;
++  dwarf = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (nr_regs + 1));
++
++  for (i = 15; i >= 0; i--)
++    {
++      if (reglist & (1 << i))
++      {
++        reg = gen_rtx_REG (SImode, INTERNAL_REGNUM (i));
++        tmp = gen_rtx_SET (VOIDmode,
++                           gen_rtx_MEM (SImode,
++                                        plus_constant (stack_pointer_rtx,
++                                                       4 * index)), reg);
++        RTX_FRAME_RELATED_P (tmp) = 1;
++        XVECEXP (dwarf, 0, 1 + index++) = tmp;
++      }
++    }
++
++  tmp = gen_rtx_SET (SImode,
++                   stack_pointer_rtx,
++                   gen_rtx_PLUS (SImode,
++                                 stack_pointer_rtx,
++                                 GEN_INT (-4 * nr_regs)));
++  RTX_FRAME_RELATED_P (tmp) = 1;
++  XVECEXP (dwarf, 0, 0) = tmp;
++  REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR, dwarf,
++                                      REG_NOTES (insn));
++  return insn;
++}
++
++
++static rtx
++emit_multi_fp_reg_push (int reglist)
++{
++  rtx insn;
++  rtx dwarf;
++  rtx tmp;
++  rtx reg;
++  int i;
++  int nr_regs;
++  int index = 0;
++
++  insn = emit_insn (gen_stm_fp (stack_pointer_rtx,
++                              gen_rtx_CONST_INT (SImode, reglist),
++                              gen_rtx_CONST_INT (SImode, 1)));
++
++  nr_regs = avr32_get_reg_mask_size (reglist) / 4;
++  dwarf = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (nr_regs + 1));
++
++  for (i = 15; i >= 0; i--)
++    {
++      if (reglist & (1 << i))
++      {
++        reg = gen_rtx_REG (SImode, INTERNAL_FP_REGNUM (i));
++        tmp = gen_rtx_SET (VOIDmode,
++                           gen_rtx_MEM (SImode,
++                                        plus_constant (stack_pointer_rtx,
++                                                       4 * index)), reg);
++        RTX_FRAME_RELATED_P (tmp) = 1;
++        XVECEXP (dwarf, 0, 1 + index++) = tmp;
++      }
++    }
++
++  tmp = gen_rtx_SET (SImode,
++                   stack_pointer_rtx,
++                   gen_rtx_PLUS (SImode,
++                                 stack_pointer_rtx,
++                                 GEN_INT (-4 * nr_regs)));
++  RTX_FRAME_RELATED_P (tmp) = 1;
++  XVECEXP (dwarf, 0, 0) = tmp;
++  REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR, dwarf,
++                                      REG_NOTES (insn));
++  return insn;
++}
++
++rtx
++avr32_gen_load_multiple (rtx * regs, int count, rtx from,
++                       int write_back, int in_struct_p, int scalar_p)
++{
++
++  rtx result;
++  int i = 0, j;
++
++  result =
++    gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count + (write_back ? 1 : 0)));
++
++  if (write_back)
++    {
++      XVECEXP (result, 0, 0)
++      = gen_rtx_SET (GET_MODE (from), from,
++                     plus_constant (from, count * 4));
++      i = 1;
++      count++;
++    }
++
++
++  for (j = 0; i < count; i++, j++)
++    {
++      rtx unspec;
++      rtx mem = gen_rtx_MEM (SImode, plus_constant (from, j * 4));
++      MEM_IN_STRUCT_P (mem) = in_struct_p;
++      MEM_SCALAR_P (mem) = scalar_p;
++      unspec = gen_rtx_UNSPEC (VOIDmode, gen_rtvec (1, mem), UNSPEC_LDM);
++      XVECEXP (result, 0, i) = gen_rtx_SET (VOIDmode, regs[j], unspec);
++    }
++
++  return result;
++}
++
++
++rtx
++avr32_gen_store_multiple (rtx * regs, int count, rtx to,
++                        int in_struct_p, int scalar_p)
++{
++  rtx result;
++  int i = 0, j;
++
++  result = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
++
++  for (j = 0; i < count; i++, j++)
++    {
++      rtx mem = gen_rtx_MEM (SImode, plus_constant (to, j * 4));
++      MEM_IN_STRUCT_P (mem) = in_struct_p;
++      MEM_SCALAR_P (mem) = scalar_p;
++      XVECEXP (result, 0, i)
++      = gen_rtx_SET (VOIDmode, mem,
++                     gen_rtx_UNSPEC (VOIDmode,
++                                     gen_rtvec (1, regs[j]),
++                                     UNSPEC_STORE_MULTIPLE));
++    }
++
++  return result;
++}
++
++
++/* Move a block of memory if it is word aligned or we support unaligned
++   word memory accesses. The size must be maximum 64 bytes. */
++
++int
++avr32_gen_movmemsi (rtx * operands)
++{
++  HOST_WIDE_INT bytes_to_go;
++  rtx src, dst;
++  rtx st_src, st_dst;
++  int ptr_offset = 0;
++  int block_size;
++  int dst_in_struct_p, src_in_struct_p;
++  int dst_scalar_p, src_scalar_p;
++  int unaligned;
++
++  if (GET_CODE (operands[2]) != CONST_INT
++      || GET_CODE (operands[3]) != CONST_INT
++      || INTVAL (operands[2]) > 64
++      || ((INTVAL (operands[3]) & 3) && !TARGET_UNALIGNED_WORD))
++    return 0;
++  
++  unaligned = (INTVAL (operands[3]) & 3) != 0;
++
++  block_size = 4;
++
++  st_dst = XEXP (operands[0], 0);
++  st_src = XEXP (operands[1], 0);
++
++  dst_in_struct_p = MEM_IN_STRUCT_P (operands[0]);
++  dst_scalar_p = MEM_SCALAR_P (operands[0]);
++  src_in_struct_p = MEM_IN_STRUCT_P (operands[1]);
++  src_scalar_p = MEM_SCALAR_P (operands[1]);
++
++  dst = copy_to_mode_reg (SImode, st_dst);
++  src = copy_to_mode_reg (SImode, st_src);
++
++  bytes_to_go = INTVAL (operands[2]);
++
++  while (bytes_to_go)
++    {
++      enum machine_mode move_mode;
++      /* Seems to be a problem with reloads for the movti pattern so this is
++         disabled until that problem is resolved */
++
++      /* if ( bytes_to_go >= GET_MODE_SIZE(TImode) ) move_mode = TImode; else
++       */
++      if ((bytes_to_go >= GET_MODE_SIZE (DImode)) && !unaligned)
++      move_mode = DImode;
++      else if (bytes_to_go >= GET_MODE_SIZE (SImode))
++      move_mode = SImode;
++      else
++      move_mode = QImode;
++
++      {
++      rtx dst_mem = gen_rtx_MEM (move_mode,
++                                 gen_rtx_PLUS (SImode, dst,
++                                               GEN_INT (ptr_offset)));
++      rtx src_mem = gen_rtx_MEM (move_mode,
++                                 gen_rtx_PLUS (SImode, src,
++                                               GEN_INT (ptr_offset)));
++      ptr_offset += GET_MODE_SIZE (move_mode);
++      bytes_to_go -= GET_MODE_SIZE (move_mode);
++
++      MEM_IN_STRUCT_P (dst_mem) = dst_in_struct_p;
++      MEM_SCALAR_P (dst_mem) = dst_scalar_p;
++
++      MEM_IN_STRUCT_P (src_mem) = src_in_struct_p;
++      MEM_SCALAR_P (src_mem) = src_scalar_p;
++      emit_move_insn (dst_mem, src_mem);
++
++      }
++    }
++
++  return 1;
++}
++
++
++
++/*Expand the prologue instruction*/
++void
++avr32_expand_prologue (void)
++{
++  rtx insn, dwarf;
++  unsigned long saved_reg_mask, saved_fp_reg_mask;
++  int reglist8 = 0;
++
++  /* Naked functions does not have a prologue */
++  if (IS_NAKED (avr32_current_func_type ()))
++    return;
++
++  saved_reg_mask = avr32_compute_save_reg_mask (TRUE);
++
++  if (saved_reg_mask)
++    {
++      /* Must push used registers */
++
++      /* Should we use POPM or LDM? */
++      int usePUSHM = TRUE;
++      reglist8 = 0;
++      if (((saved_reg_mask & (1 << 0)) ||
++         (saved_reg_mask & (1 << 1)) ||
++         (saved_reg_mask & (1 << 2)) || (saved_reg_mask & (1 << 3))))
++      {
++        /* One of R0-R3 should at least be pushed */
++        if (((saved_reg_mask & (1 << 0)) &&
++             (saved_reg_mask & (1 << 1)) &&
++             (saved_reg_mask & (1 << 2)) && (saved_reg_mask & (1 << 3))))
++          {
++            /* All should be pushed */
++            reglist8 |= 0x01;
++          }
++        else
++          {
++            usePUSHM = FALSE;
++          }
++      }
++
++      if (((saved_reg_mask & (1 << 4)) ||
++         (saved_reg_mask & (1 << 5)) ||
++         (saved_reg_mask & (1 << 6)) || (saved_reg_mask & (1 << 7))))
++      {
++        /* One of R4-R7 should at least be pushed */
++        if (((saved_reg_mask & (1 << 4)) &&
++             (saved_reg_mask & (1 << 5)) &&
++             (saved_reg_mask & (1 << 6)) && (saved_reg_mask & (1 << 7))))
++          {
++            if (usePUSHM)
++              /* All should be pushed */
++              reglist8 |= 0x02;
++          }
++        else
++          {
++            usePUSHM = FALSE;
++          }
++      }
++
++      if (((saved_reg_mask & (1 << 8)) || (saved_reg_mask & (1 << 9))))
++      {
++        /* One of R8-R9 should at least be pushed */
++        if (((saved_reg_mask & (1 << 8)) && (saved_reg_mask & (1 << 9))))
++          {
++            if (usePUSHM)
++              /* All should be pushed */
++              reglist8 |= 0x04;
++          }
++        else
++          {
++            usePUSHM = FALSE;
++          }
++      }
++
++      if (saved_reg_mask & (1 << 10))
++      reglist8 |= 0x08;
++
++      if (saved_reg_mask & (1 << 11))
++      reglist8 |= 0x10;
++
++      if (saved_reg_mask & (1 << 12))
++      reglist8 |= 0x20;
++
++      if (saved_reg_mask & (1 << ASM_REGNUM (LR_REGNUM)))
++      {
++        /* Push LR */
++        reglist8 |= 0x40;
++      }
++
++      if (usePUSHM)
++      {
++        insn = emit_multi_reg_push (reglist8, TRUE);
++      }
++      else
++      {
++        insn = emit_multi_reg_push (saved_reg_mask, FALSE);
++      }
++      RTX_FRAME_RELATED_P (insn) = 1;
++
++      /* Prevent this instruction from being scheduled after any other
++         instructions.  */
++      emit_insn (gen_blockage ());
++    }
++
++  saved_fp_reg_mask = avr32_compute_save_fp_reg_mask ();
++  if (saved_fp_reg_mask)
++    {
++      insn = emit_multi_fp_reg_push (saved_fp_reg_mask);
++      RTX_FRAME_RELATED_P (insn) = 1;
++
++      /* Prevent this instruction from being scheduled after any other
++         instructions.  */
++      emit_insn (gen_blockage ());
++    }
++
++  /* Set frame pointer */
++  if (frame_pointer_needed)
++    {
++      insn = emit_move_insn (frame_pointer_rtx, stack_pointer_rtx);
++      RTX_FRAME_RELATED_P (insn) = 1;
++    }
++
++  if (get_frame_size () > 0)
++    {
++      if (avr32_const_ok_for_constraint_p (get_frame_size (), 'K', "Ks21"))
++      {
++        insn = emit_insn (gen_rtx_SET (SImode,
++                                       stack_pointer_rtx,
++                                       gen_rtx_PLUS (SImode,
++                                                     stack_pointer_rtx,
++                                                     gen_rtx_CONST_INT
++                                                     (SImode,
++                                                      -get_frame_size
++                                                      ()))));
++        RTX_FRAME_RELATED_P (insn) = 1;
++      }
++      else
++      {
++        /* Immediate is larger than k21 We must either check if we can use
++           one of the pushed reegisters as temporary storage or we must
++           make us a temp register by pushing a register to the stack. */
++        rtx temp_reg, const_pool_entry, insn;
++        if (saved_reg_mask)
++          {
++            temp_reg =
++              gen_rtx_REG (SImode,
++                           INTERNAL_REGNUM (avr32_get_saved_reg
++                                            (saved_reg_mask)));
++          }
++        else
++          {
++            temp_reg = gen_rtx_REG (SImode, INTERNAL_REGNUM (7));
++            emit_move_insn (gen_rtx_MEM
++                            (SImode,
++                             gen_rtx_PRE_DEC (SImode, stack_pointer_rtx)),
++                            temp_reg);
++          }
++
++        const_pool_entry =
++          force_const_mem (SImode,
++                           gen_rtx_CONST_INT (SImode, get_frame_size ()));
++        emit_move_insn (temp_reg, const_pool_entry);
++
++        insn = emit_insn (gen_rtx_SET (SImode,
++                                       stack_pointer_rtx,
++                                       gen_rtx_MINUS (SImode,
++                                                      stack_pointer_rtx,
++                                                      temp_reg)));
++
++        dwarf = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
++                             gen_rtx_PLUS (SImode, stack_pointer_rtx,
++                                           GEN_INT (-get_frame_size ())));
++        REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
++                                              dwarf, REG_NOTES (insn));
++        RTX_FRAME_RELATED_P (insn) = 1;
++
++        if (!saved_reg_mask)
++          {
++            insn =
++              emit_move_insn (temp_reg,
++                              gen_rtx_MEM (SImode,
++                                           gen_rtx_POST_INC (SImode,
++                                                             gen_rtx_REG
++                                                             (SImode,
++                                                              13))));
++          }
++
++        /* Mark the temp register as dead */
++        REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_DEAD, temp_reg,
++                                              REG_NOTES (insn));
++
++
++      }
++
++      /* Prevent the the stack adjustment to be scheduled after any
++         instructions using the frame pointer.  */
++      emit_insn (gen_blockage ());
++    }
++
++  /* Load GOT */
++  if (flag_pic)
++    {
++      avr32_load_pic_register ();
++
++      /* gcc does not know that load or call instructions might use the pic
++         register so it might schedule these instructions before the loading
++         of the pic register. To avoid this emit a barrier for now. TODO!
++         Find out a better way to let gcc know which instructions might use
++         the pic register. */
++      emit_insn (gen_blockage ());
++    }
++  return;
++}
++
++void
++avr32_set_return_address (rtx source)
++{
++  rtx addr;
++  unsigned long saved_regs;
++
++  saved_regs = avr32_compute_save_reg_mask (TRUE);
++
++  if (!(saved_regs & (1 << ASM_REGNUM (LR_REGNUM))))
++    emit_move_insn (gen_rtx_REG (Pmode, LR_REGNUM), source);
++  else
++    {
++      if (frame_pointer_needed)
++      addr = gen_rtx_REG (Pmode, FRAME_POINTER_REGNUM);
++      else
++      /* FIXME: Need to use scratch register if frame is large */
++      addr = plus_constant (stack_pointer_rtx, get_frame_size ());
++
++      emit_move_insn (gen_rtx_MEM (Pmode, addr), source);
++    }
++}
++
++
++
++/* Return the length of INSN.  LENGTH is the initial length computed by
++   attributes in the machine-description file.  */
++
++int
++avr32_adjust_insn_length (rtx insn ATTRIBUTE_UNUSED,
++                        int length ATTRIBUTE_UNUSED)
++{
++  return length;
++}
++
++void
++avr32_output_return_instruction (int single_ret_inst ATTRIBUTE_UNUSED,
++                               int iscond ATTRIBUTE_UNUSED,
++                               rtx cond ATTRIBUTE_UNUSED, rtx r12_imm)
++{
++
++  unsigned long saved_reg_mask, saved_fp_reg_mask;
++  int insert_ret = TRUE;
++  int reglist8 = 0;
++  int stack_adjustment = get_frame_size ();
++  unsigned int func_type = avr32_current_func_type ();
++  FILE *f = asm_out_file;
++
++  /* Naked functions does not have an epilogue */
++  if (IS_NAKED (func_type))
++    return;
++
++  saved_fp_reg_mask = avr32_compute_save_fp_reg_mask ();
++
++  saved_reg_mask = avr32_compute_save_reg_mask (FALSE);
++
++  /* Reset frame pointer */
++  if (stack_adjustment > 0)
++    {
++      if (avr32_const_ok_for_constraint_p (stack_adjustment, 'I', "Is21"))
++      {
++        fprintf (f, "\tsub sp, %i # Reset Frame Pointer\n",
++                 -stack_adjustment);
++      }
++      else
++      {
++        /* TODO! Is it safe to use r8 as scratch?? */
++        fprintf (f, "\tmov r8, lo(%i) # Reset Frame Pointer\n",
++                 -stack_adjustment);
++        fprintf (f, "\torh r8, hi(%i) # Reset Frame Pointer\n",
++                 -stack_adjustment);
++        fprintf (f, "\tadd sp,r8  # Reset Frame Pointer\n");
++      }
++    }
++
++  if (saved_fp_reg_mask)
++    {
++      char reglist[64];               /* 64 bytes should be enough... */
++      avr32_make_fp_reglist_w (saved_fp_reg_mask, (char *) reglist);
++      fprintf (f, "\tldcm.w\tcp0, sp++, %s\n", reglist);
++      if (saved_fp_reg_mask & ~0xff)
++      {
++        saved_fp_reg_mask &= ~0xff;
++        avr32_make_fp_reglist_d (saved_fp_reg_mask, (char *) reglist);
++        fprintf (f, "\tldcm.d\tcp0, sp++, %s\n", reglist);
++      }
++    }
++
++  if (saved_reg_mask)
++    {
++      /* Must pop used registers */
++
++      /* Should we use POPM or LDM? */
++      int usePOPM = TRUE;
++      if (((saved_reg_mask & (1 << 0)) ||
++         (saved_reg_mask & (1 << 1)) ||
++         (saved_reg_mask & (1 << 2)) || (saved_reg_mask & (1 << 3))))
++      {
++        /* One of R0-R3 should at least be popped */
++        if (((saved_reg_mask & (1 << 0)) &&
++             (saved_reg_mask & (1 << 1)) &&
++             (saved_reg_mask & (1 << 2)) && (saved_reg_mask & (1 << 3))))
++          {
++            /* All should be popped */
++            reglist8 |= 0x01;
++          }
++        else
++          {
++            usePOPM = FALSE;
++          }
++      }
++
++      if (((saved_reg_mask & (1 << 4)) ||
++         (saved_reg_mask & (1 << 5)) ||
++         (saved_reg_mask & (1 << 6)) || (saved_reg_mask & (1 << 7))))
++      {
++        /* One of R0-R3 should at least be popped */
++        if (((saved_reg_mask & (1 << 4)) &&
++             (saved_reg_mask & (1 << 5)) &&
++             (saved_reg_mask & (1 << 6)) && (saved_reg_mask & (1 << 7))))
++          {
++            if (usePOPM)
++              /* All should be popped */
++              reglist8 |= 0x02;
++          }
++        else
++          {
++            usePOPM = FALSE;
++          }
++      }
++
++      if (((saved_reg_mask & (1 << 8)) || (saved_reg_mask & (1 << 9))))
++      {
++        /* One of R8-R9 should at least be pushed */
++        if (((saved_reg_mask & (1 << 8)) && (saved_reg_mask & (1 << 9))))
++          {
++            if (usePOPM)
++              /* All should be pushed */
++              reglist8 |= 0x04;
++          }
++        else
++          {
++            usePOPM = FALSE;
++          }
++      }
++
++      if (saved_reg_mask & (1 << 10))
++      reglist8 |= 0x08;
++
++      if (saved_reg_mask & (1 << 11))
++      reglist8 |= 0x10;
++
++      if (saved_reg_mask & (1 << 12))
++      reglist8 |= 0x20;
++
++      if (saved_reg_mask & (1 << ASM_REGNUM (LR_REGNUM)))
++      /* Pop LR */
++      reglist8 |= 0x40;
++
++      if (saved_reg_mask & (1 << ASM_REGNUM (PC_REGNUM)))
++      /* Pop LR into PC. */
++      reglist8 |= 0x80;
++
++      if (usePOPM)
++      {
++        char reglist[64];     /* 64 bytes should be enough... */
++        avr32_make_reglist8 (reglist8, (char *) reglist);
++
++        if (reglist8 & 0x80)
++          /* This instruction is also a return */
++          insert_ret = FALSE;
++
++        if (r12_imm && !insert_ret)
++          fprintf (f, "\tpopm    %s, r12=%li\n", reglist, INTVAL (r12_imm));
++        else
++          fprintf (f, "\tpopm    %s\n", reglist);
++
++      }
++      else
++      {
++        char reglist[64];     /* 64 bytes should be enough... */
++        avr32_make_reglist16 (saved_reg_mask, (char *) reglist);
++        if (saved_reg_mask & (1 << ASM_REGNUM (PC_REGNUM)))
++          /* This instruction is also a return */
++          insert_ret = FALSE;
++
++        if (r12_imm && !insert_ret)
++          fprintf (f, "\tldm    sp++, %s, r12=%li\n", reglist,
++                   INTVAL (r12_imm));
++        else
++          fprintf (f, "\tldm    sp++, %s\n", reglist);
++
++      }
++
++    }
++
++  if (IS_INTERRUPT (func_type))
++    {
++      fprintf (f, "\trete\n");
++    }
++  else if (insert_ret)
++    {
++      if (r12_imm)
++      fprintf (f, "\tretal    %li\n", INTVAL (r12_imm));
++      else
++      fprintf (f, "\tretal    r12\n");
++    }
++}
++
++/* Function for converting a fp-register mask to a
++   reglistCPD8 register list string. */
++void
++avr32_make_fp_reglist_d (int reglist_mask, char *reglist_string)
++{
++  int i;
++
++  /* Make sure reglist_string is empty */
++  reglist_string[0] = '\0';
++
++  for (i = 0; i < NUM_FP_REGS; i += 2)
++    {
++      if (reglist_mask & (1 << i))
++      {
++        strlen (reglist_string) ?
++          sprintf (reglist_string, "%s, %s-%s", reglist_string,
++                   reg_names[INTERNAL_FP_REGNUM (i)],
++                   reg_names[INTERNAL_FP_REGNUM (i + 1)]) :
++          sprintf (reglist_string, "%s-%s",
++                   reg_names[INTERNAL_FP_REGNUM (i)],
++                   reg_names[INTERNAL_FP_REGNUM (i + 1)]);
++      }
++    }
++}
++
++/* Function for converting a fp-register mask to a
++   reglistCP8 register list string. */
++void
++avr32_make_fp_reglist_w (int reglist_mask, char *reglist_string)
++{
++  int i;
++
++  /* Make sure reglist_string is empty */
++  reglist_string[0] = '\0';
++
++  for (i = 0; i < NUM_FP_REGS; ++i)
++    {
++      if (reglist_mask & (1 << i))
++      {
++        strlen (reglist_string) ?
++          sprintf (reglist_string, "%s, %s", reglist_string,
++                   reg_names[INTERNAL_FP_REGNUM (i)]) :
++          sprintf (reglist_string, "%s", reg_names[INTERNAL_FP_REGNUM (i)]);
++      }
++    }
++}
++
++void
++avr32_make_reglist16 (int reglist16_vect, char *reglist16_string)
++{
++  int i;
++
++  /* Make sure reglist16_string is empty */
++  reglist16_string[0] = '\0';
++
++  for (i = 0; i < 16; ++i)
++    {
++      if (reglist16_vect & (1 << i))
++      {
++        strlen (reglist16_string) ?
++          sprintf (reglist16_string, "%s, %s", reglist16_string,
++                   reg_names[INTERNAL_REGNUM (i)]) :
++          sprintf (reglist16_string, "%s", reg_names[INTERNAL_REGNUM (i)]);
++      }
++    }
++}
++
++int
++avr32_convert_to_reglist16 (int reglist8_vect)
++{
++  int reglist16_vect = 0;
++  if (reglist8_vect & 0x1)
++    reglist16_vect |= 0xF;
++  if (reglist8_vect & 0x2)
++    reglist16_vect |= 0xF0;
++  if (reglist8_vect & 0x4)
++    reglist16_vect |= 0x300;
++  if (reglist8_vect & 0x8)
++    reglist16_vect |= 0x400;
++  if (reglist8_vect & 0x10)
++    reglist16_vect |= 0x800;
++  if (reglist8_vect & 0x20)
++    reglist16_vect |= 0x1000;
++  if (reglist8_vect & 0x40)
++    reglist16_vect |= 0x4000;
++  if (reglist8_vect & 0x80)
++    reglist16_vect |= 0x8000;
++
++  return reglist16_vect;
++}
++
++void
++avr32_make_reglist8 (int reglist8_vect, char *reglist8_string)
++{
++  /* Make sure reglist8_string is empty */
++  reglist8_string[0] = '\0';
++
++  if (reglist8_vect & 0x1)
++    sprintf (reglist8_string, "r0-r3");
++  if (reglist8_vect & 0x2)
++    strlen (reglist8_string) ? sprintf (reglist8_string, "%s, r4-r7",
++                                      reglist8_string) :
++      sprintf (reglist8_string, "r4-r7");
++  if (reglist8_vect & 0x4)
++    strlen (reglist8_string) ? sprintf (reglist8_string, "%s, r8-r9",
++                                      reglist8_string) :
++      sprintf (reglist8_string, "r8-r9");
++  if (reglist8_vect & 0x8)
++    strlen (reglist8_string) ? sprintf (reglist8_string, "%s, r10",
++                                      reglist8_string) :
++      sprintf (reglist8_string, "r10");
++  if (reglist8_vect & 0x10)
++    strlen (reglist8_string) ? sprintf (reglist8_string, "%s, r11",
++                                      reglist8_string) :
++      sprintf (reglist8_string, "r11");
++  if (reglist8_vect & 0x20)
++    strlen (reglist8_string) ? sprintf (reglist8_string, "%s, r12",
++                                      reglist8_string) :
++      sprintf (reglist8_string, "r12");
++  if (reglist8_vect & 0x40)
++    strlen (reglist8_string) ? sprintf (reglist8_string, "%s, lr",
++                                      reglist8_string) :
++      sprintf (reglist8_string, "lr");
++  if (reglist8_vect & 0x80)
++    strlen (reglist8_string) ? sprintf (reglist8_string, "%s, pc",
++                                      reglist8_string) :
++      sprintf (reglist8_string, "pc");
++}
++
++int
++avr32_eh_return_data_regno (int n)
++{
++  if (n >= 0 && n <= 3)
++    return 8 + n;
++  else
++    return INVALID_REGNUM;
++}
++
++/* Compute the distance from register FROM to register TO.
++   These can be the arg pointer, the frame pointer or
++   the stack pointer.
++   Typical stack layout looks like this:
++
++       old stack pointer -> |    |
++                           ----
++                          |    | \
++                          |    |   saved arguments for
++                          |    |   vararg functions
++ arg_pointer  ->          |    | /
++                            --
++                          |    | \
++                          |    |   call saved
++                          |    |   registers
++                          |    | /
++  frame ptr    ->     --
++                          |    | \
++                          |    |   local
++                          |    |   variables
++  stack ptr -->            |    | /
++                            --
++                          |    | \
++                          |    |   outgoing
++                          |    |   arguments
++                          |    | /
++                            --
++
++  For a given funciton some or all of these stack compomnents
++  may not be needed, giving rise to the possibility of
++  eliminating some of the registers.
++
++  The values returned by this function must reflect the behaviour
++  of avr32_expand_prologue() and avr32_compute_save_reg_mask().
++
++  The sign of the number returned reflects the direction of stack
++  growth, so the values are positive for all eliminations except
++  from the soft frame pointer to the hard frame pointer.  */
++
++
++int
++avr32_initial_elimination_offset (int from, int to)
++{
++  int i;
++  int call_saved_regs = 0;
++  unsigned long saved_reg_mask, saved_fp_reg_mask;
++  unsigned int local_vars = get_frame_size ();
++
++  saved_reg_mask = avr32_compute_save_reg_mask (TRUE);
++  saved_fp_reg_mask = avr32_compute_save_fp_reg_mask ();
++
++  for (i = 0; i < 16; ++i)
++    {
++      if (saved_reg_mask & (1 << i))
++      call_saved_regs += 4;
++    }
++
++  for (i = 0; i < NUM_FP_REGS; ++i)
++    {
++      if (saved_fp_reg_mask & (1 << i))
++      call_saved_regs += 4;
++    }
++
++  switch (from)
++    {
++    case ARG_POINTER_REGNUM:
++      switch (to)
++      {
++      case STACK_POINTER_REGNUM:
++        return call_saved_regs + local_vars;
++      case FRAME_POINTER_REGNUM:
++        return call_saved_regs;
++      default:
++        abort ();
++      }
++    case FRAME_POINTER_REGNUM:
++      switch (to)
++      {
++      case STACK_POINTER_REGNUM:
++        return local_vars;
++      default:
++        abort ();
++      }
++    default:
++      abort ();
++    }
++}
++
++
++/*
++  Returns a rtx used when passing the next argument to a function.
++  avr32_init_cumulative_args() and avr32_function_arg_advance() sets witch
++  register to use.
++*/
++rtx
++avr32_function_arg (CUMULATIVE_ARGS * cum, enum machine_mode mode,
++                  tree type, int named)
++{
++  int index = -1;
++
++  HOST_WIDE_INT arg_size, arg_rsize;
++  if (type)
++    {
++      arg_size = int_size_in_bytes (type);
++    }
++  else
++    {
++      arg_size = GET_MODE_SIZE (mode);
++    }
++  arg_rsize = PUSH_ROUNDING (arg_size);
++
++  /*
++     The last time this macro is called, it is called with mode == VOIDmode,
++     and its result is passed to the call or call_value pattern as operands 2
++     and 3 respectively. */
++  if (mode == VOIDmode)
++    {
++      return gen_rtx_CONST_INT (SImode, 22);  /* ToDo: fixme. */
++    }
++
++  if ((*targetm.calls.must_pass_in_stack) (mode, type) || !named)
++    {
++      return NULL_RTX;
++    }
++
++  if (arg_rsize == 8)
++    {
++      /* use r11:r10 or r9:r8. */
++      if (!(GET_USED_INDEX (cum, 1) || GET_USED_INDEX (cum, 2)))
++      index = 1;
++      else if (!(GET_USED_INDEX (cum, 3) || GET_USED_INDEX (cum, 4)))
++      index = 3;
++      else
++      index = -1;
++    }
++  else if (arg_rsize == 4)
++    {                         /* Use first available register */
++      index = 0;
++      while (index <= LAST_CUM_REG_INDEX && GET_USED_INDEX (cum, index))
++      index++;
++      if (index > LAST_CUM_REG_INDEX)
++      index = -1;
++    }
++
++  SET_REG_INDEX (cum, index);
++
++  if (GET_REG_INDEX (cum) >= 0)
++    return gen_rtx_REG (mode,
++                      avr32_function_arg_reglist[GET_REG_INDEX (cum)]);
++
++  return NULL_RTX;
++}
++
++/*
++  Set the register used for passing the first argument to a function.
++*/
++void
++avr32_init_cumulative_args (CUMULATIVE_ARGS * cum, tree fntype,
++                          rtx libname ATTRIBUTE_UNUSED,
++                          tree fndecl ATTRIBUTE_UNUSED)
++{
++  /* Set all registers as unused. */
++  SET_INDEXES_UNUSED (cum);
++
++  /* Reset uses_anonymous_args */
++  cum->uses_anonymous_args = 0;
++
++  /* Reset size of stack pushed arguments */
++  cum->stack_pushed_args_size = 0;
++
++  /* If the function is returning a value passed in memory r12 is used as a
++     Return Value Pointer. */
++
++  if (fntype != 0 && avr32_return_in_memory (TREE_TYPE (fntype), fntype))
++    {
++      SET_REG_INDEX (cum, 0);
++      SET_USED_INDEX (cum, GET_REG_INDEX (cum));
++    }
++}
++
++/*
++  Set register used for passing the next argument to a function. Only the
++  Scratch Registers are used.
++
++              number  name
++                 15   r15  PC
++                 14   r14  LR
++                 13   r13 _SP_________
++     FIRST_CUM_REG 12   r12 _||_
++                 10   r11  ||
++                 11   r10 _||_  Scratch Registers
++                  8   r9   ||
++  LAST_SCRATCH_REG  9   r8  _\/_________
++                  6   r7   /\
++                  7   r6   ||
++                  4   r5   ||
++                  5   r4   ||
++                  2   r3   ||
++                  3   r2   ||
++                  0   r1   ||
++                  1   r0  _||_________
++
++*/
++void
++avr32_function_arg_advance (CUMULATIVE_ARGS * cum, enum machine_mode mode,
++                          tree type, int named ATTRIBUTE_UNUSED)
++{
++  HOST_WIDE_INT arg_size, arg_rsize;
++
++  if (type)
++    {
++      arg_size = int_size_in_bytes (type);
++    }
++  else
++    {
++      arg_size = GET_MODE_SIZE (mode);
++    }
++  arg_rsize = PUSH_ROUNDING (arg_size);
++
++  /* It the argument had to be passed in stack, no register is used. */
++  if ((*targetm.calls.must_pass_in_stack) (mode, type))
++    {
++      cum->stack_pushed_args_size += PUSH_ROUNDING (int_size_in_bytes (type));
++      return;
++    }
++
++  /* Mark the used registers as "used". */
++  if (GET_REG_INDEX (cum) >= 0)
++    {
++      SET_USED_INDEX (cum, GET_REG_INDEX (cum));
++      if (arg_rsize == 8)
++      {
++        SET_USED_INDEX (cum, (GET_REG_INDEX (cum) + 1));
++      }
++    }
++  else
++    {
++      /* Had to use stack */
++      cum->stack_pushed_args_size += arg_rsize;
++    }
++}
++
++/*
++  Defines witch direction to go to find the next register to use if the
++  argument is larger then one register or for arguments shorter than an
++  int which is not promoted, such as the last part of structures with
++  size not a multiple of 4. */
++enum direction
++avr32_function_arg_padding (enum machine_mode mode ATTRIBUTE_UNUSED,
++                          tree type)
++{
++  /* Pad upward for all aggregates except byte and halfword sized aggregates
++     which can be passed in registers. */
++  if (type
++      && AGGREGATE_TYPE_P (type)
++      && (int_size_in_bytes (type) != 1)
++      && !((int_size_in_bytes (type) == 2)
++         && TYPE_ALIGN_UNIT (type) >= 2)
++      && (int_size_in_bytes (type) & 0x3))
++    {
++      return upward;
++    }
++
++  return downward;
++}
++
++/*
++  Return a rtx used for the return value from a function call.
++*/
++rtx
++avr32_function_value (tree type, tree func)
++{
++  if (avr32_return_in_memory (type, func))
++    return NULL_RTX;
++
++  if (int_size_in_bytes (type) <= 4)
++    if (avr32_return_in_msb (type))
++      /* Aggregates of size less than a word which does align the data in the
++         MSB must use SImode for r12. */
++      return gen_rtx_REG (SImode, RET_REGISTER);
++    else
++      return gen_rtx_REG (TYPE_MODE (type), RET_REGISTER);
++  else if (int_size_in_bytes (type) <= 8)
++    return gen_rtx_REG (TYPE_MODE (type), INTERNAL_REGNUM (11));
++
++  return NULL_RTX;
++}
++
++/*
++  Return a rtx used for the return value from a library function call.
++*/
++rtx
++avr32_libcall_value (enum machine_mode mode)
++{
++
++  if (GET_MODE_SIZE (mode) <= 4)
++    return gen_rtx_REG (mode, RET_REGISTER);
++  else if (GET_MODE_SIZE (mode) <= 8)
++    return gen_rtx_REG (mode, INTERNAL_REGNUM (11));
++  else
++    return NULL_RTX;
++}
++
++/* Return TRUE if X references a SYMBOL_REF.  */
++int
++symbol_mentioned_p (rtx x)
++{
++  const char *fmt;
++  int i;
++
++  if (GET_CODE (x) == SYMBOL_REF)
++    return 1;
++
++  fmt = GET_RTX_FORMAT (GET_CODE (x));
++
++  for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
++    {
++      if (fmt[i] == 'E')
++      {
++        int j;
++
++        for (j = XVECLEN (x, i) - 1; j >= 0; j--)
++          if (symbol_mentioned_p (XVECEXP (x, i, j)))
++            return 1;
++      }
++      else if (fmt[i] == 'e' && symbol_mentioned_p (XEXP (x, i)))
++      return 1;
++    }
++
++  return 0;
++}
++
++/* Return TRUE if X references a LABEL_REF.  */
++int
++label_mentioned_p (rtx x)
++{
++  const char *fmt;
++  int i;
++
++  if (GET_CODE (x) == LABEL_REF)
++    return 1;
++
++  fmt = GET_RTX_FORMAT (GET_CODE (x));
++  for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
++    {
++      if (fmt[i] == 'E')
++      {
++        int j;
++
++        for (j = XVECLEN (x, i) - 1; j >= 0; j--)
++          if (label_mentioned_p (XVECEXP (x, i, j)))
++            return 1;
++      }
++      else if (fmt[i] == 'e' && label_mentioned_p (XEXP (x, i)))
++      return 1;
++    }
++
++  return 0;
++}
++
++
++int
++avr32_legitimate_pic_operand_p (rtx x)
++{
++
++  /* We can't have const, this must be broken down to a symbol. */
++  if (GET_CODE (x) == CONST)
++    return FALSE;
++
++  /* Can't access symbols or labels via the constant pool either */
++  if ((GET_CODE (x) == SYMBOL_REF
++       && CONSTANT_POOL_ADDRESS_P (x)
++       && (symbol_mentioned_p (get_pool_constant (x))
++         || label_mentioned_p (get_pool_constant (x)))))
++    return FALSE;
++
++  return TRUE;
++}
++
++
++rtx
++legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
++                      rtx reg)
++{
++
++  if (GET_CODE (orig) == SYMBOL_REF || GET_CODE (orig) == LABEL_REF)
++    {
++      int subregs = 0;
++
++      if (reg == 0)
++      {
++        if (no_new_pseudos)
++          abort ();
++        else
++          reg = gen_reg_rtx (Pmode);
++
++        subregs = 1;
++      }
++
++      emit_move_insn (reg, orig);
++
++      /* Only set current function as using pic offset table if flag_pic is
++         set. This is because this function is also used if
++         TARGET_HAS_ASM_ADDR_PSEUDOS is set. */
++      if (flag_pic)
++      current_function_uses_pic_offset_table = 1;
++
++      /* Put a REG_EQUAL note on this insn, so that it can be optimized by
++         loop.  */
++      return reg;
++    }
++  else if (GET_CODE (orig) == CONST)
++    {
++      rtx base, offset;
++
++      if (flag_pic
++        && GET_CODE (XEXP (orig, 0)) == PLUS
++        && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
++      return orig;
++
++      if (reg == 0)
++      {
++        if (no_new_pseudos)
++          abort ();
++        else
++          reg = gen_reg_rtx (Pmode);
++      }
++
++      if (GET_CODE (XEXP (orig, 0)) == PLUS)
++      {
++        base =
++          legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
++        offset =
++          legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
++                                  base == reg ? 0 : reg);
++      }
++      else
++      abort ();
++
++      if (GET_CODE (offset) == CONST_INT)
++      {
++        /* The base register doesn't really matter, we only want to test
++           the index for the appropriate mode.  */
++        if (!avr32_const_ok_for_constraint_p (INTVAL (offset), 'I', "Is21"))
++          {
++            if (!no_new_pseudos)
++              offset = force_reg (Pmode, offset);
++            else
++              abort ();
++          }
++
++        if (GET_CODE (offset) == CONST_INT)
++          return plus_constant (base, INTVAL (offset));
++      }
++
++      return gen_rtx_PLUS (Pmode, base, offset);
++    }
++
++  return orig;
++}
++
++/* Generate code to load the PIC register.  */
++void
++avr32_load_pic_register (void)
++{
++  rtx l1, pic_tmp;
++  rtx global_offset_table;
++
++  if ((current_function_uses_pic_offset_table == 0) || TARGET_NO_INIT_GOT)
++    return;
++
++  if (!flag_pic)
++    abort ();
++
++  l1 = gen_label_rtx ();
++
++  global_offset_table = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
++  pic_tmp =
++    gen_rtx_CONST (Pmode,
++                 gen_rtx_MINUS (SImode, gen_rtx_LABEL_REF (Pmode, l1),
++                                global_offset_table));
++  emit_insn (gen_pic_load_addr
++           (pic_offset_table_rtx, force_const_mem (SImode, pic_tmp)));
++  emit_insn (gen_pic_compute_got_from_pc (pic_offset_table_rtx, l1));
++
++  /* Need to emit this whether or not we obey regdecls, since setjmp/longjmp
++     can cause life info to screw up.  */
++  emit_insn (gen_rtx_USE (VOIDmode, pic_offset_table_rtx));
++}
++
++
++
++/* This hook should return true if values of type type are returned at the most
++   significant end of a register (in other words, if they are padded at the
++   least significant end). You can assume that type is returned in a register;
++   the caller is required to check this.  Note that the register provided by
++   FUNCTION_VALUE must be able to hold the complete return value. For example,
++   if a 1-, 2- or 3-byte structure is returned at the most significant end of a
++   4-byte register, FUNCTION_VALUE should provide an SImode rtx. */
++bool
++avr32_return_in_msb (tree type ATTRIBUTE_UNUSED)
++{
++  /* if ( AGGREGATE_TYPE_P (type) ) if ((int_size_in_bytes(type) == 1) ||
++     ((int_size_in_bytes(type) == 2) && TYPE_ALIGN_UNIT(type) >= 2)) return
++     false; else return true; */
++
++  return false;
++}
++
++
++/*
++  Returns one if a certain function value is going to be returned in memory
++  and zero if it is going to be returned in a register.
++
++  BLKmode and all other modes that is larger than 64 bits are returned in
++  memory.
++*/
++bool
++avr32_return_in_memory (tree type, tree fntype ATTRIBUTE_UNUSED)
++{
++  if (TYPE_MODE (type) == VOIDmode)
++    return false;
++
++  if (int_size_in_bytes (type) > (2 * UNITS_PER_WORD)
++      || int_size_in_bytes (type) == -1)
++    {
++      return true;
++    }
++
++  /* If we have an aggregate then use the same mechanism as when checking if
++     it should be passed on the stack. */
++  if (type
++      && AGGREGATE_TYPE_P (type)
++      && (*targetm.calls.must_pass_in_stack) (TYPE_MODE (type), type))
++    return true;
++
++  return false;
++}
++
++
++/* Output the constant part of the trampoline.
++   lddpc    r0, pc[0x8:e] ; load static chain register
++   lddpc    pc, pc[0x8:e] ; jump to subrutine
++   .long    0          ; Address to static chain,
++                       ; filled in by avr32_initialize_trampoline()
++   .long    0          ; Address to subrutine,
++                       ; filled in by avr32_initialize_trampoline()
++*/
++void
++avr32_trampoline_template (FILE * file)
++{
++  fprintf (file, "\tlddpc    r0, pc[8]\n");
++  fprintf (file, "\tlddpc    pc, pc[8]\n");
++  /* make room for the address of the static chain. */
++  fprintf (file, "\t.long\t0\n");
++  /* make room for the address to the subrutine. */
++  fprintf (file, "\t.long\t0\n");
++}
++
++
++/*
++  Initialize the variable parts of a trampoline.
++*/
++void
++avr32_initialize_trampoline (rtx addr, rtx fnaddr, rtx static_chain)
++{
++  /* Store the address to the static chain. */
++  emit_move_insn (gen_rtx_MEM
++                (SImode, plus_constant (addr, TRAMPOLINE_SIZE - 4)),
++                static_chain);
++
++  /* Store the address to the function. */
++  emit_move_insn (gen_rtx_MEM (SImode, plus_constant (addr, TRAMPOLINE_SIZE)),
++                fnaddr);
++
++  emit_insn (gen_cache (gen_rtx_REG (SImode, 13),
++                      gen_rtx_CONST_INT (SImode,
++                                         AVR32_CACHE_INVALIDATE_ICACHE)));
++}
++
++/* Return nonzero if X is valid as an addressing register.  */
++int
++avr32_address_register_rtx_p (rtx x, int strict_p)
++{
++  int regno;
++
++  if (GET_CODE (x) != REG)
++    return 0;
++
++  regno = REGNO (x);
++
++  if (strict_p)
++    return REGNO_OK_FOR_BASE_P (regno);
++
++  return (regno <= LAST_REGNUM || regno >= FIRST_PSEUDO_REGISTER);
++}
++
++/* Return nonzero if INDEX is valid for an address index operand.  */
++int
++avr32_legitimate_index_p (enum machine_mode mode, rtx index, int strict_p)
++{
++  enum rtx_code code = GET_CODE (index);
++
++  if (mode == TImode)
++    return 0;
++
++  /* Standard coprocessor addressing modes.  */
++  if (code == CONST_INT)
++    {
++      if (TARGET_HARD_FLOAT && GET_MODE_CLASS (mode) == MODE_FLOAT)
++      /* Coprocessor mem insns has a smaller reach than ordinary mem insns */
++      return CONST_OK_FOR_CONSTRAINT_P (INTVAL (index), 'K', "Ku14");
++      else
++      return CONST_OK_FOR_CONSTRAINT_P (INTVAL (index), 'K', "Ks16");
++    }
++
++  if (avr32_address_register_rtx_p (index, strict_p))
++    return 1;
++
++  if (code == MULT)
++    {
++      rtx xiop0 = XEXP (index, 0);
++      rtx xiop1 = XEXP (index, 1);
++      return ((avr32_address_register_rtx_p (xiop0, strict_p)
++             && power_of_two_operand (xiop1, SImode)
++             && (INTVAL (xiop1) <= 8))
++            || (avr32_address_register_rtx_p (xiop1, strict_p)
++                && power_of_two_operand (xiop0, SImode)
++                && (INTVAL (xiop0) <= 8)));
++    }
++  else if (code == ASHIFT)
++    {
++      rtx op = XEXP (index, 1);
++
++      return (avr32_address_register_rtx_p (XEXP (index, 0), strict_p)
++            && GET_CODE (op) == CONST_INT
++            && INTVAL (op) > 0 && INTVAL (op) <= 3);
++    }
++
++  return 0;
++}
++
++/*
++  Used in the GO_IF_LEGITIMATE_ADDRESS macro. Returns a nonzero value if
++  the RTX x is a legitimate memory address.
++
++  Returns NO_REGS if the address is not legatime, GENERAL_REGS or ALL_REGS
++  if it is.
++*/
++
++/* Forward declaration*/
++int is_minipool_label (rtx label);
++
++int
++avr32_legitimate_address (enum machine_mode mode ATTRIBUTE_UNUSED,
++                        rtx x, int strict)
++{
++
++  switch (GET_CODE (x))
++    {
++    case REG:
++      return avr32_address_register_rtx_p (x, strict);
++    case CONST:
++      {
++      rtx label = avr32_find_symbol (x);
++      if (label
++          && 
++            ( (CONSTANT_POOL_ADDRESS_P (label)
++               && !(flag_pic
++                    && (symbol_mentioned_p (get_pool_constant (label))
++                        || label_mentioned_p (get_pool_constant(label)))))
++              /* TODO! Can this ever happen??? */
++              || ((GET_CODE (label) == LABEL_REF)
++                  && GET_CODE (XEXP (label, 0)) == CODE_LABEL
++                  && is_minipool_label (XEXP (label, 0)))))
++          {
++            return TRUE;
++          }
++      }
++      break;
++    case LABEL_REF:
++      if (GET_CODE (XEXP (x, 0)) == CODE_LABEL
++        && is_minipool_label (XEXP (x, 0)))
++      {
++        return TRUE;
++      }
++      break;
++    case SYMBOL_REF:
++      {
++      if (CONSTANT_POOL_ADDRESS_P (x)
++          && !(flag_pic
++               && (symbol_mentioned_p (get_pool_constant (x))
++                   || label_mentioned_p (get_pool_constant (x)))))
++        return TRUE;
++      /*
++         A symbol_ref is only legal if it is a function. If all of them are
++         legal, a pseudo reg that is a constant will be replaced by a
++         symbol_ref and make illegale code. SYMBOL_REF_FLAG is set by
++         ENCODE_SECTION_INFO. */
++      else if (SYMBOL_REF_RCALL_FUNCTION_P (x))
++        return TRUE;
++      break;
++      }
++    case PRE_DEC:             /* (pre_dec (...)) */
++    case POST_INC:            /* (post_inc (...)) */
++      return avr32_address_register_rtx_p (XEXP (x, 0), strict);
++    case PLUS:                        /* (plus (...) (...)) */
++      {
++      rtx xop0 = XEXP (x, 0);
++      rtx xop1 = XEXP (x, 1);
++
++      return ((avr32_address_register_rtx_p (xop0, strict)
++               && avr32_legitimate_index_p (mode, xop1, strict))
++              || (avr32_address_register_rtx_p (xop1, strict)
++                  && avr32_legitimate_index_p (mode, xop0, strict)));
++      }
++    default:
++      break;
++    }
++
++  return FALSE;
++}
++
++
++int
++avr32_const_double_immediate (rtx value)
++{
++  HOST_WIDE_INT hi, lo;
++
++  if (GET_CODE (value) != CONST_DOUBLE)
++    return FALSE;
++
++  if (GET_MODE (value) == DImode)
++    {
++      hi = CONST_DOUBLE_HIGH (value);
++      lo = CONST_DOUBLE_LOW (value);
++    }
++  else
++    {
++      HOST_WIDE_INT target_float[2];
++      hi = lo = 0;
++      real_to_target (target_float, CONST_DOUBLE_REAL_VALUE (value),
++                    GET_MODE (value));
++      lo = target_float[0];
++      hi = target_float[1];
++    }
++  if (avr32_const_ok_for_constraint_p (lo, 'K', "Ks21")
++      && ((GET_MODE (value) == SFmode)
++        || avr32_const_ok_for_constraint_p (hi, 'K', "Ks21")))
++    {
++      return TRUE;
++    }
++
++  return FALSE;
++}
++
++
++int
++avr32_legitimate_constant_p (rtx x)
++{
++  switch (GET_CODE (x))
++    {
++    case CONST_INT:
++      return avr32_const_ok_for_constraint_p (INTVAL (x), 'K', "Ks21");
++    case CONST_DOUBLE:
++      if (GET_MODE (x) == SFmode
++        || GET_MODE (x) == DFmode || GET_MODE (x) == DImode)
++      return avr32_const_double_immediate (x);
++      else
++      return 0;
++    case LABEL_REF:
++      return flag_pic || TARGET_HAS_ASM_ADDR_PSEUDOS;
++    case SYMBOL_REF:
++      return flag_pic || TARGET_HAS_ASM_ADDR_PSEUDOS;
++    case CONST:
++      /* We must handle this one in the movsi expansion in order for gcc not
++         to put it in the constant pool. */
++      return 0 /* flag_pic || TARGET_HAS_ASM_ADDR_PSEUDOS */ ;
++    case HIGH:
++    case CONST_VECTOR:
++      return 0;
++    default:
++      printf ("%s():\n", __FUNCTION__);
++      debug_rtx (x);
++      return 1;
++    }
++}
++
++
++/* Strip any special encoding from labels */
++const char *
++avr32_strip_name_encoding (const char *name)
++{
++  const char *stripped = name;
++
++  while (1)
++    {
++      switch (stripped[0])
++      {
++      case '#':
++        stripped = strchr (name + 1, '#') + 1;
++        break;
++      case '*':
++        stripped = &stripped[1];
++        break;
++      default:
++        return stripped;
++      }
++    }
++}
++
++
++
++/* Do anything needed before RTL is emitted for each function.  */
++static struct machine_function *
++avr32_init_machine_status (void)
++{
++  struct machine_function *machine;
++  machine =
++    (machine_function *) ggc_alloc_cleared (sizeof (machine_function));
++
++#if AVR32_FT_UNKNOWN != 0
++  machine->func_type = AVR32_FT_UNKNOWN;
++#endif
++
++  machine->minipool_label_head = 0;
++  machine->minipool_label_tail = 0;
++  return machine;
++}
++
++void
++avr32_init_expanders (void)
++{
++  /* Arrange to initialize and mark the machine per-function status.  */
++  init_machine_status = avr32_init_machine_status;
++}
++
++
++/* Return an RTX indicating where the return address to the
++   calling function can be found.  */
++
++rtx
++avr32_return_addr (int count, rtx frame ATTRIBUTE_UNUSED)
++{
++  if (count != 0)
++    return NULL_RTX;
++
++  return get_hard_reg_initial_val (Pmode, LR_REGNUM);
++}
++
++
++void
++avr32_encode_section_info (tree decl, rtx rtl, int first)
++{
++
++  if (first && DECL_P (decl))
++    {
++      /* Set SYMBOL_REG_FLAG for local functions */
++      if (!TREE_PUBLIC (decl) && TREE_CODE (decl) == FUNCTION_DECL)
++      {
++        if ((*targetm.binds_local_p) (decl))
++          {
++            SYMBOL_REF_FLAG (XEXP (rtl, 0)) = 1;
++          }
++      }
++    }
++}
++
++
++void
++avr32_asm_output_ascii (FILE * stream, char *ptr, int len)
++{
++  int i, i_new = 0;
++  char *new_ptr = xmalloc (4 * len);
++  if (new_ptr == NULL)
++    internal_error ("Out of memory.");
++
++  for (i = 0; i < len; i++)
++    {
++      if (ptr[i] == '\n')
++      {
++        new_ptr[i_new++] = '\\';
++        new_ptr[i_new++] = '0';
++        new_ptr[i_new++] = '1';
++        new_ptr[i_new++] = '2';
++      }
++      else if (ptr[i] == '\"')
++      {
++        new_ptr[i_new++] = '\\';
++        new_ptr[i_new++] = '\"';
++      }
++      else if (ptr[i] == '\\')
++      {
++        new_ptr[i_new++] = '\\';
++        new_ptr[i_new++] = '\\';
++      }
++      else if (ptr[i] == '\0' && i + 1 < len)
++      {
++        new_ptr[i_new++] = '\\';
++        new_ptr[i_new++] = '0';
++      }
++      else
++      {
++        new_ptr[i_new++] = ptr[i];
++      }
++    }
++
++  /* Terminate new_ptr. */
++  new_ptr[i_new] = '\0';
++  fprintf (stream, "\t.ascii\t\"%s\"\n", new_ptr);
++  free (new_ptr);
++}
++
++
++void
++avr32_asm_output_label (FILE * stream, const char *name)
++{
++  name = avr32_strip_name_encoding (name);
++
++  /* Print the label. */
++  assemble_name (stream, name);
++  fprintf (stream, ":\n");
++}
++
++
++
++void
++avr32_asm_weaken_label (FILE * stream, const char *name)
++{
++  fprintf (stream, "\t.weak ");
++  assemble_name (stream, name);
++  fprintf (stream, "\n");
++}
++
++/*
++  Checks if a labelref is equal to a reserved word in the assembler. If it is,
++  insert a '_' before the label name.
++*/
++void
++avr32_asm_output_labelref (FILE * stream, const char *name)
++{
++  int verbatim = FALSE;
++  const char *stripped = name;
++  int strip_finished = FALSE;
++
++  while (!strip_finished)
++    {
++      switch (stripped[0])
++      {
++      case '#':
++        stripped = strchr (name + 1, '#') + 1;
++        break;
++      case '*':
++        stripped = &stripped[1];
++        verbatim = TRUE;
++        break;
++      default:
++        strip_finished = TRUE;
++        break;
++      }
++    }
++
++  if (verbatim)
++    fputs (stripped, stream);
++  else
++    asm_fprintf (stream, "%U%s", stripped);
++}
++
++
++
++/*
++   Check if the comparison in compare_exp is redundant
++   for the condition given in next_cond given that the
++   needed flags are already set by an earlier instruction.
++   Uses cc_prev_status to check this.
++
++   Returns NULL_RTX if the compare is not redundant
++   or the new condition to use in the conditional
++   instruction if the compare is redundant.
++*/
++static rtx
++is_compare_redundant (rtx compare_exp, rtx next_cond)
++{
++  int z_flag_valid = FALSE;
++  int n_flag_valid = FALSE;
++  rtx new_cond;
++
++  if (GET_CODE (compare_exp) != COMPARE)
++    return NULL_RTX;
++
++
++  if (GET_MODE (compare_exp) != SImode)
++    return NULL_RTX;
++
++  if (rtx_equal_p (cc_prev_status.mdep.value, compare_exp))
++    {
++      /* cc0 already contains the correct comparison -> delete cmp insn */
++      return next_cond;
++    }
++
++  switch (cc_prev_status.mdep.flags)
++    {
++    case CC_SET_VNCZ:
++    case CC_SET_NCZ:
++      n_flag_valid = TRUE;
++    case CC_SET_CZ:
++    case CC_SET_Z:
++      z_flag_valid = TRUE;
++    }
++
++  if (cc_prev_status.mdep.value
++      && REG_P (XEXP (compare_exp, 0))
++      && REGNO (XEXP (compare_exp, 0)) == REGNO (cc_prev_status.mdep.value)
++      && GET_CODE (XEXP (compare_exp, 1)) == CONST_INT
++      && next_cond != NULL_RTX)
++    {
++      if (INTVAL (XEXP (compare_exp, 1)) == 0
++        && z_flag_valid
++        && (GET_CODE (next_cond) == EQ || GET_CODE (next_cond) == NE))
++      /* We can skip comparison Z flag is already reflecting ops[0] */
++      return next_cond;
++      else if (n_flag_valid
++             && ((INTVAL (XEXP (compare_exp, 1)) == 0
++                  && (GET_CODE (next_cond) == GE
++                      || GET_CODE (next_cond) == LT))
++                 || (INTVAL (XEXP (compare_exp, 1)) == -1
++                     && (GET_CODE (next_cond) == GT
++                         || GET_CODE (next_cond) == LE))))
++      {
++        /* We can skip comparison N flag is already reflecting ops[0],
++           which means that we can use the mi/pl conditions to check if
++           ops[0] is GE or LT 0. */
++        if ((GET_CODE (next_cond) == GE) || (GET_CODE (next_cond) == GT))
++          new_cond =
++            gen_rtx_UNSPEC (CCmode, gen_rtvec (2, cc0_rtx, const0_rtx),
++                            UNSPEC_COND_PL);
++        else
++          new_cond =
++            gen_rtx_UNSPEC (CCmode, gen_rtvec (2, cc0_rtx, const0_rtx),
++                            UNSPEC_COND_MI);
++        return new_cond;
++      }
++    }
++  return NULL_RTX;
++}
++
++/* Updates cc_status.  */
++void
++avr32_notice_update_cc (rtx exp, rtx insn)
++{
++  switch (get_attr_cc (insn))
++    {
++    case CC_CALL_SET:
++      CC_STATUS_INIT;
++      FPCC_STATUS_INIT;
++      /* Check if the function call returns a value in r12 */
++      if (REG_P (recog_data.operand[0])
++        && REGNO (recog_data.operand[0]) == RETVAL_REGNUM)
++      {
++        cc_status.flags = 0;
++        cc_status.mdep.value =
++          gen_rtx_COMPARE (SImode, recog_data.operand[0], const0_rtx);
++        cc_status.mdep.flags = CC_SET_VNCZ;
++
++      }
++      break;
++    case CC_COMPARE:
++      /* Check that compare will not be optimized away if so nothing should
++         be done */
++      if (is_compare_redundant (SET_SRC (exp), get_next_insn_cond (insn))
++        == NULL_RTX)
++      {
++
++        /* Reset the nonstandard flag */
++        CC_STATUS_INIT;
++        cc_status.flags = 0;
++        cc_status.mdep.value = SET_SRC (exp);
++        cc_status.mdep.flags = CC_SET_VNCZ;
++      }
++      break;
++    case CC_FPCOMPARE:
++      /* Check that floating-point compare will not be optimized away if so
++         nothing should be done */
++      if (!rtx_equal_p (cc_prev_status.mdep.fpvalue, SET_SRC (exp)))
++      {
++        /* cc0 already contains the correct comparison -> delete cmp insn */
++        /* Reset the nonstandard flag */
++        cc_status.mdep.fpvalue = SET_SRC (exp);
++        cc_status.mdep.fpflags = CC_SET_CZ;
++      }
++      break;
++    case CC_FROM_FPCC:
++      /* Flags are updated with flags from Floating-point coprocessor, set
++         CC_NOT_SIGNED flag since the flags are set so that unsigned
++         condidion codes can be used directly. */
++      CC_STATUS_INIT;
++      cc_status.flags = CC_NOT_SIGNED;
++      cc_status.mdep.value = cc_status.mdep.fpvalue;
++      cc_status.mdep.flags = cc_status.mdep.fpflags;
++      break;
++    case CC_BLD:
++      /* Bit load is kind of like an inverted testsi, because the Z flag is
++         inverted */
++      CC_STATUS_INIT;
++      cc_status.flags = CC_INVERTED;
++      cc_status.mdep.value = SET_SRC (exp);
++      cc_status.mdep.flags = CC_SET_Z;
++      break;
++    case CC_NONE:
++      /* Insn does not affect CC at all. Check if the instruction updates
++         some of the register currently reflected in cc0 */
++
++      if ((GET_CODE (exp) == SET)
++        && (cc_status.value1 || cc_status.value2 || cc_status.mdep.value)
++        && (reg_mentioned_p (SET_DEST (exp), cc_status.value1)
++            || reg_mentioned_p (SET_DEST (exp), cc_status.value2)
++            || reg_mentioned_p (SET_DEST (exp), cc_status.mdep.value)))
++      {
++        CC_STATUS_INIT;
++      }
++
++      /* If this is a parallel we must step through each of the parallel
++         expressions */
++      if (GET_CODE (exp) == PARALLEL)
++      {
++        int i;
++        for (i = 0; i < XVECLEN (exp, 0); ++i)
++          {
++            rtx vec_exp = XVECEXP (exp, 0, i);
++            if ((GET_CODE (vec_exp) == SET)
++                && (cc_status.value1 || cc_status.value2
++                    || cc_status.mdep.value)
++                && (reg_mentioned_p (SET_DEST (vec_exp), cc_status.value1)
++                    || reg_mentioned_p (SET_DEST (vec_exp),
++                                        cc_status.value2)
++                    || reg_mentioned_p (SET_DEST (vec_exp),
++                                        cc_status.mdep.value)))
++              {
++                CC_STATUS_INIT;
++              }
++          }
++      }
++
++      /* Check if we have memory opartions with post_inc or pre_dec on the
++         register currently reflected in cc0 */
++      if (GET_CODE (exp) == SET
++        && GET_CODE (SET_SRC (exp)) == MEM
++        && (GET_CODE (XEXP (SET_SRC (exp), 0)) == POST_INC
++            || GET_CODE (XEXP (SET_SRC (exp), 0)) == PRE_DEC)
++        &&
++        (reg_mentioned_p
++         (XEXP (XEXP (SET_SRC (exp), 0), 0), cc_status.value1)
++         || reg_mentioned_p (XEXP (XEXP (SET_SRC (exp), 0), 0),
++                             cc_status.value2)
++         || reg_mentioned_p (XEXP (XEXP (SET_SRC (exp), 0), 0),
++                             cc_status.mdep.value)))
++      CC_STATUS_INIT;
++
++      if (GET_CODE (exp) == SET
++        && GET_CODE (SET_DEST (exp)) == MEM
++        && (GET_CODE (XEXP (SET_DEST (exp), 0)) == POST_INC
++            || GET_CODE (XEXP (SET_DEST (exp), 0)) == PRE_DEC)
++        &&
++        (reg_mentioned_p
++         (XEXP (XEXP (SET_DEST (exp), 0), 0), cc_status.value1)
++         || reg_mentioned_p (XEXP (XEXP (SET_DEST (exp), 0), 0),
++                             cc_status.value2)
++         || reg_mentioned_p (XEXP (XEXP (SET_DEST (exp), 0), 0),
++                             cc_status.mdep.value)))
++      CC_STATUS_INIT;
++      break;
++
++    case CC_SET_VNCZ:
++      CC_STATUS_INIT;
++      cc_status.mdep.value = recog_data.operand[0];
++      cc_status.mdep.flags = CC_SET_VNCZ;
++      break;
++
++    case CC_SET_NCZ:
++      CC_STATUS_INIT;
++      cc_status.mdep.value = recog_data.operand[0];
++      cc_status.mdep.flags = CC_SET_NCZ;
++      break;
++
++    case CC_SET_CZ:
++      CC_STATUS_INIT;
++      cc_status.mdep.value = recog_data.operand[0];
++      cc_status.mdep.flags = CC_SET_CZ;
++      break;
++
++    case CC_SET_Z:
++      CC_STATUS_INIT;
++      cc_status.mdep.value = recog_data.operand[0];
++      cc_status.mdep.flags = CC_SET_Z;
++      break;
++
++    case CC_CLOBBER:
++      CC_STATUS_INIT;
++      break;
++
++    default:
++      CC_STATUS_INIT;
++    }
++}
++
++
++/*
++  Outputs to stdio stream stream the assembler syntax for an instruction
++  operand x. x is an RTL expression.
++*/
++void
++avr32_print_operand (FILE * stream, rtx x, int code)
++{
++  int error = 0;
++
++  switch (GET_CODE (x))
++    {
++    case UNSPEC:
++      switch (XINT (x, 1))
++      {
++      case UNSPEC_COND_PL:
++        if (code == 'i')
++          fputs ("mi", stream);
++        else
++          fputs ("pl", stream);
++        break;
++      case UNSPEC_COND_MI:
++        if (code == 'i')
++          fputs ("pl", stream);
++        else
++          fputs ("mi", stream);
++        break;
++      default:
++        error = 1;
++      }
++      break;
++    case EQ:
++      if (code == 'i')
++      fputs ("ne", stream);
++      else
++      fputs ("eq", stream);
++      break;
++    case NE:
++      if (code == 'i')
++      fputs ("eq", stream);
++      else
++      fputs ("ne", stream);
++      break;
++    case GT:
++      if (code == 'i')
++      fputs ("le", stream);
++      else
++      fputs ("gt", stream);
++      break;
++    case GTU:
++      if (code == 'i')
++      fputs ("ls", stream);
++      else
++      fputs ("hi", stream);
++      break;
++    case LT:
++      if (code == 'i')
++      fputs ("ge", stream);
++      else
++      fputs ("lt", stream);
++      break;
++    case LTU:
++      if (code == 'i')
++      fputs ("hs", stream);
++      else
++      fputs ("lo", stream);
++      break;
++    case GE:
++      if (code == 'i')
++      fputs ("lt", stream);
++      else
++      fputs ("ge", stream);
++      break;
++    case GEU:
++      if (code == 'i')
++      fputs ("lo", stream);
++      else
++      fputs ("hs", stream);
++      break;
++    case LE:
++      if (code == 'i')
++      fputs ("gt", stream);
++      else
++      fputs ("le", stream);
++      break;
++    case LEU:
++      if (code == 'i')
++      fputs ("hi", stream);
++      else
++      fputs ("ls", stream);
++      break;
++    case CONST_INT:
++      {
++      int value = INTVAL (x);
++
++      if (code == 'i')
++        {
++          value++;
++        }
++
++      if (code == 'p')
++        {
++          /* Set to bit position of first bit set in immediate */
++          int i, bitpos = 32;
++          for (i = 0; i < 32; i++)
++            if (value & (1 << i))
++              {
++                bitpos = i;
++                break;
++              }
++          value = bitpos;
++        }
++
++      if (code == 'r')
++        {
++          /* Reglist 8 */
++          char op[50];
++          op[0] = '\0';
++
++          if (value & 0x01)
++            sprintf (op, "r0-r3");
++          if (value & 0x02)
++            strlen (op) ? sprintf (op, "%s, r4-r7", op) : sprintf (op,
++                                                                   "r4-r7");
++          if (value & 0x04)
++            strlen (op) ? sprintf (op, "%s, r8-r9", op) : sprintf (op,
++                                                                   "r8-r9");
++          if (value & 0x08)
++            strlen (op) ? sprintf (op, "%s, r10", op) : sprintf (op, "r10");
++          if (value & 0x10)
++            strlen (op) ? sprintf (op, "%s, r11", op) : sprintf (op, "r11");
++          if (value & 0x20)
++            strlen (op) ? sprintf (op, "%s, r12", op) : sprintf (op, "r12");
++          if (value & 0x40)
++            strlen (op) ? sprintf (op, "%s, lr", op) : sprintf (op, "lr");
++          if (value & 0x80)
++            strlen (op) ? sprintf (op, "%s, pc", op) : sprintf (op, "pc");
++
++          fputs (op, stream);
++        }
++      else if (code == 's')
++        {
++          /* Reglist 16 */
++          char reglist16_string[100];
++          int i;
++          reglist16_string[0] = '\0';
++
++          for (i = 0; i < 16; ++i)
++            {
++              if (value & (1 << i))
++                {
++                  strlen (reglist16_string) ? sprintf (reglist16_string,
++                                                       "%s, %s",
++                                                       reglist16_string,
++                                                       reg_names
++                                                       [INTERNAL_REGNUM
++                                                        (i)]) :
++                    sprintf (reglist16_string, "%s",
++                             reg_names[INTERNAL_REGNUM (i)]);
++                }
++            }
++          fputs (reglist16_string, stream);
++        }
++      else if (code == 'C')
++        {
++          /* RegListCP8 */
++          char reglist_string[100];
++          avr32_make_fp_reglist_w (value, (char *) reglist_string);
++          fputs (reglist_string, stream);
++        }
++      else if (code == 'D')
++        {
++          /* RegListCPD8 */
++          char reglist_string[100];
++          avr32_make_fp_reglist_d (value, (char *) reglist_string);
++          fputs (reglist_string, stream);
++        }
++      else if (code == 'd')
++        {
++          /* Print in decimal format */
++          fprintf (stream, "%d", value);
++        }
++      else if (code == 'h')
++        {
++          /* Print halfword part of word */
++          fputs (value ? "b" : "t", stream);
++        }
++      else
++        {
++          /* Normal constant */
++          fprintf (stream, "%d", value);
++        }
++      break;
++      }
++    case CONST_DOUBLE:
++      {
++      HOST_WIDE_INT hi, lo;
++      if (GET_MODE (x) == DImode)
++        {
++          hi = CONST_DOUBLE_HIGH (x);
++          lo = CONST_DOUBLE_LOW (x);
++        }
++      else
++        {
++          HOST_WIDE_INT target_float[2];
++          hi = lo = 0;
++          real_to_target (target_float, CONST_DOUBLE_REAL_VALUE (x),
++                          GET_MODE (x));
++          /* For doubles the most significant part starts at index 0. */
++          if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
++            {
++              hi = target_float[0];
++              lo = target_float[1];
++            }
++          else
++            {
++              lo = target_float[0];
++            }
++        }
++
++      if (avr32_const_ok_for_constraint_p (lo, 'K', "Ks21")
++          && ((GET_MODE (x) == SFmode)
++              || avr32_const_ok_for_constraint_p (hi, 'K', "Ks21")))
++        {
++          if (code == 'm')
++            fprintf (stream, "%ld", hi);
++          else
++            fprintf (stream, "%ld", lo);
++        }
++      else
++        {
++          fprintf (stream, "value too large");
++        }
++      break;
++      }
++    case CONST:
++      output_addr_const (stream, XEXP (XEXP (x, 0), 0));
++      fprintf (stream, "+%ld", INTVAL (XEXP (XEXP (x, 0), 1)));
++      break;
++    case REG:
++      /* Swap register name if the register is DImode or DFmode. */
++      if (GET_MODE (x) == DImode || GET_MODE (x) == DFmode)
++      {
++        /* Double register must have an even numbered address */
++        gcc_assert (!(REGNO (x) % 2));
++        if (code == 'm')
++          fputs (reg_names[true_regnum (x)], stream);
++        else
++          fputs (reg_names[true_regnum (x) + 1], stream);
++      }
++      else if (GET_MODE (x) == TImode)
++      {
++        switch (code)
++          {
++          case 'T':
++            fputs (reg_names[true_regnum (x)], stream);
++            break;
++          case 'U':
++            fputs (reg_names[true_regnum (x) + 1], stream);
++            break;
++          case 'L':
++            fputs (reg_names[true_regnum (x) + 2], stream);
++            break;
++          case 'B':
++            fputs (reg_names[true_regnum (x) + 3], stream);
++            break;
++          default:
++            fprintf (stream, "%s, %s, %s, %s",
++                     reg_names[true_regnum (x) + 3],
++                     reg_names[true_regnum (x) + 2],
++                     reg_names[true_regnum (x) + 1],
++                     reg_names[true_regnum (x)]);
++            break;
++          }
++      }
++      else
++      {
++        fputs (reg_names[true_regnum (x)], stream);
++      }
++      break;
++    case CODE_LABEL:
++    case LABEL_REF:
++    case SYMBOL_REF:
++      output_addr_const (stream, x);
++      break;
++    case MEM:
++      switch (GET_CODE (XEXP (x, 0)))
++      {
++      case LABEL_REF:
++      case SYMBOL_REF:
++        output_addr_const (stream, XEXP (x, 0));
++        break;
++      case MEM:
++        switch (GET_CODE (XEXP (XEXP (x, 0), 0)))
++          {
++          case SYMBOL_REF:
++            output_addr_const (stream, XEXP (XEXP (x, 0), 0));
++            break;
++          default:
++            error = 1;
++            break;
++          }
++        break;
++      case REG:
++        avr32_print_operand (stream, XEXP (x, 0), 0);
++        if (code != 'p')
++          fputs ("[0]", stream);
++        break;
++      case PRE_DEC:
++        fputs ("--", stream);
++        avr32_print_operand (stream, XEXP (XEXP (x, 0), 0), 0);
++        break;
++      case POST_INC:
++        avr32_print_operand (stream, XEXP (XEXP (x, 0), 0), 0);
++        fputs ("++", stream);
++        break;
++      case PLUS:
++        {
++          rtx op0 = XEXP (XEXP (x, 0), 0);
++          rtx op1 = XEXP (XEXP (x, 0), 1);
++          rtx base = NULL_RTX, offset = NULL_RTX;
++
++          if (avr32_address_register_rtx_p (op0, 1))
++            {
++              base = op0;
++              offset = op1;
++            }
++          else if (avr32_address_register_rtx_p (op1, 1))
++            {
++              /* Operands are switched. */
++              base = op1;
++              offset = op0;
++            }
++
++          gcc_assert (base && offset
++                      && avr32_address_register_rtx_p (base, 1)
++                      && avr32_legitimate_index_p (GET_MODE (x), offset,
++                                                   1));
++
++          avr32_print_operand (stream, base, 0);
++          fputs ("[", stream);
++          avr32_print_operand (stream, offset, 0);
++          fputs ("]", stream);
++          break;
++        }
++      case CONST:
++        output_addr_const (stream, XEXP (XEXP (XEXP (x, 0), 0), 0));
++        fprintf (stream, " + %ld",
++                 INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1)));
++        break;
++      default:
++        error = 1;
++      }
++      break;
++    case MULT:
++      {
++      int value = INTVAL (XEXP (x, 1));
++
++      /* Convert immediate in multiplication into a shift immediate */
++      switch (value)
++        {
++        case 2:
++          value = 1;
++          break;
++        case 4:
++          value = 2;
++          break;
++        case 8:
++          value = 3;
++          break;
++        default:
++          value = 0;
++        }
++      fprintf (stream, "%s << %i", reg_names[true_regnum (XEXP (x, 0))],
++               value);
++      break;
++      }
++    case ASHIFT:
++      if (GET_CODE (XEXP (x, 1)) == CONST_INT)
++      fprintf (stream, "%s << %i", reg_names[true_regnum (XEXP (x, 0))],
++               (int) INTVAL (XEXP (x, 1)));
++      else if (REG_P (XEXP (x, 1)))
++      fprintf (stream, "%s << %s", reg_names[true_regnum (XEXP (x, 0))],
++               reg_names[true_regnum (XEXP (x, 1))]);
++      else
++      {
++        error = 1;
++      }
++      break;
++    case LSHIFTRT:
++      if (GET_CODE (XEXP (x, 1)) == CONST_INT)
++      fprintf (stream, "%s >> %i", reg_names[true_regnum (XEXP (x, 0))],
++               (int) INTVAL (XEXP (x, 1)));
++      else if (REG_P (XEXP (x, 1)))
++      fprintf (stream, "%s >> %s", reg_names[true_regnum (XEXP (x, 0))],
++               reg_names[true_regnum (XEXP (x, 1))]);
++      else
++      {
++        error = 1;
++      }
++      fprintf (stream, ">>");
++      break;
++    case PARALLEL:
++      {
++      /* Load store multiple */
++      int i;
++      int count = XVECLEN (x, 0);
++      int reglist16 = 0;
++      char reglist16_string[100];
++
++      for (i = 0; i < count; ++i)
++        {
++          rtx vec_elm = XVECEXP (x, 0, i);
++          if (GET_MODE (vec_elm) != SET)
++            {
++              debug_rtx (vec_elm);
++              internal_error ("Unknown element in parallel expression!");
++            }
++          if (GET_MODE (XEXP (vec_elm, 0)) == REG)
++            {
++              /* Load multiple */
++              reglist16 |= 1 << ASM_REGNUM (REGNO (XEXP (vec_elm, 0)));
++            }
++          else
++            {
++              /* Store multiple */
++              reglist16 |= 1 << ASM_REGNUM (REGNO (XEXP (vec_elm, 1)));
++            }
++        }
++
++      avr32_make_reglist16 (reglist16, reglist16_string);
++      fputs (reglist16_string, stream);
++
++      break;
++      }
++
++    default:
++      error = 1;
++    }
++
++  if (error)
++    {
++      debug_rtx (x);
++      internal_error ("Illegal expression for avr32_print_operand");
++    }
++}
++
++rtx
++avr32_get_note_reg_equiv (rtx insn)
++{
++  rtx note;
++
++  note = find_reg_note (insn, REG_EQUIV, NULL_RTX);
++
++  if (note != NULL_RTX)
++    return XEXP (note, 0);
++  else
++    return NULL_RTX;
++}
++
++/*
++  Outputs to stdio stream stream the assembler syntax for an instruction
++  operand that is a memory reference whose address is x. x is an RTL
++  expression.
++
++  ToDo: fixme.
++*/
++void
++avr32_print_operand_address (FILE * stream, rtx x)
++{
++  fprintf (stream, "(%d) /* address */", REGNO (x));
++}
++
++/* Return true if _GLOBAL_OFFSET_TABLE_ symbol is mentioned.  */
++bool
++avr32_got_mentioned_p (rtx addr)
++{
++  if (GET_CODE (addr) == MEM)
++    addr = XEXP (addr, 0);
++  while (GET_CODE (addr) == CONST)
++    addr = XEXP (addr, 0);
++  if (GET_CODE (addr) == SYMBOL_REF)
++    {
++      return streq (XSTR (addr, 0), "_GLOBAL_OFFSET_TABLE_");
++    }
++  if (GET_CODE (addr) == PLUS || GET_CODE (addr) == MINUS)
++    {
++      bool l1, l2;
++
++      l1 = avr32_got_mentioned_p (XEXP (addr, 0));
++      l2 = avr32_got_mentioned_p (XEXP (addr, 1));
++      return l1 || l2;
++    }
++  return false;
++}
++
++
++/* Find the symbol in an address expression.  */
++
++rtx
++avr32_find_symbol (rtx addr)
++{
++  if (GET_CODE (addr) == MEM)
++    addr = XEXP (addr, 0);
++
++  while (GET_CODE (addr) == CONST)
++    addr = XEXP (addr, 0);
++
++  if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == LABEL_REF)
++    return addr;
++  if (GET_CODE (addr) == PLUS)
++    {
++      rtx l1, l2;
++
++      l1 = avr32_find_symbol (XEXP (addr, 0));
++      l2 = avr32_find_symbol (XEXP (addr, 1));
++      if (l1 != NULL_RTX && l2 == NULL_RTX)
++      return l1;
++      else if (l1 == NULL_RTX && l2 != NULL_RTX)
++      return l2;
++    }
++
++  return NULL_RTX;
++}
++
++
++/* Routines for manipulation of the constant pool.  */
++
++/* AVR32 instructions cannot load a large constant directly into a
++   register; they have to come from a pc relative load.  The constant
++   must therefore be placed in the addressable range of the pc
++   relative load.  Depending on the precise pc relative load
++   instruction the range is somewhere between 256 bytes and 4k.  This
++   means that we often have to dump a constant inside a function, and
++   generate code to branch around it.
++
++   It is important to minimize this, since the branches will slow
++   things down and make the code larger.
++
++   Normally we can hide the table after an existing unconditional
++   branch so that there is no interruption of the flow, but in the
++   worst case the code looks like this:
++
++      lddpc   rn, L1
++      ...
++      rjmp    L2
++      align
++      L1:     .long value
++      L2:
++      ...
++
++      lddpc   rn, L3
++      ...
++      rjmp    L4
++      align
++      L3:     .long value
++      L4:
++      ...
++
++   We fix this by performing a scan after scheduling, which notices
++   which instructions need to have their operands fetched from the
++   constant table and builds the table.
++
++   The algorithm starts by building a table of all the constants that
++   need fixing up and all the natural barriers in the function (places
++   where a constant table can be dropped without breaking the flow).
++   For each fixup we note how far the pc-relative replacement will be
++   able to reach and the offset of the instruction into the function.
++
++   Having built the table we then group the fixes together to form
++   tables that are as large as possible (subject to addressing
++   constraints) and emit each table of constants after the last
++   barrier that is within range of all the instructions in the group.
++   If a group does not contain a barrier, then we forcibly create one
++   by inserting a jump instruction into the flow.  Once the table has
++   been inserted, the insns are then modified to reference the
++   relevant entry in the pool.
++
++   Possible enhancements to the algorithm (not implemented) are:
++
++   1) For some processors and object formats, there may be benefit in
++   aligning the pools to the start of cache lines; this alignment
++   would need to be taken into account when calculating addressability
++   of a pool.  */
++
++/* These typedefs are located at the start of this file, so that
++   they can be used in the prototypes there.  This comment is to
++   remind readers of that fact so that the following structures
++   can be understood more easily.
++
++     typedef struct minipool_node    Mnode;
++     typedef struct minipool_fixup   Mfix;  */
++
++struct minipool_node
++{
++  /* Doubly linked chain of entries.  */
++  Mnode *next;
++  Mnode *prev;
++  /* The maximum offset into the code that this entry can be placed.  While
++     pushing fixes for forward references, all entries are sorted in order of
++     increasing max_address.  */
++  HOST_WIDE_INT max_address;
++  /* Similarly for an entry inserted for a backwards ref.  */
++  HOST_WIDE_INT min_address;
++  /* The number of fixes referencing this entry.  This can become zero if we
++     "unpush" an entry.  In this case we ignore the entry when we come to
++     emit the code.  */
++  int refcount;
++  /* The offset from the start of the minipool.  */
++  HOST_WIDE_INT offset;
++  /* The value in table.  */
++  rtx value;
++  /* The mode of value.  */
++  enum machine_mode mode;
++  /* The size of the value.  */
++  int fix_size;
++};
++
++struct minipool_fixup
++{
++  Mfix *next;
++  rtx insn;
++  HOST_WIDE_INT address;
++  rtx *loc;
++  enum machine_mode mode;
++  int fix_size;
++  rtx value;
++  Mnode *minipool;
++  HOST_WIDE_INT forwards;
++  HOST_WIDE_INT backwards;
++};
++
++
++/* Fixes less than a word need padding out to a word boundary.  */
++#define MINIPOOL_FIX_SIZE(mode, value)                          \
++  (IS_FORCE_MINIPOOL(value) ? 0 :                               \
++   (GET_MODE_SIZE ((mode)) >= 4 ? GET_MODE_SIZE ((mode)) : 4))
++
++#define IS_FORCE_MINIPOOL(x)                    \
++  (GET_CODE(x) == UNSPEC &&                     \
++   XINT(x, 1) == UNSPEC_FORCE_MINIPOOL)
++
++static Mnode *minipool_vector_head;
++static Mnode *minipool_vector_tail;
++
++/* The linked list of all minipool fixes required for this function.  */
++Mfix *minipool_fix_head;
++Mfix *minipool_fix_tail;
++/* The fix entry for the current minipool, once it has been placed.  */
++Mfix *minipool_barrier;
++
++/* Determines if INSN is the start of a jump table.  Returns the end
++   of the TABLE or NULL_RTX.  */
++static rtx
++is_jump_table (rtx insn)
++{
++  rtx table;
++
++  if (GET_CODE (insn) == JUMP_INSN
++      && JUMP_LABEL (insn) != NULL
++      && ((table = next_real_insn (JUMP_LABEL (insn)))
++        == next_real_insn (insn))
++      && table != NULL
++      && GET_CODE (table) == JUMP_INSN
++      && (GET_CODE (PATTERN (table)) == ADDR_VEC
++        || GET_CODE (PATTERN (table)) == ADDR_DIFF_VEC))
++    return table;
++
++  return NULL_RTX;
++}
++
++static HOST_WIDE_INT
++get_jump_table_size (rtx insn)
++{
++  /* ADDR_VECs only take room if read-only data does into the text section.  */
++  if (JUMP_TABLES_IN_TEXT_SECTION
++#if !defined(READONLY_DATA_SECTION) && !defined(READONLY_DATA_SECTION_ASM_OP)
++      || 1
++#endif
++    )
++    {
++      rtx body = PATTERN (insn);
++      int elt = GET_CODE (body) == ADDR_DIFF_VEC ? 1 : 0;
++
++      return GET_MODE_SIZE (GET_MODE (body)) * XVECLEN (body, elt);
++    }
++
++  return 0;
++}
++
++/* Move a minipool fix MP from its current location to before MAX_MP.
++   If MAX_MP is NULL, then MP doesn't need moving, but the addressing
++   constraints may need updating.  */
++static Mnode *
++move_minipool_fix_forward_ref (Mnode * mp, Mnode * max_mp,
++                             HOST_WIDE_INT max_address)
++{
++  /* This should never be true and the code below assumes these are
++     different.  */
++  if (mp == max_mp)
++    abort ();
++
++  if (max_mp == NULL)
++    {
++      if (max_address < mp->max_address)
++      mp->max_address = max_address;
++    }
++  else
++    {
++      if (max_address > max_mp->max_address - mp->fix_size)
++      mp->max_address = max_mp->max_address - mp->fix_size;
++      else
++      mp->max_address = max_address;
++
++      /* Unlink MP from its current position.  Since max_mp is non-null,
++         mp->prev must be non-null.  */
++      mp->prev->next = mp->next;
++      if (mp->next != NULL)
++      mp->next->prev = mp->prev;
++      else
++      minipool_vector_tail = mp->prev;
++
++      /* Re-insert it before MAX_MP.  */
++      mp->next = max_mp;
++      mp->prev = max_mp->prev;
++      max_mp->prev = mp;
++
++      if (mp->prev != NULL)
++      mp->prev->next = mp;
++      else
++      minipool_vector_head = mp;
++    }
++
++  /* Save the new entry.  */
++  max_mp = mp;
++
++  /* Scan over the preceding entries and adjust their addresses as required.
++     */
++  while (mp->prev != NULL
++       && mp->prev->max_address > mp->max_address - mp->prev->fix_size)
++    {
++      mp->prev->max_address = mp->max_address - mp->prev->fix_size;
++      mp = mp->prev;
++    }
++
++  return max_mp;
++}
++
++/* Add a constant to the minipool for a forward reference.  Returns the
++   node added or NULL if the constant will not fit in this pool.  */
++static Mnode *
++add_minipool_forward_ref (Mfix * fix)
++{
++  /* If set, max_mp is the first pool_entry that has a lower constraint than
++     the one we are trying to add.  */
++  Mnode *max_mp = NULL;
++  HOST_WIDE_INT max_address = fix->address + fix->forwards;
++  Mnode *mp;
++
++  /* If this fix's address is greater than the address of the first entry,
++     then we can't put the fix in this pool.  We subtract the size of the
++     current fix to ensure that if the table is fully packed we still have
++     enough room to insert this value by suffling the other fixes forwards.  */
++  if (minipool_vector_head &&
++      fix->address >= minipool_vector_head->max_address - fix->fix_size)
++    return NULL;
++
++  /* Scan the pool to see if a constant with the same value has already been
++     added.  While we are doing this, also note the location where we must
++     insert the constant if it doesn't already exist.  */
++  for (mp = minipool_vector_head; mp != NULL; mp = mp->next)
++    {
++      if (GET_CODE (fix->value) == GET_CODE (mp->value)
++        && fix->mode == mp->mode
++        && (GET_CODE (fix->value) != CODE_LABEL
++            || (CODE_LABEL_NUMBER (fix->value)
++                == CODE_LABEL_NUMBER (mp->value)))
++        && rtx_equal_p (fix->value, mp->value))
++      {
++        /* More than one fix references this entry.  */
++        mp->refcount++;
++        return move_minipool_fix_forward_ref (mp, max_mp, max_address);
++      }
++
++      /* Note the insertion point if necessary.  */
++      if (max_mp == NULL && mp->max_address > max_address)
++      max_mp = mp;
++
++    }
++
++  /* The value is not currently in the minipool, so we need to create a new
++     entry for it.  If MAX_MP is NULL, the entry will be put on the end of
++     the list since the placement is less constrained than any existing
++     entry.  Otherwise, we insert the new fix before MAX_MP and, if
++     necessary, adjust the constraints on the other entries.  */
++  mp = xmalloc (sizeof (*mp));
++  mp->fix_size = fix->fix_size;
++  mp->mode = fix->mode;
++  mp->value = fix->value;
++  mp->refcount = 1;
++  /* Not yet required for a backwards ref.  */
++  mp->min_address = -65536;
++
++  if (max_mp == NULL)
++    {
++      mp->max_address = max_address;
++      mp->next = NULL;
++      mp->prev = minipool_vector_tail;
++
++      if (mp->prev == NULL)
++      {
++        minipool_vector_head = mp;
++        minipool_vector_label = gen_label_rtx ();
++      }
++      else
++      mp->prev->next = mp;
++
++      minipool_vector_tail = mp;
++    }
++  else
++    {
++      if (max_address > max_mp->max_address - mp->fix_size)
++      mp->max_address = max_mp->max_address - mp->fix_size;
++      else
++      mp->max_address = max_address;
++
++      mp->next = max_mp;
++      mp->prev = max_mp->prev;
++      max_mp->prev = mp;
++      if (mp->prev != NULL)
++      mp->prev->next = mp;
++      else
++      minipool_vector_head = mp;
++    }
++
++  /* Save the new entry.  */
++  max_mp = mp;
++
++  /* Scan over the preceding entries and adjust their addresses as required.
++     */
++  while (mp->prev != NULL
++       && mp->prev->max_address > mp->max_address - mp->prev->fix_size)
++    {
++      mp->prev->max_address = mp->max_address - mp->prev->fix_size;
++      mp = mp->prev;
++    }
++
++  return max_mp;
++}
++
++static Mnode *
++move_minipool_fix_backward_ref (Mnode * mp, Mnode * min_mp,
++                              HOST_WIDE_INT min_address)
++{
++  HOST_WIDE_INT offset;
++
++  /* This should never be true, and the code below assumes these are
++     different.  */
++  if (mp == min_mp)
++    abort ();
++
++  if (min_mp == NULL)
++    {
++      if (min_address > mp->min_address)
++      mp->min_address = min_address;
++    }
++  else
++    {
++      /* We will adjust this below if it is too loose.  */
++      mp->min_address = min_address;
++
++      /* Unlink MP from its current position.  Since min_mp is non-null,
++         mp->next must be non-null.  */
++      mp->next->prev = mp->prev;
++      if (mp->prev != NULL)
++      mp->prev->next = mp->next;
++      else
++      minipool_vector_head = mp->next;
++
++      /* Reinsert it after MIN_MP.  */
++      mp->prev = min_mp;
++      mp->next = min_mp->next;
++      min_mp->next = mp;
++      if (mp->next != NULL)
++      mp->next->prev = mp;
++      else
++      minipool_vector_tail = mp;
++    }
++
++  min_mp = mp;
++
++  offset = 0;
++  for (mp = minipool_vector_head; mp != NULL; mp = mp->next)
++    {
++      mp->offset = offset;
++      if (mp->refcount > 0)
++      offset += mp->fix_size;
++
++      if (mp->next && mp->next->min_address < mp->min_address + mp->fix_size)
++      mp->next->min_address = mp->min_address + mp->fix_size;
++    }
++
++  return min_mp;
++}
++
++/* Add a constant to the minipool for a backward reference.  Returns the
++   node added or NULL if the constant will not fit in this pool.
++
++   Note that the code for insertion for a backwards reference can be
++   somewhat confusing because the calculated offsets for each fix do
++   not take into account the size of the pool (which is still under
++   construction.  */
++static Mnode *
++add_minipool_backward_ref (Mfix * fix)
++{
++  /* If set, min_mp is the last pool_entry that has a lower constraint than
++     the one we are trying to add.  */
++  Mnode *min_mp = NULL;
++  /* This can be negative, since it is only a constraint.  */
++  HOST_WIDE_INT min_address = fix->address - fix->backwards;
++  Mnode *mp;
++
++  /* If we can't reach the current pool from this insn, or if we can't insert
++     this entry at the end of the pool without pushing other fixes out of
++     range, then we don't try.  This ensures that we can't fail later on.  */
++  if (min_address >= minipool_barrier->address
++      || (minipool_vector_tail->min_address + fix->fix_size
++        >= minipool_barrier->address))
++    return NULL;
++
++  /* Scan the pool to see if a constant with the same value has already been
++     added.  While we are doing this, also note the location where we must
++     insert the constant if it doesn't already exist.  */
++  for (mp = minipool_vector_tail; mp != NULL; mp = mp->prev)
++    {
++      if (GET_CODE (fix->value) == GET_CODE (mp->value)
++        && fix->mode == mp->mode
++        && (GET_CODE (fix->value) != CODE_LABEL
++            || (CODE_LABEL_NUMBER (fix->value)
++                == CODE_LABEL_NUMBER (mp->value)))
++        && rtx_equal_p (fix->value, mp->value)
++        /* Check that there is enough slack to move this entry to the end
++           of the table (this is conservative).  */
++        && (mp->max_address
++            > (minipool_barrier->address
++               + minipool_vector_tail->offset
++               + minipool_vector_tail->fix_size)))
++      {
++        mp->refcount++;
++        return move_minipool_fix_backward_ref (mp, min_mp, min_address);
++      }
++
++      if (min_mp != NULL)
++      mp->min_address += fix->fix_size;
++      else
++      {
++        /* Note the insertion point if necessary.  */
++        if (mp->min_address < min_address)
++          {
++            min_mp = mp;
++          }
++        else if (mp->max_address
++                 < minipool_barrier->address + mp->offset + fix->fix_size)
++          {
++            /* Inserting before this entry would push the fix beyond its
++               maximum address (which can happen if we have re-located a
++               forwards fix); force the new fix to come after it.  */
++            min_mp = mp;
++            min_address = mp->min_address + fix->fix_size;
++          }
++      }
++    }
++
++  /* We need to create a new entry.  */
++  mp = xmalloc (sizeof (*mp));
++  mp->fix_size = fix->fix_size;
++  mp->mode = fix->mode;
++  mp->value = fix->value;
++  mp->refcount = 1;
++  mp->max_address = minipool_barrier->address + 65536;
++
++  mp->min_address = min_address;
++
++  if (min_mp == NULL)
++    {
++      mp->prev = NULL;
++      mp->next = minipool_vector_head;
++
++      if (mp->next == NULL)
++      {
++        minipool_vector_tail = mp;
++        minipool_vector_label = gen_label_rtx ();
++      }
++      else
++      mp->next->prev = mp;
++
++      minipool_vector_head = mp;
++    }
++  else
++    {
++      mp->next = min_mp->next;
++      mp->prev = min_mp;
++      min_mp->next = mp;
++
++      if (mp->next != NULL)
++      mp->next->prev = mp;
++      else
++      minipool_vector_tail = mp;
++    }
++
++  /* Save the new entry.  */
++  min_mp = mp;
++
++  if (mp->prev)
++    mp = mp->prev;
++  else
++    mp->offset = 0;
++
++  /* Scan over the following entries and adjust their offsets.  */
++  while (mp->next != NULL)
++    {
++      if (mp->next->min_address < mp->min_address + mp->fix_size)
++      mp->next->min_address = mp->min_address + mp->fix_size;
++
++      if (mp->refcount)
++      mp->next->offset = mp->offset + mp->fix_size;
++      else
++      mp->next->offset = mp->offset;
++
++      mp = mp->next;
++    }
++
++  return min_mp;
++}
++
++static void
++assign_minipool_offsets (Mfix * barrier)
++{
++  HOST_WIDE_INT offset = 0;
++  Mnode *mp;
++
++  minipool_barrier = barrier;
++
++  for (mp = minipool_vector_head; mp != NULL; mp = mp->next)
++    {
++      mp->offset = offset;
++
++      if (mp->refcount > 0)
++      offset += mp->fix_size;
++    }
++}
++
++/* Print a symbolic form of X to the debug file, F.  */
++static void
++avr32_print_value (FILE * f, rtx x)
++{
++  switch (GET_CODE (x))
++    {
++    case CONST_INT:
++      fprintf (f, "0x%x", (int) INTVAL (x));
++      return;
++
++    case CONST_DOUBLE:
++      fprintf (f, "<0x%lx,0x%lx>", (long) XWINT (x, 2), (long) XWINT (x, 3));
++      return;
++
++    case CONST_VECTOR:
++      {
++      int i;
++
++      fprintf (f, "<");
++      for (i = 0; i < CONST_VECTOR_NUNITS (x); i++)
++        {
++          fprintf (f, "0x%x", (int) INTVAL (CONST_VECTOR_ELT (x, i)));
++          if (i < (CONST_VECTOR_NUNITS (x) - 1))
++            fputc (',', f);
++        }
++      fprintf (f, ">");
++      }
++      return;
++
++    case CONST_STRING:
++      fprintf (f, "\"%s\"", XSTR (x, 0));
++      return;
++
++    case SYMBOL_REF:
++      fprintf (f, "`%s'", XSTR (x, 0));
++      return;
++
++    case LABEL_REF:
++      fprintf (f, "L%d", INSN_UID (XEXP (x, 0)));
++      return;
++
++    case CONST:
++      avr32_print_value (f, XEXP (x, 0));
++      return;
++
++    case PLUS:
++      avr32_print_value (f, XEXP (x, 0));
++      fprintf (f, "+");
++      avr32_print_value (f, XEXP (x, 1));
++      return;
++
++    case PC:
++      fprintf (f, "pc");
++      return;
++
++    default:
++      fprintf (f, "????");
++      return;
++    }
++}
++
++int
++is_minipool_label (rtx label)
++{
++  minipool_labels *cur_mp_label = cfun->machine->minipool_label_head;
++
++  if (GET_CODE (label) != CODE_LABEL)
++    return FALSE;
++
++  while (cur_mp_label)
++    {
++      if (CODE_LABEL_NUMBER (label)
++        == CODE_LABEL_NUMBER (cur_mp_label->label))
++      return TRUE;
++      cur_mp_label = cur_mp_label->next;
++    }
++  return FALSE;
++}
++
++static void
++new_minipool_label (rtx label)
++{
++  if (!cfun->machine->minipool_label_head)
++    {
++      cfun->machine->minipool_label_head =
++      ggc_alloc (sizeof (minipool_labels));
++      cfun->machine->minipool_label_tail = cfun->machine->minipool_label_head;
++      cfun->machine->minipool_label_head->label = label;
++      cfun->machine->minipool_label_head->next = 0;
++      cfun->machine->minipool_label_head->prev = 0;
++    }
++  else
++    {
++      cfun->machine->minipool_label_tail->next =
++      ggc_alloc (sizeof (minipool_labels));
++      cfun->machine->minipool_label_tail->next->label = label;
++      cfun->machine->minipool_label_tail->next->next = 0;
++      cfun->machine->minipool_label_tail->next->prev =
++      cfun->machine->minipool_label_tail;
++      cfun->machine->minipool_label_tail =
++      cfun->machine->minipool_label_tail->next;
++    }
++}
++
++/* Output the literal table */
++static void
++dump_minipool (rtx scan)
++{
++  Mnode *mp;
++  Mnode *nmp;
++
++  if (dump_file)
++    fprintf (dump_file,
++           ";; Emitting minipool after insn %u; address %ld; align %d (bytes)\n",
++           INSN_UID (scan), (unsigned long) minipool_barrier->address, 4);
++
++  scan = emit_insn_after (gen_consttable_start (), scan);
++  scan = emit_insn_after (gen_align_4 (), scan);
++  scan = emit_label_after (minipool_vector_label, scan);
++  new_minipool_label (minipool_vector_label);
++
++  for (mp = minipool_vector_head; mp != NULL; mp = nmp)
++    {
++      if (mp->refcount > 0)
++      {
++        if (dump_file)
++          {
++            fprintf (dump_file,
++                     ";;  Offset %u, min %ld, max %ld ",
++                     (unsigned) mp->offset, (unsigned long) mp->min_address,
++                     (unsigned long) mp->max_address);
++            avr32_print_value (dump_file, mp->value);
++            fputc ('\n', dump_file);
++          }
++
++        switch (mp->fix_size)
++          {
++#ifdef HAVE_consttable_4
++          case 4:
++            scan = emit_insn_after (gen_consttable_4 (mp->value), scan);
++            break;
++
++#endif
++#ifdef HAVE_consttable_8
++          case 8:
++            scan = emit_insn_after (gen_consttable_8 (mp->value), scan);
++            break;
++
++#endif
++          case 0:
++            /* This can happen for force-minipool entries which just are
++               there to force the minipool to be generate. */
++            break;
++          default:
++            abort ();
++            break;
++          }
++      }
++
++      nmp = mp->next;
++      free (mp);
++    }
++
++  minipool_vector_head = minipool_vector_tail = NULL;
++  scan = emit_insn_after (gen_consttable_end (), scan);
++  scan = emit_barrier_after (scan);
++}
++
++/* Return the cost of forcibly inserting a barrier after INSN.  */
++static int
++avr32_barrier_cost (rtx insn)
++{
++  /* Basing the location of the pool on the loop depth is preferable, but at
++     the moment, the basic block information seems to be corrupt by this
++     stage of the compilation.  */
++  int base_cost = 50;
++  rtx next = next_nonnote_insn (insn);
++
++  if (next != NULL && GET_CODE (next) == CODE_LABEL)
++    base_cost -= 20;
++
++  switch (GET_CODE (insn))
++    {
++    case CODE_LABEL:
++      /* It will always be better to place the table before the label, rather
++         than after it.  */
++      return 50;
++
++    case INSN:
++    case CALL_INSN:
++      return base_cost;
++
++    case JUMP_INSN:
++      return base_cost - 10;
++
++    default:
++      return base_cost + 10;
++    }
++}
++
++/* Find the best place in the insn stream in the range
++   (FIX->address,MAX_ADDRESS) to forcibly insert a minipool barrier.
++   Create the barrier by inserting a jump and add a new fix entry for
++   it.  */
++static Mfix *
++create_fix_barrier (Mfix * fix, HOST_WIDE_INT max_address)
++{
++  HOST_WIDE_INT count = 0;
++  rtx barrier;
++  rtx from = fix->insn;
++  rtx selected = from;
++  int selected_cost;
++  HOST_WIDE_INT selected_address;
++  Mfix *new_fix;
++  HOST_WIDE_INT max_count = max_address - fix->address;
++  rtx label = gen_label_rtx ();
++
++  selected_cost = avr32_barrier_cost (from);
++  selected_address = fix->address;
++
++  while (from && count < max_count)
++    {
++      rtx tmp;
++      int new_cost;
++
++      /* This code shouldn't have been called if there was a natural barrier
++         within range.  */
++      if (GET_CODE (from) == BARRIER)
++      abort ();
++
++      /* Count the length of this insn.  */
++      count += get_attr_length (from);
++
++      /* If there is a jump table, add its length.  */
++      tmp = is_jump_table (from);
++      if (tmp != NULL)
++      {
++        count += get_jump_table_size (tmp);
++
++        /* Jump tables aren't in a basic block, so base the cost on the
++           dispatch insn.  If we select this location, we will still put
++           the pool after the table.  */
++        new_cost = avr32_barrier_cost (from);
++
++        if (count < max_count && new_cost <= selected_cost)
++          {
++            selected = tmp;
++            selected_cost = new_cost;
++            selected_address = fix->address + count;
++          }
++
++        /* Continue after the dispatch table.  */
++        from = NEXT_INSN (tmp);
++        continue;
++      }
++
++      new_cost = avr32_barrier_cost (from);
++
++      if (count < max_count && new_cost <= selected_cost)
++      {
++        selected = from;
++        selected_cost = new_cost;
++        selected_address = fix->address + count;
++      }
++
++      from = NEXT_INSN (from);
++    }
++
++  /* Create a new JUMP_INSN that branches around a barrier.  */
++  from = emit_jump_insn_after (gen_jump (label), selected);
++  JUMP_LABEL (from) = label;
++  barrier = emit_barrier_after (from);
++  emit_label_after (label, barrier);
++
++  /* Create a minipool barrier entry for the new barrier.  */
++  new_fix = (Mfix *) obstack_alloc (&minipool_obstack, sizeof (*new_fix));
++  new_fix->insn = barrier;
++  new_fix->address = selected_address;
++  new_fix->next = fix->next;
++  fix->next = new_fix;
++
++  return new_fix;
++}
++
++/* Record that there is a natural barrier in the insn stream at
++   ADDRESS.  */
++static void
++push_minipool_barrier (rtx insn, HOST_WIDE_INT address)
++{
++  Mfix *fix = (Mfix *) obstack_alloc (&minipool_obstack, sizeof (*fix));
++
++  fix->insn = insn;
++  fix->address = address;
++
++  fix->next = NULL;
++  if (minipool_fix_head != NULL)
++    minipool_fix_tail->next = fix;
++  else
++    minipool_fix_head = fix;
++
++  minipool_fix_tail = fix;
++}
++
++/* Record INSN, which will need fixing up to load a value from the
++   minipool.  ADDRESS is the offset of the insn since the start of the
++   function; LOC is a pointer to the part of the insn which requires
++   fixing; VALUE is the constant that must be loaded, which is of type
++   MODE.  */
++static void
++push_minipool_fix (rtx insn, HOST_WIDE_INT address, rtx * loc,
++                 enum machine_mode mode, rtx value)
++{
++  Mfix *fix = (Mfix *) obstack_alloc (&minipool_obstack, sizeof (*fix));
++  rtx body = PATTERN (insn);
++
++  fix->insn = insn;
++  fix->address = address;
++  fix->loc = loc;
++  fix->mode = mode;
++  fix->fix_size = MINIPOOL_FIX_SIZE (mode, value);
++  fix->value = value;
++
++  if (GET_CODE (body) == PARALLEL)
++    {
++      /* Mcall : Ks16 << 2 */
++      fix->forwards = ((1 << 15) - 1) << 2;
++      fix->backwards = (1 << 15) << 2;
++    }
++  else if (GET_CODE (body) == SET
++         && GET_MODE_SIZE (GET_MODE (SET_DEST (body))) == 4)
++    {
++      /* Word Load */
++      if (TARGET_HARD_FLOAT
++        && GET_MODE_CLASS (GET_MODE (SET_DEST (body))) == MODE_FLOAT)
++      {
++        /* Ldc0.w : Ku12 << 2 */
++        fix->forwards = ((1 << 12) - 1) << 2;
++        fix->backwards = 0;
++      }
++      else
++      {
++        if (optimize_size)
++          {
++            /* Lddpc : Ku7 << 2 */
++            fix->forwards = ((1 << 7) - 1) << 2;
++            fix->backwards = 0;
++          }
++        else
++          {
++            /* Ld.w : Ks16 */
++            fix->forwards = ((1 << 15) - 4);
++            fix->backwards = (1 << 15);
++          }
++      }
++    }
++  else if (GET_CODE (body) == SET
++         && GET_MODE_SIZE (GET_MODE (SET_DEST (body))) == 8)
++    {
++      /* Double word load */
++      if (TARGET_HARD_FLOAT
++        && GET_MODE_CLASS (GET_MODE (SET_DEST (body))) == MODE_FLOAT)
++      {
++        /* Ldc0.d : Ku12 << 2 */
++        fix->forwards = ((1 << 12) - 1) << 2;
++        fix->backwards = 0;
++      }
++      else
++      {
++        /* Ld.d : Ks16 */
++        fix->forwards = ((1 << 15) - 4);
++        fix->backwards = (1 << 15);
++      }
++    }
++  else if (GET_CODE (body) == UNSPEC_VOLATILE
++         && XINT (body, 1) == VUNSPEC_MVRC)
++    {
++      /* Coprocessor load */
++      /* Ldc : Ku8 << 2 */
++      fix->forwards = ((1 << 8) - 1) << 2;
++      fix->backwards = 0;
++    }
++  else
++    {
++      /* Assume worst case which is lddpc insn. */
++      fix->forwards = ((1 << 7) - 1) << 2;
++      fix->backwards = 0;
++    }
++
++  fix->minipool = NULL;
++
++  /* If an insn doesn't have a range defined for it, then it isn't expecting
++     to be reworked by this code.  Better to abort now than to generate duff
++     assembly code.  */
++  if (fix->forwards == 0 && fix->backwards == 0)
++    abort ();
++
++  if (dump_file)
++    {
++      fprintf (dump_file,
++             ";; %smode fixup for i%d; addr %lu, range (%ld,%ld): ",
++             GET_MODE_NAME (mode),
++             INSN_UID (insn), (unsigned long) address,
++             -1 * (long) fix->backwards, (long) fix->forwards);
++      avr32_print_value (dump_file, fix->value);
++      fprintf (dump_file, "\n");
++    }
++
++  /* Add it to the chain of fixes.  */
++  fix->next = NULL;
++
++  if (minipool_fix_head != NULL)
++    minipool_fix_tail->next = fix;
++  else
++    minipool_fix_head = fix;
++
++  minipool_fix_tail = fix;
++}
++
++/* Scan INSN and note any of its operands that need fixing.
++   If DO_PUSHES is false we do not actually push any of the fixups
++   needed.  The function returns TRUE is any fixups were needed/pushed.
++   This is used by avr32_memory_load_p() which needs to know about loads
++   of constants that will be converted into minipool loads.  */
++static bool
++note_invalid_constants (rtx insn, HOST_WIDE_INT address, int do_pushes)
++{
++  bool result = false;
++  int opno;
++
++  extract_insn (insn);
++
++  if (!constrain_operands (1))
++    fatal_insn_not_found (insn);
++
++  if (recog_data.n_alternatives == 0)
++    return false;
++
++  /* Fill in recog_op_alt with information about the constraints of this
++     insn.  */
++  preprocess_constraints ();
++
++  for (opno = 0; opno < recog_data.n_operands; opno++)
++    {
++      rtx op;
++
++      /* Things we need to fix can only occur in inputs.  */
++      if (recog_data.operand_type[opno] != OP_IN)
++      continue;
++
++      op = recog_data.operand[opno];
++
++      if (avr32_const_pool_ref_operand (op, GET_MODE (op)))
++      {
++        if (do_pushes)
++          {
++            rtx cop = avoid_constant_pool_reference (op);
++
++            /* Casting the address of something to a mode narrower than a
++               word can cause avoid_constant_pool_reference() to return the
++               pool reference itself.  That's no good to us here.  Lets
++               just hope that we can use the constant pool value directly.
++               */
++            if (op == cop)
++              cop = get_pool_constant (XEXP (op, 0));
++
++            push_minipool_fix (insn, address,
++                               recog_data.operand_loc[opno],
++                               recog_data.operand_mode[opno], cop);
++          }
++
++        result = true;
++      }
++      else if (TARGET_HAS_ASM_ADDR_PSEUDOS
++             && avr32_address_operand (op, GET_MODE (op)))
++      {
++        /* Handle pseudo instructions using a direct address. These pseudo
++           instructions might need entries in the constant pool and we must
++           therefor create a constant pool for them, in case the
++           assembler/linker needs to insert entries. */
++        if (do_pushes)
++          {
++            /* Push a dummy constant pool entry so that the .cpool
++               directive should be inserted on the appropriate place in the
++               code even if there are no real constant pool entries. This
++               is used by the assembler and linker to know where to put
++               generated constant pool entries. */
++            push_minipool_fix (insn, address,
++                               recog_data.operand_loc[opno],
++                               recog_data.operand_mode[opno],
++                               gen_rtx_UNSPEC (VOIDmode,
++                                               gen_rtvec (1, const0_rtx),
++                                               UNSPEC_FORCE_MINIPOOL));
++            result = true;
++          }
++      }
++    }
++  return result;
++}
++
++
++static int
++avr32_insn_is_cast (rtx insn)
++{
++
++  if (NONJUMP_INSN_P (insn)
++      && GET_CODE (PATTERN (insn)) == SET
++      && (GET_CODE (SET_SRC (PATTERN (insn))) == ZERO_EXTEND
++        || GET_CODE (SET_SRC (PATTERN (insn))) == SIGN_EXTEND)
++      && REG_P (XEXP (SET_SRC (PATTERN (insn)), 0))
++      && REG_P (SET_DEST (PATTERN (insn))))
++    return true;
++  return false;
++}
++
++/* FIXME: The level of nesting in this function is way too deep. It needs to be
++   torn apart.  */
++static void
++avr32_reorg_optimization (void)
++{
++  rtx first = get_insns ();
++  rtx insn;
++
++  if (TARGET_MD_REORG_OPTIMIZATION && (optimize_size || (optimize > 0)))
++    {
++
++      /* Scan through all insns looking for cast operations. */
++      if (dump_file)
++      {
++        fprintf (dump_file, ";; Deleting redundant cast operations:\n");
++      }
++      for (insn = first; insn; insn = NEXT_INSN (insn))
++      {
++        rtx reg, src_reg, scan;
++        enum machine_mode mode;
++        int unused_cast;
++        rtx label_ref;
++
++        if (avr32_insn_is_cast (insn)
++            && (GET_MODE (XEXP (SET_SRC (PATTERN (insn)), 0)) == QImode
++                || GET_MODE (XEXP (SET_SRC (PATTERN (insn)), 0)) == HImode))
++          {
++            mode = GET_MODE (XEXP (SET_SRC (PATTERN (insn)), 0));
++            reg = SET_DEST (PATTERN (insn));
++            src_reg = XEXP (SET_SRC (PATTERN (insn)), 0);
++          }
++        else
++          {
++            continue;
++          }
++
++        unused_cast = false;
++        label_ref = NULL_RTX;
++        for (scan = NEXT_INSN (insn); scan; scan = NEXT_INSN (scan))
++          {
++            /* Check if we have reached the destination of a simple
++               conditional jump which we have already scanned past. If so,
++               we can safely continue scanning. */
++            if (LABEL_P (scan) && label_ref != NULL_RTX)
++              {
++                if (CODE_LABEL_NUMBER (scan) ==
++                    CODE_LABEL_NUMBER (XEXP (label_ref, 0)))
++                  label_ref = NULL_RTX;
++                else
++                  break;
++              }
++
++            if (!INSN_P (scan))
++              continue;
++
++            /* For conditional jumps we can manage to keep on scanning if
++               we meet the destination label later on before any new jump
++               insns occure. */
++            if (GET_CODE (scan) == JUMP_INSN)
++              {
++                if (any_condjump_p (scan) && label_ref == NULL_RTX)
++                  label_ref = condjump_label (scan);
++                else
++                  break;
++              }
++
++            if (!reg_mentioned_p (reg, PATTERN (scan)))
++              continue;
++
++            /* Check if casted register is used in this insn */
++            if ((regno_use_in (REGNO (reg), PATTERN (scan)) != NULL_RTX)
++                && (GET_MODE (regno_use_in (REGNO (reg), PATTERN (scan))) ==
++                    GET_MODE (reg)))
++              {
++                /* If not used in the source to the set or in a memory
++                   expression in the destiantion then the register is used
++                   as a destination and is really dead. */
++                if (single_set (scan)
++                    && GET_CODE (PATTERN (scan)) == SET
++                    && REG_P (SET_DEST (PATTERN (scan)))
++                    && !regno_use_in (REGNO (reg), SET_SRC (PATTERN (scan)))
++                    && label_ref == NULL_RTX)
++                  {
++                    unused_cast = true;
++                  }
++                break;
++              }
++
++            /* Check if register is dead or set in this insn */
++            if (dead_or_set_p (scan, reg))
++              {
++                unused_cast = true;
++                break;
++              }
++          }
++
++        /* Check if we have unresolved conditional jumps */
++        if (label_ref != NULL_RTX)
++          continue;
++
++        if (unused_cast)
++          {
++            if (REGNO (reg) == REGNO (XEXP (SET_SRC (PATTERN (insn)), 0)))
++              {
++                /* One operand cast, safe to delete */
++                if (dump_file)
++                  {
++                    fprintf (dump_file,
++                             ";;  INSN %i removed, casted register %i value not used.\n",
++                             INSN_UID (insn), REGNO (reg));
++                  }
++                SET_INSN_DELETED (insn);
++                /* Force the instruction to be recognized again */
++                INSN_CODE (insn) = -1;
++              }
++            else
++              {
++                /* Two operand cast, which really could be substituted with
++                   a move, if the source register is dead after the cast
++                   insn and then the insn which sets the source register
++                   could instead directly set the destination register for
++                   the cast. As long as there are no insns in between which
++                   uses the register. */
++                rtx link = NULL_RTX;
++                rtx set;
++                rtx src_reg = XEXP (SET_SRC (PATTERN (insn)), 0);
++                unused_cast = false;
++
++                if (!find_reg_note (insn, REG_DEAD, src_reg))
++                  continue;
++
++                /* Search for the insn which sets the source register */
++                for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
++                  {
++                    if (REG_NOTE_KIND (link) != 0)
++                      continue;
++                    set = single_set (XEXP (link, 0));
++                    if (set && rtx_equal_p (src_reg, SET_DEST (set)))
++                      {
++                        link = XEXP (link, 0);
++                        break;
++                      }
++                  }
++
++                /* Found no link or link is a call insn where we can not
++                   change the destination register */
++                if (link == NULL_RTX || CALL_P (link))
++                  continue;
++
++                /* Scan through all insn between link and insn */
++                for (scan = NEXT_INSN (link); scan; scan = NEXT_INSN (scan))
++                  {
++                    /* Don't try to trace forward past a CODE_LABEL if we
++                       haven't seen INSN yet.  Ordinarily, we will only
++                       find the setting insn in LOG_LINKS if it is in the
++                       same basic block.  However, cross-jumping can insert
++                       code labels in between the load and the call, and
++                       can result in situations where a single call insn
++                       may have two targets depending on where we came
++                       from.  */
++
++                    if (GET_CODE (scan) == CODE_LABEL)
++                      break;
++
++                    if (!INSN_P (scan))
++                      continue;
++
++                    /* Don't try to trace forward past a JUMP.  To optimize
++                       safely, we would have to check that all the
++                       instructions at the jump destination did not use REG.
++                     */
++
++                    if (GET_CODE (scan) == JUMP_INSN)
++                      {
++                        break;
++                      }
++
++                    if (!reg_mentioned_p (src_reg, PATTERN (scan)))
++                      continue;
++
++                    /* We have reached the cast insn */
++                    if (scan == insn)
++                      {
++                        /* We can remove cast and replace the destination
++                           register of the link insn with the destination
++                           of the cast */
++                        if (dump_file)
++                          {
++                            fprintf (dump_file,
++                                     ";;  INSN %i removed, casted value unused. "
++                                     "Destination of removed cast operation: register %i,  folded into INSN %i.\n",
++                                     INSN_UID (insn), REGNO (reg),
++                                     INSN_UID (link));
++                          }
++                        /* Update link insn */
++                        SET_DEST (PATTERN (link)) =
++                          gen_rtx_REG (mode, REGNO (reg));
++                        /* Force the instruction to be recognized again */
++                        INSN_CODE (link) = -1;
++
++                        /* Delete insn */
++                        SET_INSN_DELETED (insn);
++                        /* Force the instruction to be recognized again */
++                        INSN_CODE (insn) = -1;
++                        break;
++                      }
++                  }
++              }
++          }
++      }
++    }
++
++  if (TARGET_MD_REORG_OPTIMIZATION && (optimize_size || (optimize > 0)))
++    {
++
++      /* Scan through all insns looking for shifted add operations */
++      if (dump_file)
++      {
++        fprintf (dump_file,
++                 ";; Deleting redundant shifted add operations:\n");
++      }
++      for (insn = first; insn; insn = NEXT_INSN (insn))
++      {
++        rtx reg, mem_expr, scan, op0, op1;
++        int add_only_used_as_pointer;
++
++        if (INSN_P (insn)
++            && GET_CODE (PATTERN (insn)) == SET
++            && GET_CODE (SET_SRC (PATTERN (insn))) == PLUS
++            && (GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 0)) == MULT
++                || GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 0)) == ASHIFT)
++            && GET_CODE (XEXP (XEXP (SET_SRC (PATTERN (insn)), 0), 1)) ==
++            CONST_INT && REG_P (SET_DEST (PATTERN (insn)))
++            && REG_P (XEXP (SET_SRC (PATTERN (insn)), 1))
++            && REG_P (XEXP (XEXP (SET_SRC (PATTERN (insn)), 0), 0)))
++          {
++            reg = SET_DEST (PATTERN (insn));
++            mem_expr = SET_SRC (PATTERN (insn));
++            op0 = XEXP (XEXP (mem_expr, 0), 0);
++            op1 = XEXP (mem_expr, 1);
++          }
++        else
++          {
++            continue;
++          }
++
++        /* Scan forward the check if the result of the shifted add
++           operation is only used as an address in memory operations and
++           that the operands to the shifted add are not clobbered. */
++        add_only_used_as_pointer = false;
++        for (scan = NEXT_INSN (insn); scan; scan = NEXT_INSN (scan))
++          {
++            if (!INSN_P (scan))
++              continue;
++
++            /* Don't try to trace forward past a JUMP or CALL.  To optimize
++               safely, we would have to check that all the instructions at
++               the jump destination did not use REG.  */
++
++            if (GET_CODE (scan) == JUMP_INSN)
++              {
++                break;
++              }
++
++            /* If used in a call insn then we cannot optimize it away */
++            if (CALL_P (scan) && find_regno_fusage (scan, USE, REGNO (reg)))
++              break;
++
++            /* If any of the operands of the shifted add are clobbered we
++               cannot optimize the shifted adda away */
++            if ((reg_set_p (op0, scan) && (REGNO (op0) != REGNO (reg)))
++                || (reg_set_p (op1, scan) && (REGNO (op1) != REGNO (reg))))
++              break;
++
++            if (!reg_mentioned_p (reg, PATTERN (scan)))
++              continue;
++
++            /* If used any other place than as a pointer or as the
++               destination register we failed */
++            if (!(single_set (scan)
++                  && GET_CODE (PATTERN (scan)) == SET
++                  && ((MEM_P (SET_DEST (PATTERN (scan)))
++                       && REG_P (XEXP (SET_DEST (PATTERN (scan)), 0))
++                       && REGNO (XEXP (SET_DEST (PATTERN (scan)), 0)) ==
++                       REGNO (reg)) || (MEM_P (SET_SRC (PATTERN (scan)))
++                                        &&
++                                        REG_P (XEXP
++                                               (SET_SRC (PATTERN (scan)),
++                                                0))
++                                        &&
++                                        REGNO (XEXP
++                                               (SET_SRC (PATTERN (scan)),
++                                                0)) == REGNO (reg))))
++                && !(GET_CODE (PATTERN (scan)) == SET
++                     && REG_P (SET_DEST (PATTERN (scan)))
++                     && !regno_use_in (REGNO (reg),
++                                       SET_SRC (PATTERN (scan)))))
++              break;
++
++            /* Check if register is dead or set in this insn */
++            if (dead_or_set_p (scan, reg))
++              {
++                add_only_used_as_pointer = true;
++                break;
++              }
++          }
++
++        if (add_only_used_as_pointer)
++          {
++            /* Lets delete the add insn and replace all memory references
++               which uses the pointer with the full expression. */
++            if (dump_file)
++              {
++                fprintf (dump_file,
++                         ";; Deleting INSN %i since address expression can be folded into all "
++                         "memory references using this expression\n",
++                         INSN_UID (insn));
++              }
++            SET_INSN_DELETED (insn);
++            /* Force the instruction to be recognized again */
++            INSN_CODE (insn) = -1;
++
++            for (scan = NEXT_INSN (insn); scan; scan = NEXT_INSN (scan))
++              {
++                if (!INSN_P (scan))
++                  continue;
++
++                if (!reg_mentioned_p (reg, PATTERN (scan)))
++                  continue;
++
++                /* If used any other place than as a pointer or as the
++                   destination register we failed */
++                if ((single_set (scan)
++                     && GET_CODE (PATTERN (scan)) == SET
++                     && ((MEM_P (SET_DEST (PATTERN (scan)))
++                          && REG_P (XEXP (SET_DEST (PATTERN (scan)), 0))
++                          && REGNO (XEXP (SET_DEST (PATTERN (scan)), 0)) ==
++                          REGNO (reg)) || (MEM_P (SET_SRC (PATTERN (scan)))
++                                           &&
++                                           REG_P (XEXP
++                                                  (SET_SRC (PATTERN (scan)),
++                                                   0))
++                                           &&
++                                           REGNO (XEXP
++                                                  (SET_SRC (PATTERN (scan)),
++                                                   0)) == REGNO (reg)))))
++                  {
++                    if (dump_file)
++                      {
++                        fprintf (dump_file,
++                                 ";; Register %i replaced by indexed address in INSN %i\n",
++                                 REGNO (reg), INSN_UID (scan));
++                      }
++                    if (MEM_P (SET_DEST (PATTERN (scan))))
++                      XEXP (SET_DEST (PATTERN (scan)), 0) = mem_expr;
++                    else
++                      XEXP (SET_SRC (PATTERN (scan)), 0) = mem_expr;
++                  }
++
++                /* Check if register is dead or set in this insn */
++                if (dead_or_set_p (scan, reg))
++                  {
++                    break;
++                  }
++
++              }
++          }
++      }
++    }
++}
++
++/* Exported to toplev.c.
++
++   Do a final pass over the function, just before delayed branch
++   scheduling.  */
++
++static void
++avr32_reorg (void)
++{
++  rtx insn;
++  HOST_WIDE_INT address = 0;
++  Mfix *fix;
++
++  minipool_fix_head = minipool_fix_tail = NULL;
++
++  /* The first insn must always be a note, or the code below won't scan it
++     properly.  */
++  insn = get_insns ();
++  if (GET_CODE (insn) != NOTE)
++    abort ();
++
++  /* Scan all the insns and record the operands that will need fixing.  */
++  for (insn = next_nonnote_insn (insn); insn; insn = next_nonnote_insn (insn))
++    {
++      if (GET_CODE (insn) == BARRIER)
++      push_minipool_barrier (insn, address);
++      else if (INSN_P (insn))
++      {
++        rtx table;
++
++        note_invalid_constants (insn, address, true);
++        address += get_attr_length (insn);
++
++        /* If the insn is a vector jump, add the size of the table and skip
++           the table.  */
++        if ((table = is_jump_table (insn)) != NULL)
++          {
++            address += get_jump_table_size (table);
++            insn = table;
++          }
++      }
++    }
++
++  fix = minipool_fix_head;
++
++  /* Now scan the fixups and perform the required changes.  */
++  while (fix)
++    {
++      Mfix *ftmp;
++      Mfix *fdel;
++      Mfix *last_added_fix;
++      Mfix *last_barrier = NULL;
++      Mfix *this_fix;
++
++      /* Skip any further barriers before the next fix.  */
++      while (fix && GET_CODE (fix->insn) == BARRIER)
++      fix = fix->next;
++
++      /* No more fixes.  */
++      if (fix == NULL)
++      break;
++
++      last_added_fix = NULL;
++
++      for (ftmp = fix; ftmp; ftmp = ftmp->next)
++      {
++        if (GET_CODE (ftmp->insn) == BARRIER)
++          {
++            if (ftmp->address >= minipool_vector_head->max_address)
++              break;
++
++            last_barrier = ftmp;
++          }
++        else if ((ftmp->minipool = add_minipool_forward_ref (ftmp)) == NULL)
++          break;
++
++        last_added_fix = ftmp;        /* Keep track of the last fix added.
++                                         */
++      }
++
++      /* If we found a barrier, drop back to that; any fixes that we could
++         have reached but come after the barrier will now go in the next
++         mini-pool.  */
++      if (last_barrier != NULL)
++      {
++        /* Reduce the refcount for those fixes that won't go into this pool
++           after all.  */
++        for (fdel = last_barrier->next;
++             fdel && fdel != ftmp; fdel = fdel->next)
++          {
++            fdel->minipool->refcount--;
++            fdel->minipool = NULL;
++          }
++
++        ftmp = last_barrier;
++      }
++      else
++      {
++        /* ftmp is first fix that we can't fit into this pool and there no
++           natural barriers that we could use.  Insert a new barrier in the
++           code somewhere between the previous fix and this one, and
++           arrange to jump around it.  */
++        HOST_WIDE_INT max_address;
++
++        /* The last item on the list of fixes must be a barrier, so we can
++           never run off the end of the list of fixes without last_barrier
++           being set.  */
++        if (ftmp == NULL)
++          abort ();
++
++        max_address = minipool_vector_head->max_address;
++        /* Check that there isn't another fix that is in range that we
++           couldn't fit into this pool because the pool was already too
++           large: we need to put the pool before such an instruction.  */
++        if (ftmp->address < max_address)
++          max_address = ftmp->address;
++
++        last_barrier = create_fix_barrier (last_added_fix, max_address);
++      }
++
++      assign_minipool_offsets (last_barrier);
++
++      while (ftmp)
++      {
++        if (GET_CODE (ftmp->insn) != BARRIER
++            && ((ftmp->minipool = add_minipool_backward_ref (ftmp))
++                == NULL))
++          break;
++
++        ftmp = ftmp->next;
++      }
++
++      /* Scan over the fixes we have identified for this pool, fixing them up
++         and adding the constants to the pool itself.  */
++      for (this_fix = fix; this_fix && ftmp != this_fix;
++         this_fix = this_fix->next)
++      if (GET_CODE (this_fix->insn) != BARRIER
++          /* Do nothing for entries present just to force the insertion of
++             a minipool. */
++          && !IS_FORCE_MINIPOOL (this_fix->value))
++        {
++          rtx addr = plus_constant (gen_rtx_LABEL_REF (VOIDmode,
++                                                       minipool_vector_label),
++                                    this_fix->minipool->offset);
++          *this_fix->loc = gen_rtx_MEM (this_fix->mode, addr);
++        }
++
++      dump_minipool (last_barrier->insn);
++      fix = ftmp;
++    }
++
++  /* Free the minipool memory.  */
++  obstack_free (&minipool_obstack, minipool_startobj);
++
++  avr32_reorg_optimization ();
++}
++
++
++/*
++ Hook for doing some final scanning of instructions. Does nothing yet...*/
++void
++avr32_final_prescan_insn (rtx insn ATTRIBUTE_UNUSED,
++                        rtx * opvec ATTRIBUTE_UNUSED,
++                        int noperands ATTRIBUTE_UNUSED)
++{
++  return;
++}
++
++
++
++int
++avr32_expand_movcc (enum machine_mode mode, rtx operands[])
++{
++  rtx operator;
++  rtx compare_op0 = avr32_compare_op0;
++  rtx compare_op1 = avr32_compare_op1;
++
++  /* Only allow certain compare operations */
++  if (GET_MODE (compare_op0) != DImode
++      && GET_MODE (compare_op0) != SImode
++      && GET_MODE (compare_op0) != HImode && GET_MODE (compare_op0) != QImode)
++    return FALSE;
++
++  if (GET_CODE (compare_op0) == MEM)
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      compare_op0 = force_reg (GET_MODE (compare_op0), compare_op0);
++    }
++
++  if (GET_CODE (compare_op1) == MEM)
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      compare_op1 = force_reg (GET_MODE (compare_op1), compare_op1);
++    }
++
++  /* For DI, HI and QI mode force comparison operands to registers */
++  if (GET_MODE (compare_op0) == DImode
++      || GET_MODE (compare_op0) == HImode || GET_MODE (compare_op0) == QImode)
++    {
++      if (GET_CODE (compare_op0) != REG)
++      {
++        if (no_new_pseudos)
++          return FALSE;
++        else
++          compare_op0 = force_reg (GET_MODE (compare_op0), compare_op0);
++      }
++
++      if (GET_CODE (compare_op1) != REG)
++      {
++        if (no_new_pseudos)
++          return FALSE;
++        else
++          compare_op1 = force_reg (GET_MODE (compare_op0), compare_op1);
++      }
++    }
++
++  /* Force any immediate compare operands for SI, larger than the L
++     constraint, to a register */
++  if (GET_MODE (compare_op0) == SImode)
++    {
++      if ((GET_CODE (compare_op0) == CONST_INT
++         && !avr32_const_ok_for_constraint_p (INTVAL (compare_op0), 'K',
++                                              "Ks21")))
++      {
++        if (no_new_pseudos)
++          return FALSE;
++        else
++          compare_op0 = force_reg (SImode, compare_op0);
++      }
++
++      if ((GET_CODE (compare_op1) == CONST_INT
++         && !avr32_const_ok_for_constraint_p (INTVAL (compare_op1), 'K',
++                                              "Ks21")))
++      {
++        if (no_new_pseudos)
++          return FALSE;
++        else
++          compare_op1 = force_reg (SImode, compare_op1);
++      }
++    }
++
++  /* If we have immediates larger than can be allowed in conditional mov
++     instructions, force them to registers */
++  if (GET_CODE (operands[2]) == CONST_INT
++      && !avr32_const_ok_for_constraint_p (INTVAL (operands[2]), 'K', "Ks08"))
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      operands[2] = force_reg (mode, operands[2]);
++    }
++
++  if (GET_CODE (operands[3]) == CONST_INT
++      && !avr32_const_ok_for_constraint_p (INTVAL (operands[3]), 'K', "Ks08"))
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      operands[3] = force_reg (mode, operands[3]);
++    }
++
++  /* Emit the actual instruction */
++  operator = gen_rtx_EQ (VOIDmode, const0_rtx, const0_rtx);
++  PUT_CODE (operator, GET_CODE (operands[1]));
++  switch (mode)
++    {
++    case SImode:
++      switch (GET_MODE (compare_op0))
++      {
++      case SImode:
++        emit_insn (gen_movsicc_cmpsi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case DImode:
++        emit_insn (gen_movsicc_cmpdi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case HImode:
++        emit_insn (gen_movsicc_cmphi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case QImode:
++        emit_insn (gen_movsicc_cmpqi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      default:
++        return FALSE;
++      }
++      break;
++    case HImode:
++      switch (GET_MODE (compare_op0))
++      {
++      case SImode:
++        emit_insn (gen_movhicc_cmpsi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case DImode:
++        emit_insn (gen_movhicc_cmpdi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case HImode:
++        emit_insn (gen_movhicc_cmphi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case QImode:
++        emit_insn (gen_movhicc_cmpqi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      default:
++        return FALSE;
++      }
++      break;
++    case QImode:
++      switch (GET_MODE (compare_op0))
++      {
++      case SImode:
++        emit_insn (gen_movqicc_cmpsi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case DImode:
++        emit_insn (gen_movqicc_cmpdi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case HImode:
++        emit_insn (gen_movqicc_cmphi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case QImode:
++        emit_insn (gen_movqicc_cmpqi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      default:
++        return FALSE;
++      }
++      break;
++    default:
++      return FALSE;
++    }
++
++  return TRUE;
++}
++
++
++int
++avr32_expand_addcc (enum machine_mode mode, rtx operands[])
++{
++  rtx operator;
++  rtx compare_op0 = avr32_compare_op0;
++  rtx compare_op1 = avr32_compare_op1;
++
++  /* Check if we have an add/sub with an k8 immediate */
++  if (!(GET_CODE (operands[3]) == CONST_INT
++      && avr32_const_ok_for_constraint_p (-INTVAL (operands[3]), 'K',
++                                          "Ks08")))
++    return FALSE;
++  else
++    /* Flip sign */
++    operands[3] = GEN_INT (-INTVAL (operands[3]));
++
++  /* Only allow certain compare operations */
++  if (GET_MODE (compare_op0) != DImode
++      && GET_MODE (compare_op0) != SImode
++      && GET_MODE (compare_op0) != HImode && GET_MODE (compare_op0) != QImode)
++    return FALSE;
++
++  if (GET_CODE (compare_op0) == MEM)
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      compare_op0 = force_reg (GET_MODE (compare_op0), compare_op0);
++    }
++
++  if (GET_CODE (compare_op1) == MEM)
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      compare_op1 = force_reg (GET_MODE (compare_op1), compare_op1);
++    }
++
++  /* For DI, HI and QI mode force comparison operands to registers */
++  if (GET_MODE (compare_op0) == DImode
++      || GET_MODE (compare_op0) == HImode || GET_MODE (compare_op0) == QImode)
++    {
++      if (GET_CODE (compare_op0) != REG)
++      {
++        if (no_new_pseudos)
++          return FALSE;
++        else
++          compare_op0 = force_reg (GET_MODE (compare_op0), compare_op0);
++      }
++
++      if (GET_CODE (compare_op1) != REG)
++      {
++        if (no_new_pseudos)
++          return FALSE;
++        else
++          compare_op1 = force_reg (GET_MODE (compare_op0), compare_op1);
++      }
++    }
++
++  /* Force any immediate compare operands for SI, larger than the L
++     constraint, to a register */
++  if (GET_MODE (compare_op0) == SImode)
++    {
++      if ((GET_CODE (compare_op0) == CONST_INT
++         && !avr32_const_ok_for_constraint_p (INTVAL (compare_op0), 'K',
++                                              "Ks21")))
++      {
++        if (no_new_pseudos)
++          return FALSE;
++        else
++          compare_op0 = force_reg (SImode, compare_op0);
++      }
++
++      if ((GET_CODE (compare_op1) == CONST_INT
++         && !avr32_const_ok_for_constraint_p (INTVAL (compare_op1), 'K',
++                                              "Ks21")))
++      {
++        if (no_new_pseudos)
++          return FALSE;
++        else
++          compare_op1 = force_reg (SImode, compare_op1);
++      }
++    }
++
++  /* If we have immediates larger than can be allowed in conditional mov
++     instructions, force them to registers */
++  if (GET_CODE (operands[2]) == CONST_INT
++      && !avr32_const_ok_for_constraint_p (INTVAL (operands[2]), 'K', "Ks08"))
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      operands[2] = force_reg (mode, operands[2]);
++    }
++
++  if (GET_CODE (operands[3]) == CONST_INT
++      && !avr32_const_ok_for_constraint_p (INTVAL (operands[3]), 'K', "Ks08"))
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      operands[3] = force_reg (mode, operands[3]);
++    }
++
++  if (GET_CODE (operands[0]) != REG)
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      operands[0] = force_reg (GET_MODE (operands[0]), operands[0]);
++    }
++
++  if (GET_CODE (operands[2]) != REG)
++    {
++      if (no_new_pseudos)
++      return FALSE;
++      else
++      operands[2] = force_reg (GET_MODE (operands[2]), operands[2]);
++    }
++
++  /* Check if operands[0] and operands[2] are different */
++  if (REGNO (operands[0]) != REGNO (operands[2]))
++    {
++      emit_move_insn (operands[0], operands[2]);
++      operands[2] = operands[0];
++    }
++
++  /* Emit the actual instruction */
++  operator = gen_rtx_EQ (VOIDmode, const0_rtx, const0_rtx);
++  PUT_CODE (operator, GET_CODE (operands[1]));
++  switch (mode)
++    {
++    case SImode:
++      switch (GET_MODE (compare_op0))
++      {
++      case SImode:
++        emit_insn (gen_addsicc_cmpsi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case DImode:
++        emit_insn (gen_addsicc_cmpdi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case HImode:
++        emit_insn (gen_addsicc_cmphi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case QImode:
++        emit_insn (gen_addsicc_cmpqi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      default:
++        return FALSE;
++      }
++      break;
++    case HImode:
++      switch (GET_MODE (compare_op0))
++      {
++      case SImode:
++        emit_insn (gen_addhicc_cmpsi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case DImode:
++        emit_insn (gen_addhicc_cmpdi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case HImode:
++        emit_insn (gen_addhicc_cmphi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case QImode:
++        emit_insn (gen_addhicc_cmpqi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      default:
++        return FALSE;
++      }
++      break;
++    case QImode:
++      switch (GET_MODE (compare_op0))
++      {
++      case SImode:
++        emit_insn (gen_addqicc_cmpsi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case DImode:
++        emit_insn (gen_addqicc_cmpdi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case HImode:
++        emit_insn (gen_addqicc_cmphi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      case QImode:
++        emit_insn (gen_addqicc_cmpqi
++                   (operands[0], operator, operands[2], operands[3],
++                    compare_op0, compare_op1));
++        break;
++      default:
++        return FALSE;
++      }
++      break;
++    default:
++      return FALSE;
++    }
++
++  return TRUE;
++}
++
++/* Function for changing the condition on the next instruction,
++   should be used when emmiting compare instructions and
++   the condition of the next instruction needs to change.
++*/
++int
++set_next_insn_cond (rtx cur_insn, rtx new_cond)
++{
++  rtx next_insn = next_nonnote_insn (cur_insn);
++  if ((next_insn != NULL_RTX)
++      && (INSN_P (next_insn))
++      && (GET_CODE (PATTERN (next_insn)) == SET)
++      && (GET_CODE (SET_SRC (PATTERN (next_insn))) == IF_THEN_ELSE))
++    {
++      /* Branch instructions */
++      XEXP (SET_SRC (PATTERN (next_insn)), 0) = new_cond;
++      /* Force the instruction to be recognized again */
++      INSN_CODE (next_insn) = -1;
++      return TRUE;
++    }
++  else if ((next_insn != NULL_RTX)
++         && (INSN_P (next_insn))
++         && (GET_CODE (PATTERN (next_insn)) == SET)
++         && comparison_operator (SET_SRC (PATTERN (next_insn)),
++                                 GET_MODE (SET_SRC (PATTERN (next_insn)))))
++    {
++      /* scc with no compare */
++      SET_SRC (PATTERN (next_insn)) = new_cond;
++      /* Force the instruction to be recognized again */
++      INSN_CODE (next_insn) = -1;
++      return TRUE;
++    }
++
++  return FALSE;
++}
++
++/* Function for obtaining the condition for the next instruction
++   after cur_insn.
++*/
++rtx
++get_next_insn_cond (rtx cur_insn)
++{
++  rtx next_insn = next_nonnote_insn (cur_insn);
++  rtx cond = NULL_RTX;
++  if ((next_insn != NULL_RTX)
++      && (INSN_P (next_insn))
++      && (GET_CODE (PATTERN (next_insn)) == SET)
++      && (GET_CODE (SET_SRC (PATTERN (next_insn))) == IF_THEN_ELSE))
++    {
++      /* Branch instructions */
++      cond = XEXP (SET_SRC (PATTERN (next_insn)), 0);
++    }
++  else if ((next_insn != NULL_RTX)
++         && (INSN_P (next_insn))
++         && (GET_CODE (PATTERN (next_insn)) == SET)
++         && comparison_operator (SET_SRC (PATTERN (next_insn)),
++                                 GET_MODE (SET_SRC (PATTERN (next_insn)))))
++    {
++      /* scc with no compare */
++      cond = SET_SRC (PATTERN (next_insn));
++    }
++
++  return cond;
++}
++
++int
++avr32_expand_scc (enum rtx_code cond, rtx * operands)
++{
++
++  rtx comparation;
++  /* Only allow certain compare operations */
++  if (GET_MODE (avr32_compare_op0) != DImode
++      && GET_MODE (avr32_compare_op0) != SImode
++      && GET_MODE (avr32_compare_op0) != HImode
++      && GET_MODE (avr32_compare_op0) != QImode)
++    return FALSE;
++
++  /* Delete compare instruction as it is merged into this instruction */
++  remove_insn (get_last_insn_anywhere ());
++
++  if (!REG_P (avr32_compare_op0))
++    avr32_compare_op0 =
++      force_reg (GET_MODE (avr32_compare_op0), avr32_compare_op0);
++
++  if (GET_MODE (avr32_compare_op0) != SImode && !REG_P (avr32_compare_op1))
++    {
++      avr32_compare_op1 =
++      force_reg (GET_MODE (avr32_compare_op0), avr32_compare_op1);
++    }
++  else if (GET_MODE (avr32_compare_op0) == SImode
++         && !REG_P (avr32_compare_op1)
++         && (GET_CODE (avr32_compare_op1) != CONST_INT
++             || (GET_CODE (avr32_compare_op1) == CONST_INT
++                 &&
++                 !avr32_const_ok_for_constraint_p (INTVAL
++                                                   (avr32_compare_op1), 'K',
++                                                   "Ks21"))))
++    avr32_compare_op1 =
++      force_reg (GET_MODE (avr32_compare_op0), avr32_compare_op1);
++
++
++  comparation =
++    gen_rtx_EQ (SImode,
++              gen_rtx_COMPARE (GET_MODE (avr32_compare_op0),
++                               avr32_compare_op0, avr32_compare_op1),
++              const0_rtx);
++  /* Set correct condition */
++  PUT_CODE (comparation, cond);
++  emit_insn (gen_rtx_SET (VOIDmode, operands[0], comparation));
++  return TRUE;
++}
++
++rtx
++avr32_output_cmp (rtx cond, enum machine_mode mode, rtx op0, rtx op1)
++{
++
++  rtx new_cond = NULL_RTX;
++  rtx ops[2];
++  rtx compare_pattern;
++  ops[0] = op0;
++  ops[1] = op1;
++
++  compare_pattern = gen_rtx_COMPARE (mode, op0, op1);
++
++  new_cond = is_compare_redundant (compare_pattern, cond);
++
++  if (new_cond != NULL_RTX)
++    return new_cond;
++
++  /* Insert compare */
++  switch (mode)
++    {
++    case QImode:
++      output_asm_insn ("cp.b\t%0, %1", ops);
++      break;
++    case HImode:
++      output_asm_insn ("cp.h\t%0, %1", ops);
++      break;
++    case SImode:
++      output_asm_insn ("cp.w\t%0, %1", ops);
++      break;
++    case DImode:
++      if (rtx_equal_p (op1, const0_rtx))
++      output_asm_insn ("cp.w\t%0, %1\ncpc\t%m0", ops);
++      else
++      output_asm_insn ("cp.w\t%0, %1\ncpc\t%m0, %m1", ops);
++      break;
++    default:
++      internal_error ("Unknown comparison mode");
++      break;
++    }
++
++  return cond;
++}
++
++int
++avr32_load_multiple_operation (rtx op,
++                             enum machine_mode mode ATTRIBUTE_UNUSED)
++{
++  int count = XVECLEN (op, 0);
++  unsigned int dest_regno;
++  rtx src_addr;
++  rtx elt;
++  int i = 1, base = 0;
++
++  if (count <= 1 || GET_CODE (XVECEXP (op, 0, 0)) != SET)
++    return 0;
++
++  /* Check to see if this might be a write-back.  */
++  if (GET_CODE (SET_SRC (elt = XVECEXP (op, 0, 0))) == PLUS)
++    {
++      i++;
++      base = 1;
++
++      /* Now check it more carefully.  */
++      if (GET_CODE (SET_DEST (elt)) != REG
++        || GET_CODE (XEXP (SET_SRC (elt), 0)) != REG
++        || GET_CODE (XEXP (SET_SRC (elt), 1)) != CONST_INT
++        || INTVAL (XEXP (SET_SRC (elt), 1)) != (count - 1) * 4)
++      return 0;
++    }
++
++  /* Perform a quick check so we don't blow up below.  */
++  if (count <= 1
++      || GET_CODE (XVECEXP (op, 0, i - 1)) != SET
++      || GET_CODE (SET_DEST (XVECEXP (op, 0, i - 1))) != REG
++      || GET_CODE (SET_SRC (XVECEXP (op, 0, i - 1))) != UNSPEC)
++    return 0;
++
++  dest_regno = REGNO (SET_DEST (XVECEXP (op, 0, i - 1)));
++  src_addr = XEXP (SET_SRC (XVECEXP (op, 0, i - 1)), 0);
++
++  for (; i < count; i++)
++    {
++      elt = XVECEXP (op, 0, i);
++
++      if (GET_CODE (elt) != SET
++        || GET_CODE (SET_DEST (elt)) != REG
++        || GET_MODE (SET_DEST (elt)) != SImode
++        || GET_CODE (SET_SRC (elt)) != UNSPEC)
++      return 0;
++    }
++
++  return 1;
++}
++
++int
++avr32_store_multiple_operation (rtx op,
++                              enum machine_mode mode ATTRIBUTE_UNUSED)
++{
++  int count = XVECLEN (op, 0);
++  int src_regno;
++  rtx dest_addr;
++  rtx elt;
++  int i = 1;
++
++  if (count <= 1 || GET_CODE (XVECEXP (op, 0, 0)) != SET)
++    return 0;
++
++  /* Perform a quick check so we don't blow up below.  */
++  if (count <= i
++      || GET_CODE (XVECEXP (op, 0, i - 1)) != SET
++      || GET_CODE (SET_DEST (XVECEXP (op, 0, i - 1))) != MEM
++      || GET_CODE (SET_SRC (XVECEXP (op, 0, i - 1))) != UNSPEC)
++    return 0;
++
++  src_regno = REGNO (SET_SRC (XVECEXP (op, 0, i - 1)));
++  dest_addr = XEXP (SET_DEST (XVECEXP (op, 0, i - 1)), 0);
++
++  for (; i < count; i++)
++    {
++      elt = XVECEXP (op, 0, i);
++
++      if (GET_CODE (elt) != SET
++        || GET_CODE (SET_DEST (elt)) != MEM
++        || GET_MODE (SET_DEST (elt)) != SImode
++        || GET_CODE (SET_SRC (elt)) != UNSPEC)
++      return 0;
++    }
++
++  return 1;
++}
++
++int
++avr32_valid_macmac_bypass (rtx insn_out, rtx insn_in)
++{
++  /* Check if they use the same accumulator */
++  if (rtx_equal_p
++      (SET_DEST (PATTERN (insn_out)), SET_DEST (PATTERN (insn_in))))
++    {
++      return TRUE;
++    }
++
++  return FALSE;
++}
++
++int
++avr32_valid_mulmac_bypass (rtx insn_out, rtx insn_in)
++{
++  /*
++     Check if the mul instruction produces the accumulator for the mac
++     instruction. */
++  if (rtx_equal_p
++      (SET_DEST (PATTERN (insn_out)), SET_DEST (PATTERN (insn_in))))
++    {
++      return TRUE;
++    }
++  return FALSE;
++}
++
++int
++avr32_store_bypass (rtx insn_out, rtx insn_in)
++{
++  /* Only valid bypass if the output result is used as an src in the store
++     instruction, NOT if used as a pointer or base. */
++  if (rtx_equal_p
++      (SET_DEST (PATTERN (insn_out)), SET_SRC (PATTERN (insn_in))))
++    {
++      return TRUE;
++    }
++
++  return FALSE;
++}
++
++int
++avr32_mul_waw_bypass (rtx insn_out, rtx insn_in)
++{
++  /* Check if the register holding the result from the mul instruction is
++     used as a result register in the input instruction. */
++  if (rtx_equal_p
++      (SET_DEST (PATTERN (insn_out)), SET_DEST (PATTERN (insn_in))))
++    {
++      return TRUE;
++    }
++
++  return FALSE;
++}
++
++int
++avr32_valid_load_double_bypass (rtx insn_out, rtx insn_in)
++{
++  /* Check if the first loaded word in insn_out is used in insn_in. */
++  rtx dst_reg;
++  rtx second_loaded_reg;
++
++  /* If this is a double alu operation then the bypass is not valid */
++  if ((get_attr_type (insn_in) == TYPE_ALU
++       || get_attr_type (insn_in) == TYPE_ALU2)
++      && (GET_MODE_SIZE (GET_MODE (SET_DEST (PATTERN (insn_out)))) > 4))
++    return FALSE;
++
++  /* Get the destination register in the load */
++  if (!REG_P (SET_DEST (PATTERN (insn_out))))
++    return FALSE;
++
++  dst_reg = SET_DEST (PATTERN (insn_out));
++  second_loaded_reg = gen_rtx_REG (SImode, REGNO (dst_reg) + 1);
++
++  if (!reg_mentioned_p (second_loaded_reg, PATTERN (insn_in)))
++    return TRUE;
++
++  return FALSE;
++}
++
++
++int
++avr32_valid_load_quad_bypass (rtx insn_out, rtx insn_in)
++{
++  /*
++     Check if the two first loaded word in insn_out are used in insn_in. */
++  rtx dst_reg;
++  rtx third_loaded_reg, fourth_loaded_reg;
++
++  /* Get the destination register in the load */
++  if (!REG_P (SET_DEST (PATTERN (insn_out))))
++    return FALSE;
++
++  dst_reg = SET_DEST (PATTERN (insn_out));
++  third_loaded_reg = gen_rtx_REG (SImode, REGNO (dst_reg) + 2);
++  fourth_loaded_reg = gen_rtx_REG (SImode, REGNO (dst_reg) + 3);
++
++  if (!reg_mentioned_p (third_loaded_reg, PATTERN (insn_in))
++      && !reg_mentioned_p (fourth_loaded_reg, PATTERN (insn_in)))
++    {
++      return TRUE;
++    }
++
++  return FALSE;
++}
++
++int
++avr32_sched_use_dfa_pipeline_interface (void)
++{
++  /* No need to scedule on avr32_uc architecture. */
++  return (avr32_arch->arch_type != ARCH_TYPE_AVR32_UC);
++}
++
++void
++avr32_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
++                        rtx x ATTRIBUTE_UNUSED,
++                        unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
++{
++  /* Let ASM_OUTPUT_POOL_PROLOGUE take care of this */
++}
++
++/* Set up library functions to comply to AVR32 ABI  */
++
++static void
++avr32_init_libfuncs (void)
++{
++  /* Convert gcc run-time function names to AVR32 ABI names */
++
++  /* Double-precision floating-point arithmetic. */
++  set_optab_libfunc (add_optab, DFmode, "__avr32_f64_add");
++  set_optab_libfunc (sdiv_optab, DFmode, "__avr32_f64_div");
++  set_optab_libfunc (smul_optab, DFmode, "__avr32_f64_mul");
++  set_optab_libfunc (neg_optab, DFmode, NULL);
++  set_optab_libfunc (sub_optab, DFmode, "__avr32_f64_sub");
++
++  /* Double-precision comparisons.  */
++  set_optab_libfunc (eq_optab, DFmode, "__avr32_f64_cmp_eq");
++  set_optab_libfunc (ne_optab, DFmode, NULL);
++  set_optab_libfunc (lt_optab, DFmode, "__avr32_f64_cmp_lt");
++  set_optab_libfunc (le_optab, DFmode, NULL);
++  set_optab_libfunc (ge_optab, DFmode, "__avr32_f64_cmp_ge");
++  set_optab_libfunc (gt_optab, DFmode, NULL);
++
++  /* Single-precision floating-point arithmetic. */
++  set_optab_libfunc (add_optab, SFmode, "__avr32_f32_add");
++  set_optab_libfunc (sdiv_optab, SFmode, "__avr32_f32_div");
++  set_optab_libfunc (smul_optab, SFmode, "__avr32_f32_mul");
++  set_optab_libfunc (neg_optab, SFmode, NULL);
++  set_optab_libfunc (sub_optab, SFmode, "__avr32_f32_sub");
++
++  /* Single-precision comparisons.  */
++  set_optab_libfunc (eq_optab, SFmode, "__avr32_f32_cmp_eq");
++  set_optab_libfunc (ne_optab, SFmode, NULL);
++  set_optab_libfunc (lt_optab, SFmode, "__avr32_f32_cmp_lt");
++  set_optab_libfunc (le_optab, SFmode, NULL);
++  set_optab_libfunc (ge_optab, SFmode, "__avr32_f32_cmp_ge");
++  set_optab_libfunc (gt_optab, SFmode, NULL);
++
++  /* Floating-point to integer conversions. */
++  set_conv_libfunc (sfix_optab, SImode, DFmode, "__avr32_f64_to_s32");
++  set_conv_libfunc (ufix_optab, SImode, DFmode, "__avr32_f64_to_u32");
++  set_conv_libfunc (sfix_optab, DImode, DFmode, "__avr32_f64_to_s64");
++  set_conv_libfunc (ufix_optab, DImode, DFmode, "__avr32_f64_to_u64");
++  set_conv_libfunc (sfix_optab, SImode, SFmode, "__avr32_f32_to_s32");
++  set_conv_libfunc (ufix_optab, SImode, SFmode, "__avr32_f32_to_u32");
++  set_conv_libfunc (sfix_optab, DImode, SFmode, "__avr32_f32_to_s64");
++  set_conv_libfunc (ufix_optab, DImode, SFmode, "__avr32_f32_to_u64");
++
++  /* Conversions between floating types.  */
++  set_conv_libfunc (trunc_optab, SFmode, DFmode, "__avr32_f64_to_f32");
++  set_conv_libfunc (sext_optab, DFmode, SFmode, "__avr32_f32_to_f64");
++
++  /* Integer to floating-point conversions.  Table 8.  */
++  set_conv_libfunc (sfloat_optab, DFmode, SImode, "__avr32_s32_to_f64");
++  set_conv_libfunc (sfloat_optab, DFmode, DImode, "__avr32_s64_to_f64");
++  set_conv_libfunc (sfloat_optab, SFmode, SImode, "__avr32_s32_to_f32");
++  set_conv_libfunc (sfloat_optab, SFmode, DImode, "__avr32_s64_to_f32");
++  set_conv_libfunc (ufloat_optab, DFmode, SImode, "__avr32_u32_to_f64");
++  set_conv_libfunc (ufloat_optab, SFmode, SImode, "__avr32_u32_to_f32");
++  /* TODO: Add these to gcc library functions */
++
++  set_conv_libfunc (ufloat_optab, DFmode, DImode, NULL);
++  set_conv_libfunc (ufloat_optab, SFmode, DImode, NULL);
++
++  /* Long long.  Table 9.  */
++  set_optab_libfunc (smul_optab, DImode, "__avr32_mul64");
++  set_optab_libfunc (sdiv_optab, DImode, "__avr32_sdiv64");
++  set_optab_libfunc (udiv_optab, DImode, "__avr32_udiv64");
++  set_optab_libfunc (smod_optab, DImode, "__avr32_smod64");
++  set_optab_libfunc (umod_optab, DImode, "__avr32_umod64");
++  set_optab_libfunc (ashl_optab, DImode, "__avr32_lsl64");
++  set_optab_libfunc (lshr_optab, DImode, "__avr32_lsr64");
++  set_optab_libfunc (ashr_optab, DImode, "__avr32_asr64");
++}
+diff -Nur gcc-4.1.2/gcc/config/avr32/avr32-elf.h gcc-4.1.2-owrt/gcc/config/avr32/avr32-elf.h
+--- gcc-4.1.2/gcc/config/avr32/avr32-elf.h     1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/avr32-elf.h        2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,82 @@
++/*
++   Elf specific definitions.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++
++   This file is part of GCC.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
++
++
++/*****************************************************************************
++ * Controlling the Compilator Driver, 'gcc'
++ *****************************************************************************/
++
++/* Run-time Target Specification.  */
++#undef  TARGET_VERSION
++#define TARGET_VERSION  fputs (" (AVR32 GNU with ELF)", stderr);
++
++/*
++Another C string constant used much like LINK_SPEC.  The
++difference between the two is that STARTFILE_SPEC is used at
++the very beginning of the command given to the linker.
++
++If this macro is not defined, a default is provided that loads the
++standard C startup file from the usual place.  See gcc.c.
++*/
++#undef  STARTFILE_SPEC
++#define STARTFILE_SPEC "crt0%O%s crti%O%s crtbegin%O%s"
++
++#undef LINK_SPEC
++#define LINK_SPEC "%{muse-oscall:--defsym __do_not_use_oscall_coproc__=0} %{mrelax|O*:%{mno-relax|O0|O1: ;:--relax}} %{mpart=*:-mavr32elf_%*} %{mcpu=*:-mavr32elf_%*}"
++
++
++/*
++Another C string constant used much like LINK_SPEC.  The
++difference between the two is that ENDFILE_SPEC is used at
++the very end of the command given to the linker.
++
++Do not define this macro if it does not need to do anything.
++*/
++#undef  ENDFILE_SPEC
++#define ENDFILE_SPEC "crtend%O%s crtn%O%s"
++
++
++/* Target CPU builtins.  */
++#define TARGET_CPU_CPP_BUILTINS()                             \
++  do                                                          \
++    {                                                         \
++      builtin_define ("__avr32__");                           \
++      builtin_define ("__AVR32__");                           \
++      builtin_define ("__AVR32_ELF__");                               \
++      builtin_define (avr32_part->macro);                     \
++      builtin_define (avr32_arch->macro);                     \
++      if (avr32_arch->uarch_type == UARCH_TYPE_AVR32A)                \
++      builtin_define ("__AVR32_AVR32A__");                    \
++      else                                                    \
++      builtin_define ("__AVR32_AVR32B__");                    \
++      if (TARGET_UNALIGNED_WORD)                              \
++      builtin_define ("__AVR32_HAS_UNALIGNED_WORD__");        \
++      if (TARGET_SIMD)                                                \
++      builtin_define ("__AVR32_HAS_SIMD__");                  \
++      if (TARGET_DSP)                                         \
++      builtin_define ("__AVR32_HAS_DSP__");                   \
++      if (TARGET_RMW)                                         \
++      builtin_define ("__AVR32_HAS_RMW__");                   \
++      if (TARGET_BRANCH_PRED)                                 \
++      builtin_define ("__AVR32_HAS_BRANCH_PRED__");           \
++    }                                                         \
++  while (0)
+diff -Nur gcc-4.1.2/gcc/config/avr32/avr32.h gcc-4.1.2-owrt/gcc/config/avr32/avr32.h
+--- gcc-4.1.2/gcc/config/avr32/avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/avr32.h    2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,3322 @@
++/*
++   Definitions of target machine for AVR32.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++   Initial porting by Anders ï¿½dland.
++
++   This file is part of GCC.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
++
++#ifndef GCC_AVR32_H
++#define GCC_AVR32_H
++
++
++#ifndef OBJECT_FORMAT_ELF
++#error avr32.h included before elfos.h
++#endif
++
++#ifndef LOCAL_LABEL_PREFIX
++#define LOCAL_LABEL_PREFIX "."
++#endif
++
++#ifndef SUBTARGET_CPP_SPEC
++#define SUBTARGET_CPP_SPEC  "-D__ELF__"
++#endif
++
++
++extern struct rtx_def *avr32_compare_op0;
++extern struct rtx_def *avr32_compare_op1;
++
++
++extern struct rtx_def *avr32_acc_cache;
++
++/* cache instruction op5 codes */
++#define AVR32_CACHE_INVALIDATE_ICACHE 1
++
++/* These bits describe the different types of function supported
++   by the AVR32 backend.  They are exclusive.  ie a function cannot be both a
++   normal function and an interworked function, for example.  Knowing the
++   type of a function is important for determining its prologue and
++   epilogue sequences.
++   Note value 7 is currently unassigned.  Also note that the interrupt
++   function types all have bit 2 set, so that they can be tested for easily.
++   Note that 0 is deliberately chosen for AVR32_FT_UNKNOWN so that when the
++   machine_function structure is initialized (to zero) func_type will
++   default to unknown.  This will force the first use of avr32_current_func_type
++   to call avr32_compute_func_type.  */
++#define AVR32_FT_UNKNOWN       0      /* Type has not yet been determined.
++                                         */
++#define AVR32_FT_NORMAL                1      /* Your normal, straightforward
++                                         function.  */
++#define AVR32_FT_ACALL                 2      /* An acall function.  */
++#define AVR32_FT_EXCEPTION_HANDLER 3  /* A C++ exception handler.  */
++#define AVR32_FT_ISR_FULL      4      /* A fully shadowed interrupt mode.  */
++#define AVR32_FT_ISR_HALF      5      /* A half shadowed interrupt mode.  */
++#define AVR32_FT_ISR_NONE      6      /* No shadow registers.  */
++
++#define AVR32_FT_TYPE_MASK    ((1 << 3) - 1)
++
++/* In addition functions can have several type modifiers,
++   outlined by these bit masks:  */
++#define AVR32_FT_INTERRUPT    (1 << 2)        /* Note overlap with FT_ISR
++                                                 and above.  */
++#define AVR32_FT_NAKED                (1 << 3)        /* No prologue or epilogue.  */
++#define AVR32_FT_VOLATILE     (1 << 4)        /* Does not return.  */
++#define AVR32_FT_NESTED               (1 << 5)        /* Embedded inside another
++                                                 func. */
++
++/* Some macros to test these flags.  */
++#define AVR32_FUNC_TYPE(t)    (t & AVR32_FT_TYPE_MASK)
++#define IS_INTERRUPT(t)               (t & AVR32_FT_INTERRUPT)
++#define IS_VOLATILE(t)        (t & AVR32_FT_VOLATILE)
++#define IS_NAKED(t)           (t & AVR32_FT_NAKED)
++#define IS_NESTED(t)          (t & AVR32_FT_NESTED)
++
++
++typedef struct minipool_labels
++GTY ((chain_next ("%h.next"), chain_prev ("%h.prev")))
++{
++  rtx label;
++  struct minipool_labels *prev;
++  struct minipool_labels *next;
++} minipool_labels;
++
++/* A C structure for machine-specific, per-function data.
++   This is added to the cfun structure.  */
++
++typedef struct machine_function
++GTY (())
++{
++  /* Records the type of the current function.  */
++  unsigned long func_type;
++  /* List of minipool labels, use for checking if code label is valid in a
++     memory expression */
++  minipool_labels *minipool_label_head;
++  minipool_labels *minipool_label_tail;
++} machine_function;
++
++/* Initialize data used by insn expanders.  This is called from insn_emit,
++   once for every function before code is generated.  */
++#define INIT_EXPANDERS avr32_init_expanders ()
++
++/******************************************************************************
++ * SPECS
++ *****************************************************************************/
++
++#ifndef ASM_SPEC
++#define ASM_SPEC "%{fpic:--pic} %{mrelax|O*:%{mno-relax|O0|O1: ;:--linkrelax}} %{march=*:-march=%*} %{mpart=*:-mpart=%*}"
++#endif
++
++#ifndef MULTILIB_DEFAULTS
++#define MULTILIB_DEFAULTS { "march=ap" }
++#endif
++
++/******************************************************************************
++ * Run-time Target Specification
++ *****************************************************************************/
++#ifndef TARGET_VERSION
++#define TARGET_VERSION fprintf(stderr, " (AVR32, GNU assembler syntax)");
++#endif
++
++/* Part types. Keep this in sync with the order of avr32_part_types in avr32.c*/
++enum part_type
++{
++  PART_TYPE_AVR32_NONE,
++  PART_TYPE_AVR32_AP7000,
++  PART_TYPE_AVR32_AP7010,
++  PART_TYPE_AVR32_AP7020,
++  PART_TYPE_AVR32_UC3A0256,
++  PART_TYPE_AVR32_UC3A0512,
++  PART_TYPE_AVR32_UC3A1128,
++  PART_TYPE_AVR32_UC3A1256,
++  PART_TYPE_AVR32_UC3A1512
++};
++
++/* Microarchitectures. */
++enum microarchitecture_type
++{
++  UARCH_TYPE_AVR32A,
++  UARCH_TYPE_AVR32B
++};
++
++/* Architectures types which specifies the pipeline.
++ Keep this in sync with avr32_arch_types in avr32.c*/
++enum architecture_type
++{
++  ARCH_TYPE_AVR32_AP,
++  ARCH_TYPE_AVR32_UC
++};
++
++/* Flag specifying if the cpu has support for DSP instructions.*/
++#define FLAG_AVR32_HAS_DSP (1 << 0)
++/* Flag specifying if the cpu has support for Read-Modify-Write
++   instructions.*/
++#define FLAG_AVR32_HAS_RMW (1 << 1)
++/* Flag specifying if the cpu has support for SIMD instructions. */
++#define FLAG_AVR32_HAS_SIMD (1 << 2)
++/* Flag specifying if the cpu has support for unaligned memory word access. */
++#define FLAG_AVR32_HAS_UNALIGNED_WORD (1 << 3)
++/* Flag specifying if the cpu has support for branch prediction. */
++#define FLAG_AVR32_HAS_BRANCH_PRED (1 << 4)
++
++/* Structure for holding information about different avr32 CPUs/parts */
++struct part_type_s
++{
++  const char *const name;
++  enum part_type part_type;
++  enum architecture_type arch_type;
++  /* Must lie outside user's namespace.  NULL == no macro.  */
++  const char *const macro;
++};
++
++/* Structure for holding information about different avr32 pipeline
++ architectures. */
++struct arch_type_s
++{
++  const char *const name;
++  enum architecture_type arch_type;
++  enum microarchitecture_type uarch_type;
++  const unsigned long feature_flags;
++  /* Must lie outside user's namespace.  NULL == no macro.  */
++  const char *const macro;
++};
++
++extern const struct part_type_s *avr32_part;
++extern const struct arch_type_s *avr32_arch;
++
++#define TARGET_SIMD  (avr32_arch->feature_flags & FLAG_AVR32_HAS_SIMD)
++#define TARGET_DSP  (avr32_arch->feature_flags & FLAG_AVR32_HAS_DSP)
++#define TARGET_RMW  (avr32_arch->feature_flags & FLAG_AVR32_HAS_RMW)
++#define TARGET_UNALIGNED_WORD  (avr32_arch->feature_flags & FLAG_AVR32_HAS_UNALIGNED_WORD)
++#define TARGET_BRANCH_PRED  (avr32_arch->feature_flags & FLAG_AVR32_HAS_BRANCH_PRED)
++
++#define CAN_DEBUG_WITHOUT_FP
++
++/******************************************************************************
++ * Storage Layout
++ *****************************************************************************/
++
++/*
++Define this macro to have the value 1 if the most significant bit in a
++byte has the lowest number; otherwise define it to have the value zero.
++This means that bit-field instructions count from the most significant
++bit.  If the machine has no bit-field instructions, then this must still
++be defined, but it doesn't matter which value it is defined to.  This
++macro need not be a constant.
++
++This macro does not affect the way structure fields are packed into
++bytes or words; that is controlled by BYTES_BIG_ENDIAN.
++*/
++#define BITS_BIG_ENDIAN 0
++
++/*
++Define this macro to have the value 1 if the most significant byte in a
++word has the lowest number. This macro need not be a constant.
++*/
++/*
++  Data is stored in an big-endian way.
++*/
++#define BYTES_BIG_ENDIAN 1
++
++/*
++Define this macro to have the value 1 if, in a multiword object, the
++most significant word has the lowest number.  This applies to both
++memory locations and registers; GCC fundamentally assumes that the
++order of words in memory is the same as the order in registers.  This
++macro need not be a constant.
++*/
++/*
++  Data is stored in an bin-endian way.
++*/
++#define WORDS_BIG_ENDIAN 1
++
++/*
++Define this macro if WORDS_BIG_ENDIAN is not constant.  This must be a
++constant value with the same meaning as WORDS_BIG_ENDIAN, which will be
++used only when compiling libgcc2.c.  Typically the value will be set
++based on preprocessor defines.
++*/
++#define LIBGCC2_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN
++
++/*
++Define this macro to have the value 1 if DFmode, XFmode or
++TFmode floating point numbers are stored in memory with the word
++containing the sign bit at the lowest address; otherwise define it to
++have the value 0.  This macro need not be a constant.
++
++You need not define this macro if the ordering is the same as for
++multi-word integers.
++*/
++/* #define FLOAT_WORDS_BIG_ENDIAN 1 */
++
++/*
++Define this macro to be the number of bits in an addressable storage
++unit (byte); normally 8.
++*/
++#define BITS_PER_UNIT 8
++
++/*
++Number of bits in a word; normally 32.
++*/
++#define BITS_PER_WORD 32
++
++/*
++Maximum number of bits in a word.  If this is undefined, the default is
++BITS_PER_WORD.  Otherwise, it is the constant value that is the
++largest value that BITS_PER_WORD can have at run-time.
++*/
++/* MAX_BITS_PER_WORD not defined*/
++
++/*
++Number of storage units in a word; normally 4.
++*/
++#define UNITS_PER_WORD 4
++
++/*
++Minimum number of units in a word.  If this is undefined, the default is
++UNITS_PER_WORD.  Otherwise, it is the constant value that is the
++smallest value that UNITS_PER_WORD can have at run-time.
++*/
++/* MIN_UNITS_PER_WORD not defined */
++
++/*
++Width of a pointer, in bits.  You must specify a value no wider than the
++width of Pmode.  If it is not equal to the width of Pmode,
++you must define POINTERS_EXTEND_UNSIGNED.
++*/
++#define POINTER_SIZE 32
++
++/*
++A C expression whose value is greater than zero if pointers that need to be
++extended from being POINTER_SIZE bits wide to Pmode are to
++be zero-extended and zero if they are to be sign-extended.  If the value
++is less then zero then there must be an "ptr_extend" instruction that
++extends a pointer from POINTER_SIZE to Pmode.
++
++You need not define this macro if the POINTER_SIZE is equal
++to the width of Pmode.
++*/
++/* #define POINTERS_EXTEND_UNSIGNED */
++
++/*
++A Macro to update M and UNSIGNEDP when an object whose type
++is TYPE and which has the specified mode and signedness is to be
++stored in a register.  This macro is only called when TYPE is a
++scalar type.
++
++On most RISC machines, which only have operations that operate on a full
++register, define this macro to set M to word_mode if
++M is an integer mode narrower than BITS_PER_WORD.  In most
++cases, only integer modes should be widened because wider-precision
++floating-point operations are usually more expensive than their narrower
++counterparts.
++
++For most machines, the macro definition does not change UNSIGNEDP.
++However, some machines, have instructions that preferentially handle
++either signed or unsigned quantities of certain modes.  For example, on
++the DEC Alpha, 32-bit loads from memory and 32-bit add instructions
++sign-extend the result to 64 bits.  On such machines, set
++UNSIGNEDP according to which kind of extension is more efficient.
++
++Do not define this macro if it would never modify M.
++*/
++#define PROMOTE_MODE(M, UNSIGNEDP, TYPE)      \
++  do                                          \
++    {                                         \
++      if (GET_MODE_CLASS (M) == MODE_INT      \
++        && GET_MODE_SIZE (M) < 4)             \
++      {                                       \
++        (M) = SImode;                         \
++      }                                       \
++    }                                         \
++  while (0)
++
++/* Define if operations between registers always perform the operation
++   on the full register even if a narrower mode is specified.  */
++#define WORD_REGISTER_OPERATIONS
++
++/* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
++   will either zero-extend or sign-extend.  The value of this macro should
++   be the code that says which one of the two operations is implicitly
++   done, UNKNOWN if not known.  */
++#define LOAD_EXTEND_OP(MODE)                          \
++   (((MODE) == QImode) ? ZERO_EXTEND                  \
++   : ((MODE) == HImode) ? SIGN_EXTEND : UNKNOWN)
++
++
++/*
++Define this macro if the promotion described by PROMOTE_MODE
++should only be performed for outgoing function arguments or
++function return values, as specified by PROMOTE_FUNCTION_ARGS
++and PROMOTE_FUNCTION_RETURN, respectively.
++*/
++/* #define PROMOTE_FOR_CALL_ONLY */
++
++/*
++Normal alignment required for function parameters on the stack, in
++bits.  All stack parameters receive at least this much alignment
++regardless of data type.  On most machines, this is the same as the
++size of an integer.
++*/
++#define PARM_BOUNDARY 32
++
++/*
++Define this macro to the minimum alignment enforced by hardware for the
++stack pointer on this machine.  The definition is a C expression for the
++desired alignment (measured in bits).  This value is used as a default
++if PREFERRED_STACK_BOUNDARY is not defined.  On most machines,
++this should be the same as PARM_BOUNDARY.
++*/
++#define STACK_BOUNDARY 32
++
++/*
++Define this macro if you wish to preserve a certain alignment for the
++stack pointer, greater than what the hardware enforces.  The definition
++is a C expression for the desired alignment (measured in bits).  This
++macro must evaluate to a value equal to or larger than
++STACK_BOUNDARY.
++*/
++#define PREFERRED_STACK_BOUNDARY (TARGET_FORCE_DOUBLE_ALIGN ? 64 : 32 )
++
++/*
++Alignment required for a function entry point, in bits.
++*/
++#define FUNCTION_BOUNDARY 16
++
++/*
++Biggest alignment that any data type can require on this machine, in bits.
++*/
++#define BIGGEST_ALIGNMENT  (TARGET_FORCE_DOUBLE_ALIGN ? 64 : 32 )
++
++/*
++If defined, the smallest alignment, in bits, that can be given to an
++object that can be referenced in one operation, without disturbing any
++nearby object.  Normally, this is BITS_PER_UNIT, but may be larger
++on machines that don't have byte or half-word store operations.
++*/
++#define MINIMUM_ATOMIC_ALIGNMENT BITS_PER_UNIT
++
++
++/*
++An integer expression for the size in bits of the largest integer machine mode that
++should actually be used. All integer machine modes of this size or smaller can be
++used for structures and unions with the appropriate sizes. If this macro is undefined,
++GET_MODE_BITSIZE (DImode) is assumed.*/
++#define MAX_FIXED_MODE_SIZE  GET_MODE_BITSIZE (DImode)
++
++
++/*
++If defined, a C expression to compute the alignment given to a constant
++that is being placed in memory.  CONSTANT is the constant and
++BASIC_ALIGN is the alignment that the object would ordinarily
++have.  The value of this macro is used instead of that alignment to
++align the object.
++
++If this macro is not defined, then BASIC_ALIGN is used.
++
++The typical use of this macro is to increase alignment for string
++constants to be word aligned so that strcpy calls that copy
++constants can be done inline.
++*/
++#define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \
++ ((TREE_CODE(CONSTANT) == STRING_CST) ? BITS_PER_WORD : BASIC_ALIGN)
++
++/* Try to align string to a word. */
++#define DATA_ALIGNMENT(TYPE, ALIGN)                                     \
++  ({(TREE_CODE (TYPE) == ARRAY_TYPE                                     \
++     && TYPE_MODE (TREE_TYPE (TYPE)) == QImode                          \
++     && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN));})
++
++/* Try to align local store strings to a word. */
++#define LOCAL_ALIGNMENT(TYPE, ALIGN)                                    \
++  ({(TREE_CODE (TYPE) == ARRAY_TYPE                                     \
++     && TYPE_MODE (TREE_TYPE (TYPE)) == QImode                          \
++     && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN));})
++
++/*
++Define this macro to be the value 1 if instructions will fail to work
++if given data not on the nominal alignment.  If instructions will merely
++go slower in that case, define this macro as 0.
++*/
++#define STRICT_ALIGNMENT 1
++
++/*
++Define this if you wish to imitate the way many other C compilers handle
++alignment of bit-fields and the structures that contain them.
++
++The behavior is that the type written for a bit-field (int,
++short, or other integer type) imposes an alignment for the
++entire structure, as if the structure really did contain an ordinary
++field of that type.  In addition, the bit-field is placed within the
++structure so that it would fit within such a field, not crossing a
++boundary for it.
++
++Thus, on most machines, a bit-field whose type is written as int
++would not cross a four-byte boundary, and would force four-byte
++alignment for the whole structure.  (The alignment used may not be four
++bytes; it is controlled by the other alignment parameters.)
++
++If the macro is defined, its definition should be a C expression;
++a nonzero value for the expression enables this behavior.
++
++Note that if this macro is not defined, or its value is zero, some
++bit-fields may cross more than one alignment boundary.  The compiler can
++support such references if there are insv, extv, and
++extzv insns that can directly reference memory.
++
++The other known way of making bit-fields work is to define
++STRUCTURE_SIZE_BOUNDARY as large as BIGGEST_ALIGNMENT.
++Then every structure can be accessed with fullwords.
++
++Unless the machine has bit-field instructions or you define
++STRUCTURE_SIZE_BOUNDARY that way, you must define
++PCC_BITFIELD_TYPE_MATTERS to have a nonzero value.
++
++If your aim is to make GCC use the same conventions for laying out
++bit-fields as are used by another compiler, here is how to investigate
++what the other compiler does.  Compile and run this program:
++
++struct foo1
++{
++  char x;
++  char :0;
++  char y;
++};
++
++struct foo2
++{
++  char x;
++  int :0;
++  char y;
++};
++
++main ()
++{
++  printf ("Size of foo1 is %d\n",
++          sizeof (struct foo1));
++  printf ("Size of foo2 is %d\n",
++          sizeof (struct foo2));
++  exit (0);
++}
++
++If this prints 2 and 5, then the compiler's behavior is what you would
++get from PCC_BITFIELD_TYPE_MATTERS.
++*/
++#define PCC_BITFIELD_TYPE_MATTERS 1
++
++
++/******************************************************************************
++ * Layout of Source Language Data Types
++ *****************************************************************************/
++
++/*
++A C expression for the size in bits of the type int on the
++target machine.  If you don't define this, the default is one word.
++*/
++#define INT_TYPE_SIZE 32
++
++/*
++A C expression for the size in bits of the type short on the
++target machine.  If you don't define this, the default is half a word. (If
++this would be less than one storage unit, it is rounded up to one unit.)
++*/
++#define SHORT_TYPE_SIZE 16
++
++/*
++A C expression for the size in bits of the type long on the
++target machine.  If you don't define this, the default is one word.
++*/
++#define LONG_TYPE_SIZE 32
++
++
++/*
++A C expression for the size in bits of the type long long on the
++target machine.  If you don't define this, the default is two
++words.  If you want to support GNU Ada on your machine, the value of this
++macro must be at least 64.
++*/
++#define LONG_LONG_TYPE_SIZE 64
++
++/*
++A C expression for the size in bits of the type char on the
++target machine.  If you don't define this, the default is
++BITS_PER_UNIT.
++*/
++#define CHAR_TYPE_SIZE 8
++
++
++/*
++A C expression for the size in bits of the C++ type bool and
++C99 type _Bool on the target machine.  If you don't define
++this, and you probably shouldn't, the default is CHAR_TYPE_SIZE.
++*/
++#define BOOL_TYPE_SIZE 8
++
++
++/*
++An expression whose value is 1 or 0, according to whether the type
++char should be signed or unsigned by default.  The user can
++always override this default with the options -fsigned-char
++and -funsigned-char.
++*/
++/* We are using unsigned char */
++#define DEFAULT_SIGNED_CHAR 0
++
++
++/*
++A C expression for a string describing the name of the data type to use
++for size values.  The typedef name size_t is defined using the
++contents of the string.
++
++The string can contain more than one keyword.  If so, separate them with
++spaces, and write first any length keyword, then unsigned if
++appropriate, and finally int.  The string must exactly match one
++of the data type names defined in the function
++init_decl_processing in the file c-decl.c.  You may not
++omit int or change the order - that would cause the compiler to
++crash on startup.
++
++If you don't define this macro, the default is "long unsigned int".
++*/
++#define SIZE_TYPE "long unsigned int"
++
++/*
++A C expression for a string describing the name of the data type to use
++for the result of subtracting two pointers.  The typedef name
++ptrdiff_t is defined using the contents of the string.  See
++SIZE_TYPE above for more information.
++
++If you don't define this macro, the default is "long int".
++*/
++#define PTRDIFF_TYPE "long int"
++
++
++/*
++A C expression for the size in bits of the data type for wide
++characters.  This is used in cpp, which cannot make use of
++WCHAR_TYPE.
++*/
++#define WCHAR_TYPE_SIZE 32
++
++
++/*
++A C expression for a string describing the name of the data type to
++use for wide characters passed to printf and returned from
++getwc.  The typedef name wint_t is defined using the
++contents of the string.  See SIZE_TYPE above for more
++information.
++
++If you don't define this macro, the default is "unsigned int".
++*/
++#define WINT_TYPE "unsigned int"
++
++/*
++A C expression for a string describing the name of the data type that
++can represent any value of any standard or extended signed integer type.
++The typedef name intmax_t is defined using the contents of the
++string.  See SIZE_TYPE above for more information.
++
++If you don't define this macro, the default is the first of
++"int", "long int", or "long long int" that has as
++much precision as long long int.
++*/
++#define INTMAX_TYPE "long long int"
++
++/*
++A C expression for a string describing the name of the data type that
++can represent any value of any standard or extended unsigned integer
++type.  The typedef name uintmax_t is defined using the contents
++of the string.  See SIZE_TYPE above for more information.
++
++If you don't define this macro, the default is the first of
++"unsigned int", "long unsigned int", or "long long unsigned int"
++that has as much precision as long long unsigned int.
++*/
++#define UINTMAX_TYPE "long long unsigned int"
++
++
++/******************************************************************************
++ * Register Usage
++ *****************************************************************************/
++
++/* Convert from gcc internal register number to register number
++   used in assembly code */
++#define ASM_REGNUM(reg) (LAST_REGNUM - (reg))
++#define ASM_FP_REGNUM(reg) (LAST_FP_REGNUM - (reg))
++
++/* Convert between register number used in assembly to gcc
++   internal register number  */
++#define INTERNAL_REGNUM(reg) (LAST_REGNUM - (reg))
++#define INTERNAL_FP_REGNUM(reg) (LAST_FP_REGNUM - (reg))
++
++/** Basic Characteristics of Registers **/
++
++/*
++Number of hardware registers known to the compiler.  They receive
++numbers 0 through FIRST_PSEUDO_REGISTER-1; thus, the first
++pseudo register's number really is assigned the number
++FIRST_PSEUDO_REGISTER.
++*/
++#define FIRST_PSEUDO_REGISTER (LAST_FP_REGNUM + 1)
++
++#define FIRST_REGNUM 0
++#define LAST_REGNUM 15
++#define NUM_FP_REGS 16
++#define FIRST_FP_REGNUM 16
++#define LAST_FP_REGNUM (16+NUM_FP_REGS-1)
++
++/*
++An initializer that says which registers are used for fixed purposes
++all throughout the compiled code and are therefore not available for
++general allocation.  These would include the stack pointer, the frame
++pointer (except on machines where that can be used as a general
++register when no frame pointer is needed), the program counter on
++machines where that is considered one of the addressable registers,
++and any other numbered register with a standard use.
++
++This information is expressed as a sequence of numbers, separated by
++commas and surrounded by braces.  The nth number is 1 if
++register n is fixed, 0 otherwise.
++
++The table initialized from this macro, and the table initialized by
++the following one, may be overridden at run time either automatically,
++by the actions of the macro CONDITIONAL_REGISTER_USAGE, or by
++the user with the command options -ffixed-[reg],
++-fcall-used-[reg] and -fcall-saved-[reg].
++*/
++
++/* The internal gcc register numbers are reversed
++   compared to the real register numbers since
++   gcc expects data types stored over multiple
++   registers in the register file to be big endian
++   if the memory layout is big endian. But this
++   is not the case for avr32 so we fake a big
++   endian register file. */
++
++#define FIXED_REGISTERS {     \
++  1, /* Program Counter */    \
++  0, /* Link Register */      \
++  1, /* Stack Pointer */      \
++  0, /* r12 */                        \
++  0, /* r11 */                        \
++  0, /* r10 */                        \
++  0, /* r9 */                 \
++  0, /* r8 */                 \
++  0, /* r7 */                 \
++  0, /* r6 */                 \
++  0, /* r5 */                 \
++  0, /* r4 */                 \
++  0, /* r3 */                 \
++  0, /* r2 */                 \
++  0, /* r1 */                 \
++  0, /* r0 */                 \
++  0, /* f15 */                        \
++  0, /* f14 */                        \
++  0, /* f13 */                        \
++  0, /* f12 */                        \
++  0, /* f11 */                        \
++  0, /* f10 */                        \
++  0, /* f9 */                 \
++  0, /* f8 */                 \
++  0, /* f7 */                 \
++  0, /* f6 */                 \
++  0, /* f5 */                 \
++  0, /* f4 */                 \
++  0, /* f3 */                 \
++  0, /* f2*/                  \
++  0, /* f1 */                 \
++  0  /* f0 */                 \
++}
++
++/*
++Like FIXED_REGISTERS but has 1 for each register that is
++clobbered (in general) by function calls as well as for fixed
++registers.  This macro therefore identifies the registers that are not
++available for general allocation of values that must live across
++function calls.
++
++If a register has 0 in CALL_USED_REGISTERS, the compiler
++automatically saves it on function entry and restores it on function
++exit, if the register is used within the function.
++*/
++#define CALL_USED_REGISTERS { \
++  1, /* Program Counter */    \
++  0, /* Link Register */      \
++  1, /* Stack Pointer */      \
++  1, /* r12 */                        \
++  1, /* r11 */                        \
++  1, /* r10 */                        \
++  1, /* r9 */                 \
++  1, /* r8 */                 \
++  0, /* r7 */                 \
++  0, /* r6 */                 \
++  0, /* r5 */                 \
++  0, /* r4 */                 \
++  0, /* r3 */                 \
++  0, /* r2 */                 \
++  0, /* r1 */                 \
++  0, /* r0 */                 \
++  1, /* f15 */                        \
++  1, /* f14 */                        \
++  1, /* f13 */                        \
++  1, /* f12 */                        \
++  1, /* f11 */                        \
++  1, /* f10 */                        \
++  1, /* f9 */                 \
++  1, /* f8 */                 \
++  0, /* f7 */                 \
++  0, /* f6 */                 \
++  0, /* f5 */                 \
++  0, /* f4 */                 \
++  0, /* f3 */                 \
++  0, /* f2*/                  \
++  0, /* f1*/                  \
++  0, /* f0 */                 \
++}
++
++/* Interrupt functions can only use registers that have already been
++   saved by the prologue, even if they would normally be
++   call-clobbered.  */
++#define HARD_REGNO_RENAME_OK(SRC, DST)                                        \
++      (! IS_INTERRUPT (cfun->machine->func_type) ||                   \
++              regs_ever_live[DST])
++
++
++/*
++Zero or more C statements that may conditionally modify five variables
++fixed_regs, call_used_regs, global_regs,
++reg_names, and reg_class_contents, to take into account
++any dependence of these register sets on target flags.  The first three
++of these are of type char [] (interpreted as Boolean vectors).
++global_regs is a const char *[], and
++reg_class_contents is a HARD_REG_SET.  Before the macro is
++called, fixed_regs, call_used_regs,
++reg_class_contents, and reg_names have been initialized
++from FIXED_REGISTERS, CALL_USED_REGISTERS,
++REG_CLASS_CONTENTS, and REGISTER_NAMES, respectively.
++global_regs has been cleared, and any -ffixed-[reg],
++-fcall-used-[reg] and -fcall-saved-[reg]
++command options have been applied.
++
++You need not define this macro if it has no work to do.
++
++If the usage of an entire class of registers depends on the target
++flags, you may indicate this to GCC by using this macro to modify
++fixed_regs and call_used_regs to 1 for each of the
++registers in the classes which should not be used by GCC.  Also define
++the macro REG_CLASS_FROM_LETTER to return NO_REGS if it
++is called with a letter for a class that shouldn't be used.
++
++ (However, if this class is not included in GENERAL_REGS and all
++of the insn patterns whose constraints permit this class are
++controlled by target switches, then GCC will automatically avoid using
++these registers when the target switches are opposed to them.)
++*/
++#define CONDITIONAL_REGISTER_USAGE                              \
++  do                                                          \
++    {                                                         \
++      int regno;                                              \
++                                                              \
++      if (TARGET_SOFT_FLOAT)                                  \
++      {                                                       \
++        for (regno = FIRST_FP_REGNUM;                         \
++             regno <= LAST_FP_REGNUM; ++regno)                \
++          fixed_regs[regno] = call_used_regs[regno] = 1;      \
++      }                                                       \
++      if (flag_pic)                                           \
++      {                                                       \
++        fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;              \
++        call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;          \
++      }                                                       \
++    }                                                         \
++  while (0)
++
++
++/*
++If the program counter has a register number, define this as that
++register number.  Otherwise, do not define it.
++*/
++
++#define LAST_AVR32_REGNUM 16
++
++
++/** Order of Allocation of Registers **/
++
++/*
++If defined, an initializer for a vector of integers, containing the
++numbers of hard registers in the order in which GCC should prefer
++to use them (from most preferred to least).
++
++If this macro is not defined, registers are used lowest numbered first
++(all else being equal).
++
++One use of this macro is on machines where the highest numbered
++registers must always be saved and the save-multiple-registers
++instruction supports only sequences of consecutive registers.  On such
++machines, define REG_ALLOC_ORDER to be an initializer that lists
++the highest numbered allocable register first.
++*/
++#define REG_ALLOC_ORDER       \
++{                             \
++  INTERNAL_REGNUM(8),         \
++  INTERNAL_REGNUM(9),         \
++  INTERNAL_REGNUM(10),                \
++  INTERNAL_REGNUM(11),                \
++  INTERNAL_REGNUM(12),                \
++  LR_REGNUM,                  \
++  INTERNAL_REGNUM(7),         \
++  INTERNAL_REGNUM(6),         \
++  INTERNAL_REGNUM(5),         \
++  INTERNAL_REGNUM(4),         \
++  INTERNAL_REGNUM(3),         \
++  INTERNAL_REGNUM(2),         \
++  INTERNAL_REGNUM(1),         \
++  INTERNAL_REGNUM(0),         \
++  INTERNAL_FP_REGNUM(15),     \
++  INTERNAL_FP_REGNUM(14),     \
++  INTERNAL_FP_REGNUM(13),     \
++  INTERNAL_FP_REGNUM(12),     \
++  INTERNAL_FP_REGNUM(11),     \
++  INTERNAL_FP_REGNUM(10),     \
++  INTERNAL_FP_REGNUM(9),      \
++  INTERNAL_FP_REGNUM(8),      \
++  INTERNAL_FP_REGNUM(7),      \
++  INTERNAL_FP_REGNUM(6),      \
++  INTERNAL_FP_REGNUM(5),      \
++  INTERNAL_FP_REGNUM(4),      \
++  INTERNAL_FP_REGNUM(3),      \
++  INTERNAL_FP_REGNUM(2),      \
++  INTERNAL_FP_REGNUM(1),      \
++  INTERNAL_FP_REGNUM(0),      \
++  SP_REGNUM,                          \
++  PC_REGNUM                   \
++}
++
++
++/** How Values Fit in Registers **/
++
++/*
++A C expression for the number of consecutive hard registers, starting
++at register number REGNO, required to hold a value of mode
++MODE.
++
++On a machine where all registers are exactly one word, a suitable
++definition of this macro is
++
++#define HARD_REGNO_NREGS(REGNO, MODE)            \
++   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1)  \
++    / UNITS_PER_WORD)
++*/
++#define HARD_REGNO_NREGS(REGNO, MODE) \
++  ((unsigned int)((GET_MODE_SIZE(MODE) + UNITS_PER_WORD -1 ) / UNITS_PER_WORD))
++
++/*
++A C expression that is nonzero if it is permissible to store a value
++of mode MODE in hard register number REGNO (or in several
++registers starting with that one).  For a machine where all registers
++are equivalent, a suitable definition is
++
++  #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
++
++You need not include code to check for the numbers of fixed registers,
++because the allocation mechanism considers them to be always occupied.
++
++On some machines, double-precision values must be kept in even/odd
++register pairs.  You can implement that by defining this macro to reject
++odd register numbers for such modes.
++
++The minimum requirement for a mode to be OK in a register is that the
++mov[mode] instruction pattern support moves between the
++register and other hard register in the same class and that moving a
++value into the register and back out not alter it.
++
++Since the same instruction used to move word_mode will work for
++all narrower integer modes, it is not necessary on any machine for
++HARD_REGNO_MODE_OK to distinguish between these modes, provided
++you define patterns movhi, etc., to take advantage of this.  This
++is useful because of the interaction between HARD_REGNO_MODE_OK
++and MODES_TIEABLE_P; it is very desirable for all integer modes
++to be tieable.
++
++Many machines have special registers for floating point arithmetic.
++Often people assume that floating point machine modes are allowed only
++in floating point registers.  This is not true.  Any registers that
++can hold integers can safely hold a floating point machine
++mode, whether or not floating arithmetic can be done on it in those
++registers.  Integer move instructions can be used to move the values.
++
++On some machines, though, the converse is true: fixed-point machine
++modes may not go in floating registers.  This is true if the floating
++registers normalize any value stored in them, because storing a
++non-floating value there would garble it.  In this case,
++HARD_REGNO_MODE_OK should reject fixed-point machine modes in
++floating registers.  But if the floating registers do not automatically
++normalize, if you can store any bit pattern in one and retrieve it
++unchanged without a trap, then any machine mode may go in a floating
++register, so you can define this macro to say so.
++
++The primary significance of special floating registers is rather that
++they are the registers acceptable in floating point arithmetic
++instructions.  However, this is of no concern to
++HARD_REGNO_MODE_OK.  You handle it by writing the proper
++constraints for those instructions.
++
++On some machines, the floating registers are especially slow to access,
++so that it is better to store a value in a stack frame than in such a
++register if floating point arithmetic is not being done.  As long as the
++floating registers are not in class GENERAL_REGS, they will not
++be used unless some pattern's constraint asks for one.
++*/
++#define HARD_REGNO_MODE_OK(REGNO, MODE) avr32_hard_regno_mode_ok(REGNO, MODE)
++
++/*
++A C expression that is nonzero if a value of mode
++MODE1 is accessible in mode MODE2 without copying.
++
++If HARD_REGNO_MODE_OK(R, MODE1) and
++HARD_REGNO_MODE_OK(R, MODE2) are always the same for
++any R, then MODES_TIEABLE_P(MODE1, MODE2)
++should be nonzero.  If they differ for any R, you should define
++this macro to return zero unless some other mechanism ensures the
++accessibility of the value in a narrower mode.
++
++You should define this macro to return nonzero in as many cases as
++possible since doing so will allow GCC to perform better register
++allocation.
++*/
++#define MODES_TIEABLE_P(MODE1, MODE2)  \
++  (GET_MODE_CLASS (MODE1) == GET_MODE_CLASS (MODE2))
++
++
++
++/******************************************************************************
++ * Register Classes
++ *****************************************************************************/
++
++/*
++An enumeral type that must be defined with all the register class names
++as enumeral values.  NO_REGS must be first.  ALL_REGS
++must be the last register class, followed by one more enumeral value,
++LIM_REG_CLASSES, which is not a register class but rather
++tells how many classes there are.
++
++Each register class has a number, which is the value of casting
++the class name to type int.  The number serves as an index
++in many of the tables described below.
++*/
++enum reg_class
++{
++  NO_REGS,
++  GENERAL_REGS,
++  FP_REGS,
++  ALL_REGS,
++  LIM_REG_CLASSES
++};
++
++/*
++The number of distinct register classes, defined as follows:
++  #define N_REG_CLASSES (int) LIM_REG_CLASSES
++*/
++#define N_REG_CLASSES (int)LIM_REG_CLASSES
++
++/*
++An initializer containing the names of the register classes as C string
++constants.  These names are used in writing some of the debugging dumps.
++*/
++#define REG_CLASS_NAMES               \
++{                             \
++  "NO_REGS",                  \
++  "GENERAL_REGS",             \
++  "FLOATING_POINT_REGS",      \
++  "ALL_REGS"                  \
++}
++
++/*
++An initializer containing the contents of the register classes, as integers
++which are bit masks.  The nth integer specifies the contents of class
++n.  The way the integer mask is interpreted is that
++register r is in the class if mask & (1 << r) is 1.
++
++When the machine has more than 32 registers, an integer does not suffice.
++Then the integers are replaced by sub-initializers, braced groupings containing
++several integers.  Each sub-initializer must be suitable as an initializer
++for the type HARD_REG_SET which is defined in hard-reg-set.h.
++In this situation, the first integer in each sub-initializer corresponds to
++registers 0 through 31, the second integer to registers 32 through 63, and
++so on.
++*/
++#define REG_CLASS_CONTENTS {          \
++  {0x00000000}, /* NO_REGS */         \
++  {0x0000FFFF}, /* GENERAL_REGS */    \
++  {0xFFFF0000}, /* FP_REGS */         \
++  {0x7FFFFFFF}, /* ALL_REGS */                \
++}
++
++
++/*
++A C expression whose value is a register class containing hard register
++REGNO.  In general there is more than one such class; choose a class
++which is minimal, meaning that no smaller class also contains the
++register.
++*/
++#define REGNO_REG_CLASS(REGNO) ((REGNO < 16) ? GENERAL_REGS : FP_REGS)
++
++/*
++A macro whose definition is the name of the class to which a valid
++base register must belong.  A base register is one used in an address
++which is the register value plus a displacement.
++*/
++#define BASE_REG_CLASS GENERAL_REGS
++
++/*
++This is a variation of the BASE_REG_CLASS macro which allows
++the selection of a base register in a mode depenedent manner.  If
++mode is VOIDmode then it should return the same value as
++BASE_REG_CLASS.
++*/
++#define MODE_BASE_REG_CLASS(MODE) BASE_REG_CLASS
++
++/*
++A macro whose definition is the name of the class to which a valid
++index register must belong.  An index register is one used in an
++address where its value is either multiplied by a scale factor or
++added to another register (as well as added to a displacement).
++*/
++#define INDEX_REG_CLASS BASE_REG_CLASS
++
++/*
++A C expression which defines the machine-dependent operand constraint
++letters for register classes.  If CHAR is such a letter, the
++value should be the register class corresponding to it.  Otherwise,
++the value should be NO_REGS.  The register letter r,
++corresponding to class GENERAL_REGS, will not be passed
++to this macro; you do not need to handle it.
++*/
++#define REG_CLASS_FROM_LETTER(CHAR) ((CHAR) == 'f' ? FP_REGS : NO_REGS)
++
++
++/* These assume that REGNO is a hard or pseudo reg number.
++   They give nonzero only if REGNO is a hard reg of the suitable class
++   or a pseudo reg currently allocated to a suitable hard reg.
++   Since they use reg_renumber, they are safe only once reg_renumber
++   has been allocated, which happens in local-alloc.c.  */
++#define TEST_REGNO(R, TEST, VALUE) \
++  ((R TEST VALUE) || ((unsigned) reg_renumber[R] TEST VALUE))
++
++/*
++A C expression which is nonzero if register number num is suitable for use as a base
++register in operand addresses. It may be either a suitable hard register or a pseudo
++register that has been allocated such a hard register.
++*/
++#define REGNO_OK_FOR_BASE_P(NUM)  TEST_REGNO(NUM, <=, LAST_REGNUM)
++
++/*
++A C expression which is nonzero if register number NUM is
++suitable for use as an index register in operand addresses.  It may be
++either a suitable hard register or a pseudo register that has been
++allocated such a hard register.
++
++The difference between an index register and a base register is that
++the index register may be scaled.  If an address involves the sum of
++two registers, neither one of them scaled, then either one may be
++labeled the ``base'' and the other the ``index''; but whichever
++labeling is used must fit the machine's constraints of which registers
++may serve in each capacity.  The compiler will try both labelings,
++looking for one that is valid, and will reload one or both registers
++only if neither labeling works.
++*/
++#define REGNO_OK_FOR_INDEX_P(NUM) TEST_REGNO(NUM, <=, LAST_REGNUM)
++
++/*
++A C expression that places additional restrictions on the register class
++to use when it is necessary to copy value X into a register in class
++CLASS.  The value is a register class; perhaps CLASS, or perhaps
++another, smaller class.  On many machines, the following definition is
++safe: #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
++
++Sometimes returning a more restrictive class makes better code.  For
++example, on the 68000, when X is an integer constant that is in range
++for a 'moveq' instruction, the value of this macro is always
++DATA_REGS as long as CLASS includes the data registers.
++Requiring a data register guarantees that a 'moveq' will be used.
++
++If X is a const_double, by returning NO_REGS
++you can force X into a memory constant.  This is useful on
++certain machines where immediate floating values cannot be loaded into
++certain kinds of registers.
++*/
++#define PREFERRED_RELOAD_CLASS(X, CLASS)  CLASS
++
++
++
++/*
++A C expression for the maximum number of consecutive registers
++of class CLASS needed to hold a value of mode MODE.
++
++This is closely related to the macro HARD_REGNO_NREGS.  In fact,
++the value of the macro CLASS_MAX_NREGS(CLASS, MODE)
++should be the maximum value of HARD_REGNO_NREGS(REGNO, MODE)
++for all REGNO values in the class CLASS.
++
++This macro helps control the handling of multiple-word values
++in the reload pass.
++*/
++#define CLASS_MAX_NREGS(CLASS, MODE) /* ToDo:fixme */ \
++  (unsigned int)((GET_MODE_SIZE(MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
++
++
++/*
++  Using CONST_OK_FOR_CONSTRAINT_P instead of CONS_OK_FOR_LETTER_P
++  in order to support constraints with more than one letter.
++  Only two letters are then used for constant constraints,
++  the letter 'K' and the letter 'I'. The constraint starting with
++  these letters must consist of four characters. The character following
++  'K' or 'I' must be either 'u' (unsigned) or 's' (signed) to specify
++  if the constant is zero or sign extended. The last two characters specify
++  the length in bits of the constant. The base constraint letter 'I' means
++  that this is an negated constant, meaning that actually -VAL should be
++  checked to lie withing the valid range instead of VAL which is used when
++  'K' is the base constraint letter.
++
++*/
++
++#define CONSTRAINT_LEN(C, STR)                                \
++  ( ((C) == 'K' || (C) == 'I') ?  4 :                 \
++    ((C) == 'R') ?  5 :                                       \
++    ((C) == 'N' || (C) == 'O' ||                      \
++     (C) == 'P' || (C) == 'L' || (C) == 'J') ? -1 :   \
++    DEFAULT_CONSTRAINT_LEN((C), (STR)) )
++
++#define CONST_OK_FOR_CONSTRAINT_P(VALUE, C, STR)      \
++  avr32_const_ok_for_constraint_p(VALUE, C, STR)
++
++/*
++A C expression that defines the machine-dependent operand constraint
++letters that specify particular ranges of const_double values ('G' or 'H').
++
++If C is one of those letters, the expression should check that
++VALUE, an RTX of code const_double, is in the appropriate
++range and return 1 if so, 0 otherwise.  If C is not one of those
++letters, the value should be 0 regardless of VALUE.
++
++const_double is used for all floating-point constants and for
++DImode fixed-point constants.  A given letter can accept either
++or both kinds of values.  It can use GET_MODE to distinguish
++between these kinds.
++*/
++#define CONST_DOUBLE_OK_FOR_LETTER_P(OP, C) \
++  ((C) == 'G' ? avr32_const_double_immediate(OP) : 0)
++
++/*
++A C expression that defines the optional machine-dependent constraint
++letters that can be used to segregate specific types of operands, usually
++memory references, for the target machine.  Any letter that is not
++elsewhere defined and not matched by REG_CLASS_FROM_LETTER
++may be used.  Normally this macro will not be defined.
++
++If it is required for a particular target machine, it should return 1
++if VALUE corresponds to the operand type represented by the
++constraint letter C.  If C is not defined as an extra
++constraint, the value returned should be 0 regardless of VALUE.
++
++For example, on the ROMP, load instructions cannot have their output
++in r0 if the memory reference contains a symbolic address.  Constraint
++letter 'Q' is defined as representing a memory address that does
++not contain a symbolic address.  An alternative is specified with
++a 'Q' constraint on the input and 'r' on the output.  The next
++alternative specifies 'm' on the input and a register class that
++does not include r0 on the output.
++*/
++#define EXTRA_CONSTRAINT_STR(OP, C, STR)                              \
++  ((C) == 'W' ? avr32_address_operand(OP, GET_MODE(OP)) :             \
++   (C) == 'R' ? (avr32_indirect_register_operand(OP, GET_MODE(OP)) || \
++                 (avr32_imm_disp_memory_operand(OP, GET_MODE(OP))     \
++                  && avr32_const_ok_for_constraint_p(                 \
++                              INTVAL(XEXP(XEXP(OP, 0), 1)),           \
++                              (STR)[1], &(STR)[1]))) :                \
++   (C) == 'S' ? avr32_indexed_memory_operand(OP, GET_MODE(OP)) :      \
++   (C) == 'T' ? avr32_const_pool_ref_operand(OP, GET_MODE(OP)) :      \
++   (C) == 'U' ? SYMBOL_REF_RCALL_FUNCTION_P(OP) :                     \
++   (C) == 'Z' ? avr32_cop_memory_operand(OP, GET_MODE(OP)) :          \
++   0)
++
++
++#define EXTRA_MEMORY_CONSTRAINT(C, STR) ( ((C) == 'R') ||               \
++                                          ((C) == 'S') ||               \
++                                          ((C) == 'Z') )
++
++
++/* Returns nonzero if op is a function SYMBOL_REF which
++   can be called using an rcall instruction */
++#define SYMBOL_REF_RCALL_FUNCTION_P(op)  \
++  ( GET_CODE(op) == SYMBOL_REF           \
++    && SYMBOL_REF_FUNCTION_P(op)         \
++    && SYMBOL_REF_LOCAL_P(op)            \
++    && !SYMBOL_REF_EXTERNAL_P(op)        \
++    && !TARGET_HAS_ASM_ADDR_PSEUDOS )
++
++/******************************************************************************
++ * Stack Layout and Calling Conventions
++ *****************************************************************************/
++
++/** Basic Stack Layout **/
++
++/*
++Define this macro if pushing a word onto the stack moves the stack
++pointer to a smaller address.
++
++When we say, ``define this macro if ...,'' it means that the
++compiler checks this macro only with #ifdef so the precise
++definition used does not matter.
++*/
++/* pushm decrece SP: *(--SP) <-- Rx */
++#define STACK_GROWS_DOWNWARD
++
++/*
++This macro defines the operation used when something is pushed
++on the stack.  In RTL, a push operation will be
++(set (mem (STACK_PUSH_CODE (reg sp))) ...)
++
++The choices are PRE_DEC, POST_DEC, PRE_INC,
++and POST_INC.  Which of these is correct depends on
++the stack direction and on whether the stack pointer points
++to the last item on the stack or whether it points to the
++space for the next item on the stack.
++
++The default is PRE_DEC when STACK_GROWS_DOWNWARD is
++defined, which is almost always right, and PRE_INC otherwise,
++which is often wrong.
++*/
++/* pushm: *(--SP) <-- Rx */
++#define STACK_PUSH_CODE PRE_DEC
++
++/* Define this to nonzero if the nominal address of the stack frame
++   is at the high-address end of the local variables;
++   that is, each additional local variable allocated
++   goes at a more negative offset in the frame.  */
++#define FRAME_GROWS_DOWNWARD 1
++
++
++/*
++Offset from the frame pointer to the first local variable slot to be allocated.
++
++If FRAME_GROWS_DOWNWARD, find the next slot's offset by
++subtracting the first slot's length from STARTING_FRAME_OFFSET.
++Otherwise, it is found by adding the length of the first slot to the
++value STARTING_FRAME_OFFSET.
++  (i'm not sure if the above is still correct.. had to change it to get
++   rid of an overfull.  --mew 2feb93 )
++*/
++#define STARTING_FRAME_OFFSET 0
++
++/*
++Offset from the stack pointer register to the first location at which
++outgoing arguments are placed.  If not specified, the default value of
++zero is used.  This is the proper value for most machines.
++
++If ARGS_GROW_DOWNWARD, this is the offset to the location above
++the first location at which outgoing arguments are placed.
++*/
++#define STACK_POINTER_OFFSET 0
++
++/*
++Offset from the argument pointer register to the first argument's
++address.  On some machines it may depend on the data type of the
++function.
++
++If ARGS_GROW_DOWNWARD, this is the offset to the location above
++the first argument's address.
++*/
++#define FIRST_PARM_OFFSET(FUNDECL) 0
++
++
++/*
++A C expression whose value is RTL representing the address in a stack
++frame where the pointer to the caller's frame is stored.  Assume that
++FRAMEADDR is an RTL expression for the address of the stack frame
++itself.
++
++If you don't define this macro, the default is to return the value
++of FRAMEADDR - that is, the stack frame address is also the
++address of the stack word that points to the previous frame.
++*/
++#define DYNAMIC_CHAIN_ADDRESS(FRAMEADDR) plus_constant ((FRAMEADDR), 4)
++
++
++/*
++A C expression whose value is RTL representing the value of the return
++address for the frame COUNT steps up from the current frame, after
++the prologue.  FRAMEADDR is the frame pointer of the COUNT
++frame, or the frame pointer of the COUNT - 1 frame if
++RETURN_ADDR_IN_PREVIOUS_FRAME is defined.
++
++The value of the expression must always be the correct address when
++COUNT is zero, but may be NULL_RTX if there is not way to
++determine the return address of other frames.
++*/
++#define RETURN_ADDR_RTX(COUNT, FRAMEADDR) avr32_return_addr(COUNT, FRAMEADDR)
++
++
++/*
++A C expression whose value is RTL representing the location of the
++incoming return address at the beginning of any function, before the
++prologue.  This RTL is either a REG, indicating that the return
++value is saved in 'REG', or a MEM representing a location in
++the stack.
++
++You only need to define this macro if you want to support call frame
++debugging information like that provided by DWARF 2.
++
++If this RTL is a REG, you should also define
++DWARF_FRAME_RETURN_COLUMN to DWARF_FRAME_REGNUM (REGNO).
++*/
++#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, LR_REGNUM)
++
++
++
++/*
++A C expression whose value is an integer giving the offset, in bytes,
++from the value of the stack pointer register to the top of the stack
++frame at the beginning of any function, before the prologue.  The top of
++the frame is defined to be the value of the stack pointer in the
++previous frame, just before the call instruction.
++
++You only need to define this macro if you want to support call frame
++debugging information like that provided by DWARF 2.
++*/
++#define INCOMING_FRAME_SP_OFFSET 0
++
++
++/** Exception Handling Support **/
++
++#define DWARF2_UNWIND_INFO 1
++
++/*
++A C expression whose value is the Nth register number used for
++data by exception handlers, or INVALID_REGNUM if fewer than
++N registers are usable.
++
++The exception handling library routines communicate with the exception
++handlers via a set of agreed upon registers.  Ideally these registers
++should be call-clobbered; it is possible to use call-saved registers,
++but may negatively impact code size.  The target must support at least
++2 data registers, but should define 4 if there are enough free registers.
++
++You must define this macro if you want to support call frame exception
++handling like that provided by DWARF 2.
++*/
++/*
++  Use r8-r11
++*/
++#define EH_RETURN_DATA_REGNO(N)                                       \
++  ((N) < 4 ? INTERNAL_REGNUM((N) + 8U) : INVALID_REGNUM)
++
++/*
++A C expression whose value is RTL representing a location in which
++to store a stack adjustment to be applied before function return.
++This is used to unwind the stack to an exception handler's call frame.
++It will be assigned zero on code paths that return normally.
++
++Typically this is a call-clobbered hard register that is otherwise
++untouched by the epilogue, but could also be a stack slot.
++
++You must define this macro if you want to support call frame exception
++handling like that provided by DWARF 2.
++*/
++/*
++  I don't think functions that may throw exceptions can ever be leaf
++  functions, so we may safely use LR for this.
++*/
++#define EH_RETURN_STACKADJ_REGNO LR_REGNUM
++#define EH_RETURN_STACKADJ_RTX gen_rtx_REG(SImode, EH_RETURN_STACKADJ_REGNO)
++
++/*
++A C expression whose value is RTL representing a location in which
++to store the address of an exception handler to which we should
++return.  It will not be assigned on code paths that return normally.
++
++Typically this is the location in the call frame at which the normal
++return address is stored.  For targets that return by popping an
++address off the stack, this might be a memory address just below
++the target call frame rather than inside the current call
++frame.  EH_RETURN_STACKADJ_RTX will have already been assigned,
++so it may be used to calculate the location of the target call frame.
++
++Some targets have more complex requirements than storing to an
++address calculable during initial code generation.  In that case
++the eh_return instruction pattern should be used instead.
++
++If you want to support call frame exception handling, you must
++define either this macro or the eh_return instruction pattern.
++*/
++/*
++  We define the eh_return instruction pattern, so this isn't needed.
++*/
++/* #define EH_RETURN_HANDLER_RTX gen_rtx_REG(Pmode, RET_REGISTER) */
++
++/*
++  This macro chooses the encoding of pointers embedded in the
++  exception handling sections. If at all possible, this should be
++  defined such that the exception handling section will not require
++  dynamic relocations, and so may be read-only.
++
++  code is 0 for data, 1 for code labels, 2 for function
++  pointers. global is true if the symbol may be affected by dynamic
++  relocations. The macro should return a combination of the DW_EH_PE_*
++  defines as found in dwarf2.h.
++
++  If this macro is not defined, pointers will not be encoded but
++  represented directly.
++*/
++#define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL)    \
++  ((flag_pic && (GLOBAL) ? DW_EH_PE_indirect : 0)     \
++   | (flag_pic ? DW_EH_PE_pcrel : DW_EH_PE_absptr)    \
++   | DW_EH_PE_sdata4)
++
++/* ToDo: The rest of this subsection */
++
++/** Specifying How Stack Checking is Done **/
++/* ToDo: All in this subsection */
++
++/** Registers That Address the Stack Frame **/
++
++/*
++The register number of the stack pointer register, which must also be a
++fixed register according to FIXED_REGISTERS.  On most machines,
++the hardware determines which register this is.
++*/
++/* Using r13 as stack pointer. */
++#define STACK_POINTER_REGNUM INTERNAL_REGNUM(13)
++
++/*
++The register number of the frame pointer register, which is used to
++access automatic variables in the stack frame.  On some machines, the
++hardware determines which register this is.  On other machines, you can
++choose any register you wish for this purpose.
++*/
++/* Use r7 */
++#define FRAME_POINTER_REGNUM INTERNAL_REGNUM(7)
++
++
++
++/*
++The register number of the arg pointer register, which is used to access
++the function's argument list.  On some machines, this is the same as the
++frame pointer register.  On some machines, the hardware determines which
++register this is.  On other machines, you can choose any register you
++wish for this purpose.  If this is not the same register as the frame
++pointer register, then you must mark it as a fixed register according to
++FIXED_REGISTERS, or arrange to be able to eliminate it (see Section
++10.10.5 [Elimination], page 224).
++*/
++/* Using r5 */
++#define ARG_POINTER_REGNUM INTERNAL_REGNUM(4)
++
++
++/*
++Register numbers used for passing a function's static chain pointer.  If
++register windows are used, the register number as seen by the called
++function is STATIC_CHAIN_INCOMING_REGNUM, while the register
++number as seen by the calling function is STATIC_CHAIN_REGNUM.  If
++these registers are the same, STATIC_CHAIN_INCOMING_REGNUM need
++not be defined.
++
++The static chain register need not be a fixed register.
++
++If the static chain is passed in memory, these macros should not be
++defined; instead, the next two macros should be defined.
++*/
++/* Using r0 */
++#define STATIC_CHAIN_REGNUM INTERNAL_REGNUM(0)
++
++
++/** Eliminating Frame Pointer and Arg Pointer **/
++
++/*
++A C expression which is nonzero if a function must have and use a frame
++pointer.  This expression is evaluated  in the reload pass.  If its value is
++nonzero the function will have a frame pointer.
++
++The expression can in principle examine the current function and decide
++according to the facts, but on most machines the constant 0 or the
++constant 1 suffices.  Use 0 when the machine allows code to be generated
++with no frame pointer, and doing so saves some time or space.  Use 1
++when there is no possible advantage to avoiding a frame pointer.
++
++In certain cases, the compiler does not know how to produce valid code
++without a frame pointer.  The compiler recognizes those cases and
++automatically gives the function a frame pointer regardless of what
++FRAME_POINTER_REQUIRED says.  You don't need to worry about
++them.
++
++In a function that does not require a frame pointer, the frame pointer
++register can be allocated for ordinary usage, unless you mark it as a
++fixed register.  See FIXED_REGISTERS for more information.
++*/
++/* We need the frame pointer when compiling for profiling */
++#define FRAME_POINTER_REQUIRED (current_function_profile)
++
++/*
++A C statement to store in the variable DEPTH_VAR the difference
++between the frame pointer and the stack pointer values immediately after
++the function prologue.  The value would be computed from information
++such as the result of get_frame_size () and the tables of
++registers regs_ever_live and call_used_regs.
++
++If ELIMINABLE_REGS is defined, this macro will be not be used and
++need not be defined.  Otherwise, it must be defined even if
++FRAME_POINTER_REQUIRED is defined to always be true; in that
++case, you may set DEPTH_VAR to anything.
++*/
++#define INITIAL_FRAME_POINTER_OFFSET(DEPTH_VAR) ((DEPTH_VAR) = get_frame_size())
++
++/*
++If defined, this macro specifies a table of register pairs used to
++eliminate unneeded registers that point into the stack frame.  If it is not
++defined, the only elimination attempted by the compiler is to replace
++references to the frame pointer with references to the stack pointer.
++
++The definition of this macro is a list of structure initializations, each
++of which specifies an original and replacement register.
++
++On some machines, the position of the argument pointer is not known until
++the compilation is completed.  In such a case, a separate hard register
++must be used for the argument pointer.  This register can be eliminated by
++replacing it with either the frame pointer or the argument pointer,
++depending on whether or not the frame pointer has been eliminated.
++
++In this case, you might specify:
++  #define ELIMINABLE_REGS  \
++  {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
++   {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \
++   {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
++
++Note that the elimination of the argument pointer with the stack pointer is
++specified first since that is the preferred elimination.
++*/
++#define ELIMINABLE_REGS                                       \
++{                                                     \
++  { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM },     \
++  { ARG_POINTER_REGNUM, STACK_POINTER_REGNUM },               \
++  { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM }                \
++}
++
++/*
++A C expression that returns nonzero if the compiler is allowed to try
++to replace register number FROM with register number
++TO.  This macro need only be defined if ELIMINABLE_REGS
++is defined, and will usually be the constant 1, since most of the cases
++preventing register elimination are things that the compiler already
++knows about.
++*/
++#define CAN_ELIMINATE(FROM, TO) 1
++
++/*
++This macro is similar to INITIAL_FRAME_POINTER_OFFSET.  It
++specifies the initial difference between the specified pair of
++registers.  This macro must be defined if ELIMINABLE_REGS is
++defined.
++*/
++#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)          \
++  ((OFFSET) = avr32_initial_elimination_offset(FROM, TO))
++
++/** Passing Function Arguments on the Stack **/
++
++
++/*
++A C expression.  If nonzero, push insns will be used to pass
++outgoing arguments.
++If the target machine does not have a push instruction, set it to zero.
++That directs GCC to use an alternate strategy: to
++allocate the entire argument block and then store the arguments into
++it.  When PUSH_ARGS is nonzero, PUSH_ROUNDING must be defined too.
++*/
++#define PUSH_ARGS 1
++
++
++/*
++A C expression that is the number of bytes actually pushed onto the
++stack when an instruction attempts to push NPUSHED bytes.
++
++On some machines, the definition
++
++  #define PUSH_ROUNDING(BYTES) (BYTES)
++
++will suffice.  But on other machines, instructions that appear
++to push one byte actually push two bytes in an attempt to maintain
++alignment.  Then the definition should be
++
++  #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
++*/
++/* Push 4 bytes at the time. */
++#define PUSH_ROUNDING(NPUSHED) (((NPUSHED) + 3) & ~3)
++
++/*
++A C expression.  If nonzero, the maximum amount of space required for
++outgoing arguments will be computed and placed into the variable
++current_function_outgoing_args_size.  No space will be pushed
++onto the stack for each call; instead, the function prologue should
++increase the stack frame size by this amount.
++
++Setting both PUSH_ARGS and ACCUMULATE_OUTGOING_ARGS is not proper.
++*/
++#define ACCUMULATE_OUTGOING_ARGS 0
++
++
++
++
++/*
++A C expression that should indicate the number of bytes of its own
++arguments that a function pops on returning, or 0 if the
++function pops no arguments and the caller must therefore pop them all
++after the function returns.
++
++FUNDECL is a C variable whose value is a tree node that describes
++the function in question.  Normally it is a node of type
++FUNCTION_DECL that describes the declaration of the function.
++From this you can obtain the DECL_ATTRIBUTES of the function.
++
++FUNTYPE is a C variable whose value is a tree node that
++describes the function in question.  Normally it is a node of type
++FUNCTION_TYPE that describes the data type of the function.
++From this it is possible to obtain the data types of the value and
++arguments (if known).
++
++When a call to a library function is being considered, FUNDECL
++will contain an identifier node for the library function.  Thus, if
++you need to distinguish among various library functions, you can do so
++by their names.  Note that ``library function'' in this context means
++a function used to perform arithmetic, whose name is known specially
++in the compiler and was not mentioned in the C code being compiled.
++
++STACK_SIZE is the number of bytes of arguments passed on the
++stack.  If a variable number of bytes is passed, it is zero, and
++argument popping will always be the responsibility of the calling function.
++
++On the VAX, all functions always pop their arguments, so the definition
++of this macro is STACK_SIZE.  On the 68000, using the standard
++calling convention, no functions pop their arguments, so the value of
++the macro is always 0 in this case.  But an alternative calling
++convention is available in which functions that take a fixed number of
++arguments pop them but other functions (such as printf) pop
++nothing (the caller pops all).  When this convention is in use,
++FUNTYPE is examined to determine whether a function takes a fixed
++number of arguments.
++*/
++#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
++
++
++/*Return true if this function can we use a single return instruction*/
++#define USE_RETURN_INSN(ISCOND) avr32_use_return_insn(ISCOND)
++
++/*
++A C expression that should indicate the number of bytes a call sequence
++pops off the stack.  It is added to the value of RETURN_POPS_ARGS
++when compiling a function call.
++
++CUM is the variable in which all arguments to the called function
++have been accumulated.
++
++On certain architectures, such as the SH5, a call trampoline is used
++that pops certain registers off the stack, depending on the arguments
++that have been passed to the function.  Since this is a property of the
++call site, not of the called function, RETURN_POPS_ARGS is not
++appropriate.
++*/
++#define CALL_POPS_ARGS(CUM) 0
++
++/* Passing Arguments in Registers */
++
++/*
++A C expression that controls whether a function argument is passed
++in a register, and which register.
++
++The arguments are CUM, which summarizes all the previous
++arguments; MODE, the machine mode of the argument; TYPE,
++the data type of the argument as a tree node or 0 if that is not known
++(which happens for C support library functions); and NAMED,
++which is 1 for an ordinary argument and 0 for nameless arguments that
++correspond to '...' in the called function's prototype.
++TYPE can be an incomplete type if a syntax error has previously
++occurred.
++
++The value of the expression is usually either a reg RTX for the
++hard register in which to pass the argument, or zero to pass the
++argument on the stack.
++
++For machines like the VAX and 68000, where normally all arguments are
++pushed, zero suffices as a definition.
++
++The value of the expression can also be a parallel RTX.  This is
++used when an argument is passed in multiple locations.  The mode of the
++of the parallel should be the mode of the entire argument.  The
++parallel holds any number of expr_list pairs; each one
++describes where part of the argument is passed.  In each
++expr_list the first operand must be a reg RTX for the hard
++register in which to pass this part of the argument, and the mode of the
++register RTX indicates how large this part of the argument is.  The
++second operand of the expr_list is a const_int which gives
++the offset in bytes into the entire argument of where this part starts.
++As a special exception the first expr_list in the parallel
++RTX may have a first operand of zero.  This indicates that the entire
++argument is also stored on the stack.
++
++The last time this macro is called, it is called with MODE == VOIDmode,
++and its result is passed to the call or call_value
++pattern as operands 2 and 3 respectively.
++
++The usual way to make the ISO library 'stdarg.h' work on a machine
++where some arguments are usually passed in registers, is to cause
++nameless arguments to be passed on the stack instead.  This is done
++by making FUNCTION_ARG return 0 whenever NAMED is 0.
++
++You may use the macro MUST_PASS_IN_STACK (MODE, TYPE)
++in the definition of this macro to determine if this argument is of a
++type that must be passed in the stack.  If REG_PARM_STACK_SPACE
++is not defined and FUNCTION_ARG returns nonzero for such an
++argument, the compiler will abort.  If REG_PARM_STACK_SPACE is
++defined, the argument will be computed in the stack and then loaded into
++a register.  */
++
++#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
++  avr32_function_arg(&(CUM), MODE, TYPE, NAMED)
++
++
++
++
++/*
++A C type for declaring a variable that is used as the first argument of
++FUNCTION_ARG and other related values.  For some target machines,
++the type int suffices and can hold the number of bytes of
++argument so far.
++
++There is no need to record in CUMULATIVE_ARGS anything about the
++arguments that have been passed on the stack.  The compiler has other
++variables to keep track of that.  For target machines on which all
++arguments are passed on the stack, there is no need to store anything in
++CUMULATIVE_ARGS; however, the data structure must exist and
++should not be empty, so use int.
++*/
++typedef struct avr32_args
++{
++  /* Index representing the argument register the current function argument
++     will occupy */
++  int index;
++  /* A mask with bits representing the argument registers: if a bit is set
++     then this register is used for an arguemnt */
++  int used_index;
++  /* TRUE if this function has anonymous arguments */
++  int uses_anonymous_args;
++  /* The size in bytes of the named arguments pushed on the stack */
++  int stack_pushed_args_size;
++  /* Set to true if this function needs a Return Value Pointer */
++  int use_rvp;
++
++} CUMULATIVE_ARGS;
++
++
++#define FIRST_CUM_REG_INDEX 0
++#define LAST_CUM_REG_INDEX 4
++#define GET_REG_INDEX(CUM) ((CUM)->index)
++#define SET_REG_INDEX(CUM, INDEX) ((CUM)->index = (INDEX));
++#define GET_USED_INDEX(CUM, INDEX) ((CUM)->used_index & (1 << (INDEX)))
++#define SET_USED_INDEX(CUM, INDEX)            \
++  do                                          \
++    {                                         \
++      if (INDEX >= 0)                         \
++        (CUM)->used_index |= (1 << (INDEX));  \
++    }                                         \
++  while (0)
++#define SET_INDEXES_UNUSED(CUM) ((CUM)->used_index = 0)
++
++
++/*
++   A C statement (sans semicolon) for initializing the variable cum for the
++   state at the beginning of the argument list. The variable has type
++   CUMULATIVE_ARGS. The value of FNTYPE is the tree node for the data type of
++   the function which will receive the args, or 0 if the args are to a compiler
++   support library function. For direct calls that are not libcalls, FNDECL
++   contain the declaration node of the function. FNDECL is also set when
++   INIT_CUMULATIVE_ARGS is used to find arguments for the function being
++   compiled.  N_NAMED_ARGS is set to the number of named arguments, including a
++   structure return address if it is passed as a parameter, when making a call.
++   When processing incoming arguments, N_NAMED_ARGS is set to -1.
++
++   When processing a call to a compiler support library function, LIBNAME
++   identifies which one.  It is a symbol_ref rtx which contains the name of the
++   function, as a string. LIBNAME is 0 when an ordinary C function call is
++   being processed. Thus, each time this macro is called, either LIBNAME or
++   FNTYPE is nonzero, but never both of them at once.
++*/
++#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
++  avr32_init_cumulative_args(&(CUM), FNTYPE, LIBNAME, FNDECL)
++
++
++/*
++A C statement (sans semicolon) to update the summarizer variable
++CUM to advance past an argument in the argument list.  The
++values MODE, TYPE and NAMED describe that argument.
++Once this is done, the variable CUM is suitable for analyzing
++the following argument with FUNCTION_ARG, etc.
++
++This macro need not do anything if the argument in question was passed
++on the stack.  The compiler knows how to track the amount of stack space
++used for arguments without any special help.
++*/
++#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
++  avr32_function_arg_advance(&(CUM), MODE, TYPE, NAMED)
++
++/*
++If defined, a C expression which determines whether, and in which direction,
++to pad out an argument with extra space.  The value should be of type
++enum direction: either 'upward' to pad above the argument,
++'downward' to pad below, or 'none' to inhibit padding.
++
++The amount of padding is always just enough to reach the next
++multiple of FUNCTION_ARG_BOUNDARY; this macro does not control
++it.
++
++This macro has a default definition which is right for most systems.
++For little-endian machines, the default is to pad upward.  For
++big-endian machines, the default is to pad downward for an argument of
++constant size shorter than an int, and upward otherwise.
++*/
++#define FUNCTION_ARG_PADDING(MODE, TYPE) \
++  avr32_function_arg_padding(MODE, TYPE)
++
++/*
++  Specify padding for the last element of a block move between registers
++  and memory. First is nonzero if this is the only element. Defining
++  this macro allows better control of register function parameters on
++  big-endian machines, without using PARALLEL rtl. In particular,
++  MUST_PASS_IN_STACK need not test padding and mode of types in registers,
++  as there is no longer a "wrong" part of a register; For example, a three
++  byte aggregate may be passed in the high part of a register if so required.
++*/
++#define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \
++  avr32_function_arg_padding(MODE, TYPE)
++
++/*
++If defined, a C expression which determines whether the default
++implementation of va_arg will attempt to pad down before reading the
++next argument, if that argument is smaller than its aligned space as
++controlled by PARM_BOUNDARY.  If this macro is not defined, all such
++arguments are padded down if BYTES_BIG_ENDIAN is true.
++*/
++#define PAD_VARARGS_DOWN \
++  (FUNCTION_ARG_PADDING (TYPE_MODE (type), type) == downward)
++
++
++/*
++A C expression that is nonzero if REGNO is the number of a hard
++register in which function arguments are sometimes passed.  This does
++not include implicit arguments such as the static chain and
++the structure-value address.  On many machines, no registers can be
++used for this purpose since all function arguments are pushed on the
++stack.
++*/
++/*
++  Use r8 - r12 for function arguments.
++*/
++#define FUNCTION_ARG_REGNO_P(REGNO) \
++  (REGNO >= 3 && REGNO <= 7)
++
++/* Number of registers used for passing function arguments */
++#define NUM_ARG_REGS 5
++
++/*
++If defined, the order in which arguments are loaded into their
++respective argument registers is reversed so that the last
++argument is loaded first.  This macro only affects arguments
++passed in registers.
++*/
++/* #define LOAD_ARGS_REVERSED */
++
++/** How Scalar Function Values Are Returned **/
++
++/* AVR32 is using r12 as return register. */
++#define RET_REGISTER (15 - 12)
++
++/*
++Define this macro if -traditional should not cause functions
++declared to return float to convert the value to double.
++*/
++/* #define TRADITIONAL_RETURN_FLOAT */
++
++/*
++A C expression to create an RTX representing the place where a
++function returns a value of data type VALTYPE.  VALTYPE is
++a tree node representing a data type.  Write TYPE_MODE(VALTYPE)
++to get the machine mode used to represent that type.
++On many machines, only the mode is relevant.  (Actually, on most
++machines, scalar values are returned in the same place regardless of
++mode).
++
++The value of the expression is usually a reg RTX for the hard
++register where the return value is stored.  The value can also be a
++parallel RTX, if the return value is in multiple places.  See
++FUNCTION_ARG for an explanation of the parallel form.
++
++If PROMOTE_FUNCTION_RETURN is defined, you must apply the same
++promotion rules specified in PROMOTE_MODE if VALTYPE is a
++scalar type.
++
++If the precise function being called is known, FUNC is a tree
++node (FUNCTION_DECL) for it; otherwise, FUNC is a null
++pointer.  This makes it possible to use a different value-returning
++convention for specific functions when all their calls are
++known.
++
++FUNCTION_VALUE is not used for return vales with aggregate data
++types, because these are returned in another way.  See
++STRUCT_VALUE_REGNUM and related macros, below.
++*/
++#define FUNCTION_VALUE(VALTYPE, FUNC) avr32_function_value(VALTYPE, FUNC)
++
++
++/*
++A C expression to create an RTX representing the place where a library
++function returns a value of mode MODE.  If the precise function
++being called is known, FUNC is a tree node
++(FUNCTION_DECL) for it; otherwise, func is a null
++pointer.  This makes it possible to use a different value-returning
++convention for specific functions when all their calls are
++known.
++
++Note that "library function" in this context means a compiler
++support routine, used to perform arithmetic, whose name is known
++specially by the compiler and was not mentioned in the C code being
++compiled.
++
++The definition of LIBRARY_VALUE need not be concerned aggregate
++data types, because none of the library functions returns such types.
++*/
++#define LIBCALL_VALUE(MODE) avr32_libcall_value(MODE)
++
++/*
++A C expression that is nonzero if REGNO is the number of a hard
++register in which the values of called function may come back.
++
++A register whose use for returning values is limited to serving as the
++second of a pair (for a value of type double, say) need not be
++recognized by this macro.  So for most machines, this definition
++suffices:
++  #define FUNCTION_VALUE_REGNO_P(N) ((N) == 0)
++
++If the machine has register windows, so that the caller and the called
++function use different registers for the return value, this macro
++should recognize only the caller's register numbers.
++*/
++/*
++  When returning a value of mode DImode, r11:r10 is used, else r12 is used.
++*/
++#define FUNCTION_VALUE_REGNO_P(REGNO) ((REGNO) == RET_REGISTER \
++                                       || (REGNO) == INTERNAL_REGNUM(11))
++
++
++/** How Large Values Are Returned **/
++
++
++/*
++Define this macro to be 1 if all structure and union return values must be
++in memory.  Since this results in slower code, this should be defined
++only if needed for compatibility with other compilers or with an ABI.
++If you define this macro to be 0, then the conventions used for structure
++and union return values are decided by the RETURN_IN_MEMORY macro.
++
++If not defined, this defaults to the value 1.
++*/
++#define DEFAULT_PCC_STRUCT_RETURN 0
++
++
++
++
++/** Generating Code for Profiling **/
++
++/*
++A C statement or compound statement to output to FILE some
++assembler code to call the profiling subroutine mcount.
++
++The details of how mcount expects to be called are determined by
++your operating system environment, not by GCC.  To figure them out,
++compile a small program for profiling using the system's installed C
++compiler and look at the assembler code that results.
++
++Older implementations of mcount expect the address of a counter
++variable to be loaded into some register.  The name of this variable is
++'LP' followed by the number LABELNO, so you would generate
++the name using 'LP%d' in a fprintf.
++*/
++/* ToDo: fixme */
++#ifndef FUNCTION_PROFILER
++#define FUNCTION_PROFILER(FILE, LABELNO) \
++  fprintf((FILE), "/* profiler %d */", (LABELNO))
++#endif
++
++
++/*****************************************************************************
++ * Trampolines for Nested Functions                                          *
++ *****************************************************************************/
++
++/*
++A C statement to output, on the stream FILE, assembler code for a
++block of data that contains the constant parts of a trampoline.  This
++code should not include a label - the label is taken care of
++automatically.
++
++If you do not define this macro, it means no template is needed
++for the target.  Do not define this macro on systems where the block move
++code to copy the trampoline into place would be larger than the code
++to generate it on the spot.
++*/
++/* ToDo: correct? */
++#define TRAMPOLINE_TEMPLATE(FILE) avr32_trampoline_template(FILE);
++
++
++/*
++A C expression for the size in bytes of the trampoline, as an integer.
++*/
++/* ToDo: fixme */
++#define TRAMPOLINE_SIZE 0x0C
++
++/*
++Alignment required for trampolines, in bits.
++
++If you don't define this macro, the value of BIGGEST_ALIGNMENT
++is used for aligning trampolines.
++*/
++#define TRAMPOLINE_ALIGNMENT 16
++
++/*
++A C statement to initialize the variable parts of a trampoline.
++ADDR is an RTX for the address of the trampoline; FNADDR is
++an RTX for the address of the nested function; STATIC_CHAIN is an
++RTX for the static chain value that should be passed to the function
++when it is called.
++*/
++#define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN) \
++  avr32_initialize_trampoline(ADDR, FNADDR, STATIC_CHAIN)
++
++
++/******************************************************************************
++ * Implicit Calls to Library Routines
++ *****************************************************************************/
++
++/* Tail calling.  */
++
++/* A C expression that evaluates to true if it is ok to perform a sibling
++   call to DECL.  */
++#define FUNCTION_OK_FOR_SIBCALL(DECL) 0
++
++#define OVERRIDE_OPTIONS  avr32_override_options ()
++
++
++
++/******************************************************************************
++ * Addressing Modes
++ *****************************************************************************/
++
++/*
++A C expression that is nonzero if the machine supports pre-increment,
++pre-decrement, post-increment, or post-decrement addressing respectively.
++*/
++/*
++  AVR32 supports Rp++ and --Rp
++*/
++#define HAVE_PRE_INCREMENT 0
++#define HAVE_PRE_DECREMENT 1
++#define HAVE_POST_INCREMENT 1
++#define HAVE_POST_DECREMENT 0
++
++/*
++A C expression that is nonzero if the machine supports pre- or
++post-address side-effect generation involving constants other than
++the size of the memory operand.
++*/
++#define HAVE_PRE_MODIFY_DISP 0
++#define HAVE_POST_MODIFY_DISP 0
++
++/*
++A C expression that is nonzero if the machine supports pre- or
++post-address side-effect generation involving a register displacement.
++*/
++#define HAVE_PRE_MODIFY_REG 0
++#define HAVE_POST_MODIFY_REG 0
++
++/*
++A C expression that is 1 if the RTX X is a constant which
++is a valid address.  On most machines, this can be defined as
++CONSTANT_P (X), but a few machines are more restrictive
++in which constant addresses are supported.
++
++CONSTANT_P accepts integer-values expressions whose values are
++not explicitly known, such as symbol_ref, label_ref, and
++high expressions and const arithmetic expressions, in
++addition to const_int and const_double expressions.
++*/
++#define CONSTANT_ADDRESS_P(X) CONSTANT_P(X)
++
++/*
++A number, the maximum number of registers that can appear in a valid
++memory address.  Note that it is up to you to specify a value equal to
++the maximum number that GO_IF_LEGITIMATE_ADDRESS would ever
++accept.
++*/
++#define MAX_REGS_PER_ADDRESS 2
++
++/*
++A C compound statement with a conditional goto LABEL;
++executed if X (an RTX) is a legitimate memory address on the
++target machine for a memory operand of mode MODE.
++
++It usually pays to define several simpler macros to serve as
++subroutines for this one.  Otherwise it may be too complicated to
++understand.
++
++This macro must exist in two variants: a strict variant and a
++non-strict one.  The strict variant is used in the reload pass.  It
++must be defined so that any pseudo-register that has not been
++allocated a hard register is considered a memory reference.  In
++contexts where some kind of register is required, a pseudo-register
++with no hard register must be rejected.
++
++The non-strict variant is used in other passes.  It must be defined to
++accept all pseudo-registers in every context where some kind of
++register is required.
++
++Compiler source files that want to use the strict variant of this
++macro define the macro REG_OK_STRICT.  You should use an
++#ifdef REG_OK_STRICT conditional to define the strict variant
++in that case and the non-strict variant otherwise.
++
++Subroutines to check for acceptable registers for various purposes (one
++for base registers, one for index registers, and so on) are typically
++among the subroutines used to define GO_IF_LEGITIMATE_ADDRESS.
++Then only these subroutine macros need have two variants; the higher
++levels of macros may be the same whether strict or not.
++
++Normally, constant addresses which are the sum of a symbol_ref
++and an integer are stored inside a const RTX to mark them as
++constant.  Therefore, there is no need to recognize such sums
++specifically as legitimate addresses.  Normally you would simply
++recognize any const as legitimate.
++
++Usually PRINT_OPERAND_ADDRESS is not prepared to handle constant
++sums that are not marked with  const.  It assumes that a naked
++plus indicates indexing.  If so, then you must reject such
++naked constant sums as illegitimate addresses, so that none of them will
++be given to PRINT_OPERAND_ADDRESS.
++
++On some machines, whether a symbolic address is legitimate depends on
++the section that the address refers to.  On these machines, define the
++macro ENCODE_SECTION_INFO to store the information into the
++symbol_ref, and then check for it here.  When you see a
++const, you will have to look inside it to find the
++symbol_ref in order to determine the section.
++
++The best way to modify the name string is by adding text to the
++beginning, with suitable punctuation to prevent any ambiguity.  Allocate
++the new name in saveable_obstack.  You will have to modify
++ASM_OUTPUT_LABELREF to remove and decode the added text and
++output the name accordingly, and define STRIP_NAME_ENCODING to
++access the original name string.
++
++You can check the information stored here into the symbol_ref in
++the definitions of the macros GO_IF_LEGITIMATE_ADDRESS and
++PRINT_OPERAND_ADDRESS.
++*/
++#ifdef REG_OK_STRICT
++#  define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)    \
++  do                                                  \
++    {                                                 \
++      if (avr32_legitimate_address(MODE, X, 1))               \
++      goto LABEL;                                     \
++    }                                                 \
++  while (0)
++#else
++#  define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)    \
++  do                                                  \
++    {                                                 \
++      if (avr32_legitimate_address(MODE, X, 0))               \
++      goto LABEL;                                     \
++    }                                                 \
++  while (0)
++#endif
++
++/*
++A C expression that is nonzero if X (assumed to be a reg
++RTX) is valid for use as a base register.  For hard registers, it
++should always accept those which the hardware permits and reject the
++others.  Whether the macro accepts or rejects pseudo registers must be
++controlled by REG_OK_STRICT as described above.  This usually
++requires two variant definitions, of which REG_OK_STRICT
++controls the one actually used.
++*/
++#ifdef REG_OK_STRICT
++#  define REG_OK_FOR_BASE_P(X) \
++  REGNO_OK_FOR_BASE_P(REGNO(X))
++#else
++#  define REG_OK_FOR_BASE_P(X) \
++  ((REGNO(X) <= LAST_REGNUM) || (REGNO(X) >= FIRST_PSEUDO_REGISTER))
++#endif
++
++
++/*
++A C expression that is nonzero if X (assumed to be a reg
++RTX) is valid for use as an index register.
++
++The difference between an index register and a base register is that
++the index register may be scaled.  If an address involves the sum of
++two registers, neither one of them scaled, then either one may be
++labeled the "base" and the other the "index"; but whichever
++labeling is used must fit the machine's constraints of which registers
++may serve in each capacity.  The compiler will try both labelings,
++looking for one that is valid, and will reload one or both registers
++only if neither labeling works.
++*/
++#define REG_OK_FOR_INDEX_P(X) \
++  REG_OK_FOR_BASE_P(X)
++
++
++/*
++A C compound statement that attempts to replace X with a valid
++memory address for an operand of mode MODE.  win will be a
++C statement label elsewhere in the code; the macro definition may use
++
++  GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN);
++
++to avoid further processing if the address has become legitimate.
++
++X will always be the result of a call to break_out_memory_refs,
++and OLDX will be the operand that was given to that function to produce
++X.
++
++The code generated by this macro should not alter the substructure of
++X.  If it transforms X into a more legitimate form, it
++should assign X (which will always be a C variable) a new value.
++
++It is not necessary for this macro to come up with a legitimate
++address.  The compiler has standard ways of doing so in all cases.  In
++fact, it is safe for this macro to do nothing.  But often a
++machine-dependent strategy can generate better code.
++*/
++#define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN)                        \
++  do                                                          \
++    {                                                         \
++      if (GET_CODE(X) == PLUS                                 \
++        && GET_CODE(XEXP(X, 0)) == REG                        \
++        && GET_CODE(XEXP(X, 1)) == CONST_INT                  \
++        && !CONST_OK_FOR_CONSTRAINT_P(INTVAL(XEXP(X, 1)),     \
++                                      'K', "Ks16"))           \
++      {                                                       \
++        rtx index = force_reg(SImode, XEXP(X, 1));            \
++        X = gen_rtx_PLUS( SImode, XEXP(X, 0), index);         \
++      }                                                       \
++      GO_IF_LEGITIMATE_ADDRESS(MODE, X, WIN);                 \
++    }                                                         \
++  while(0)
++
++
++/*
++A C statement or compound statement with a conditional
++goto LABEL; executed if memory address X (an RTX) can have
++different meanings depending on the machine mode of the memory
++reference it is used for or if the address is valid for some modes
++but not others.
++
++Autoincrement and autodecrement addresses typically have mode-dependent
++effects because the amount of the increment or decrement is the size
++of the operand being addressed.  Some machines have other mode-dependent
++addresses.  Many RISC machines have no mode-dependent addresses.
++
++You may assume that ADDR is a valid address for the machine.
++*/
++#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)     \
++  do                                                  \
++    {                                                 \
++      if (GET_CODE (ADDR) == POST_INC                 \
++        || GET_CODE (ADDR) == PRE_DEC)                \
++      goto LABEL;                                     \
++    }                                                 \
++  while (0)
++
++/*
++A C expression that is nonzero if X is a legitimate constant for
++an immediate operand on the target machine.  You can assume that
++X satisfies CONSTANT_P, so you need not check this.  In fact,
++'1' is a suitable definition for this macro on machines where
++anything CONSTANT_P is valid.
++*/
++#define LEGITIMATE_CONSTANT_P(X) avr32_legitimate_constant_p(X)
++
++
++/******************************************************************************
++ * Condition Code Status
++ *****************************************************************************/
++
++#define HAVE_conditional_move 1
++
++/*
++C code for a data type which is used for declaring the mdep
++component of cc_status.  It defaults to int.
++
++This macro is not used on machines that do not use cc0.
++*/
++
++typedef struct
++{
++  int flags;
++  rtx value;
++  int fpflags;
++  rtx fpvalue;
++} avr32_status_reg;
++
++
++#define CC_STATUS_MDEP avr32_status_reg
++
++/*
++A C expression to initialize the mdep field to "empty".
++The default definition does nothing, since most machines don't use
++the field anyway.  If you want to use the field, you should probably
++define this macro to initialize it.
++
++This macro is not used on machines that do not use cc0.
++*/
++
++#define CC_STATUS_MDEP_INIT  \
++ (cc_status.mdep.flags = CC_NONE , cc_status.mdep.value = 0)
++
++#define FPCC_STATUS_INIT \
++   (cc_status.mdep.fpflags = CC_NONE , cc_status.mdep.fpvalue = 0)
++
++/*
++A C compound statement to set the components of cc_status
++appropriately for an insn INSN whose body is EXP.  It is
++this macro's responsibility to recognize insns that set the condition
++code as a byproduct of other activity as well as those that explicitly
++set (cc0).
++
++This macro is not used on machines that do not use cc0.
++
++If there are insns that do not set the condition code but do alter
++other machine registers, this macro must check to see whether they
++invalidate the expressions that the condition code is recorded as
++reflecting.  For example, on the 68000, insns that store in address
++registers do not set the condition code, which means that usually
++NOTICE_UPDATE_CC can leave cc_status unaltered for such
++insns.  But suppose that the previous insn set the condition code
++based on location 'a4@@(102)' and the current insn stores a new
++value in 'a4'.  Although the condition code is not changed by
++this, it will no longer be true that it reflects the contents of
++'a4@@(102)'.  Therefore, NOTICE_UPDATE_CC must alter
++cc_status in this case to say that nothing is known about the
++condition code value.
++
++The definition of NOTICE_UPDATE_CC must be prepared to deal
++with the results of peephole optimization: insns whose patterns are
++parallel RTXs containing various reg, mem or
++constants which are just the operands.  The RTL structure of these
++insns is not sufficient to indicate what the insns actually do.  What
++NOTICE_UPDATE_CC should do when it sees one is just to run
++CC_STATUS_INIT.
++
++A possible definition of NOTICE_UPDATE_CC is to call a function
++that looks at an attribute (see Insn Attributes) named, for example,
++'cc'.  This avoids having detailed information about patterns in
++two places, the 'md' file and in NOTICE_UPDATE_CC.
++*/
++
++#define NOTICE_UPDATE_CC(EXP, INSN) avr32_notice_update_cc(EXP, INSN)
++
++
++
++
++/******************************************************************************
++ * Describing Relative Costs of Operations
++ *****************************************************************************/
++
++
++
++/*
++A C expression for the cost of moving data of mode MODE from a
++register in class FROM to one in class TO.  The classes are
++expressed using the enumeration values such as GENERAL_REGS.  A
++value of 2 is the default; other values are interpreted relative to
++that.
++
++It is not required that the cost always equal 2 when FROM is the
++same as TO; on some machines it is expensive to move between
++registers if they are not general registers.
++
++If reload sees an insn consisting of a single set between two
++hard registers, and if REGISTER_MOVE_COST applied to their
++classes returns a value of 2, reload does not check to ensure that the
++constraints of the insn are met.  Setting a cost of other than 2 will
++allow reload to verify that the constraints are met.  You should do this
++if the movm pattern's constraints do not allow such copying.
++*/
++#define REGISTER_MOVE_COST(MODE, FROM, TO) \
++  ((GET_MODE_SIZE(MODE) <= 4) ? 2:         \
++   (GET_MODE_SIZE(MODE) <= 8) ? 3:         \
++   4)
++
++/*
++A C expression for the cost of moving data of mode MODE between a
++register of class CLASS and memory; IN is zero if the value
++is to be written to memory, nonzero if it is to be read in.  This cost
++is relative to those in REGISTER_MOVE_COST.  If moving between
++registers and memory is more expensive than between two registers, you
++should define this macro to express the relative cost.
++
++If you do not define this macro, GCC uses a default cost of 4 plus
++the cost of copying via a secondary reload register, if one is
++needed.  If your machine requires a secondary reload register to copy
++between memory and a register of CLASS but the reload mechanism is
++more complex than copying via an intermediate, define this macro to
++reflect the actual cost of the move.
++
++GCC defines the function memory_move_secondary_cost if
++secondary reloads are needed.  It computes the costs due to copying via
++a secondary register.  If your machine copies from memory using a
++secondary register in the conventional way but the default base value of
++4 is not correct for your machine, define this macro to add some other
++value to the result of that function.  The arguments to that function
++are the same as to this macro.
++*/
++/*
++  Memory moves are costly
++*/
++#define MEMORY_MOVE_COST(MODE, CLASS, IN)    10
++/*
++  (((IN) ? ((GET_MODE_SIZE(MODE) < 4) ? 4 :          \
++            (GET_MODE_SIZE(MODE) > 8) ? 6 :          \
++            3)                                       \
++         : ((GET_MODE_SIZE(MODE) > 8) ? 4 : 2)))
++*/
++
++/*
++A C expression for the cost of a branch instruction.  A value of 1 is
++the default; other values are interpreted relative to that.
++*/
++  /* Try to use conditionals as much as possible */
++#define BRANCH_COST (TARGET_BRANCH_PRED ? 3 : 5)
++
++/*A C expression for the maximum number of instructions to execute via conditional
++  execution instructions instead of a branch. A value of BRANCH_COST+1 is the default
++  if the machine does not use cc0, and 1 if it does use cc0.*/
++#define MAX_CONDITIONAL_EXECUTE 3
++
++/*
++Define this macro as a C expression which is nonzero if accessing less
++than a word of memory (i.e.: a char or a short) is no
++faster than accessing a word of memory, i.e., if such access
++require more than one instruction or if there is no difference in cost
++between byte and (aligned) word loads.
++
++When this macro is not defined, the compiler will access a field by
++finding the smallest containing object; when it is defined, a fullword
++load will be used if alignment permits.  Unless bytes accesses are
++faster than word accesses, using word accesses is preferable since it
++may eliminate subsequent memory access if subsequent accesses occur to
++other fields in the same word of the structure, but to different bytes.
++*/
++#define SLOW_BYTE_ACCESS 1
++
++
++/*
++Define this macro if it is as good or better to call a constant
++function address than to call an address kept in a register.
++*/
++#define NO_FUNCTION_CSE
++
++
++/******************************************************************************
++ * Adjusting the Instruction Scheduler
++ *****************************************************************************/
++
++/*****************************************************************************
++ * Dividing the Output into Sections (Texts, Data, ...)                      *
++ *****************************************************************************/
++
++/*
++A C expression whose value is a string, including spacing, containing the
++assembler operation that should precede instructions and read-only data.
++Normally "\t.text" is right.
++*/
++#define TEXT_SECTION_ASM_OP "\t.text"
++/*
++A C statement that switches to the default section containing instructions.
++Normally this is not needed, as simply defining TEXT_SECTION_ASM_OP
++is enough.  The MIPS port uses this to sort all functions after all data
++declarations.
++*/
++/* #define TEXT_SECTION */
++
++/*
++A C expression whose value is a string, including spacing, containing the
++assembler operation to identify the following data as writable initialized
++data.  Normally "\t.data" is right.
++*/
++#define DATA_SECTION_ASM_OP "\t.data"
++
++/*
++If defined, a C expression whose value is a string, including spacing,
++containing the assembler operation to identify the following data as
++shared data.  If not defined, DATA_SECTION_ASM_OP will be used.
++*/
++
++/*
++A C expression whose value is a string, including spacing, containing
++the assembler operation to identify the following data as read-only
++initialized data.
++*/
++#undef READONLY_DATA_SECTION_ASM_OP
++#define READONLY_DATA_SECTION_ASM_OP \
++  ((TARGET_USE_RODATA_SECTION) ?  \
++   "\t.section\t.rodata" :                \
++   TEXT_SECTION_ASM_OP )
++
++
++/*
++If defined, a C expression whose value is a string, including spacing,
++containing the assembler operation to identify the following data as
++uninitialized global data.  If not defined, and neither
++ASM_OUTPUT_BSS nor ASM_OUTPUT_ALIGNED_BSS are defined,
++uninitialized global data will be output in the data section if
++-fno-common is passed, otherwise ASM_OUTPUT_COMMON will be
++used.
++*/
++#define BSS_SECTION_ASM_OP    "\t.section\t.bss"
++
++/*
++If defined, a C expression whose value is a string, including spacing,
++containing the assembler operation to identify the following data as
++uninitialized global shared data.  If not defined, and
++BSS_SECTION_ASM_OP is, the latter will be used.
++*/
++/*#define SHARED_BSS_SECTION_ASM_OP "\trseg\tshared_bbs_section:data:noroot(0)\n"*/
++/*
++If defined, a C expression whose value is a string, including spacing,
++containing the assembler operation to identify the following data as
++initialization code.  If not defined, GCC will assume such a section does
++not exist.
++*/
++#undef  INIT_SECTION_ASM_OP
++#define INIT_SECTION_ASM_OP "\t.section\t.init"
++
++/*
++If defined, a C expression whose value is a string, including spacing,
++containing the assembler operation to identify the following data as
++finalization code.  If not defined, GCC will assume such a section does
++not exist.
++*/
++#undef  FINI_SECTION_ASM_OP
++#define FINI_SECTION_ASM_OP "\t.section\t.fini"
++
++/*
++If defined, an ASM statement that switches to a different section
++via SECTION_OP, calls FUNCTION, and switches back to
++the text section.  This is used in crtstuff.c if
++INIT_SECTION_ASM_OP or FINI_SECTION_ASM_OP to calls
++to initialization and finalization functions from the init and fini
++sections.  By default, this macro uses a simple function call.  Some
++ports need hand-crafted assembly code to avoid dependencies on
++registers initialized in the function prologue or to ensure that
++constant pools don't end up too far way in the text section.
++*/
++#define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC)      \
++   asm ( SECTION_OP "\n" \
++         "mcall   r6[" USER_LABEL_PREFIX #FUNC "@got]\n" \
++         TEXT_SECTION_ASM_OP);
++
++
++/*
++Define this macro to be an expression with a nonzero value if jump
++tables (for tablejump insns) should be output in the text
++section, along with the assembler instructions.  Otherwise, the
++readonly data section is used.
++
++This macro is irrelevant if there is no separate readonly data section.
++*/
++#define JUMP_TABLES_IN_TEXT_SECTION 1
++
++
++/******************************************************************************
++ * Position Independent Code (PIC)
++ *****************************************************************************/
++
++#ifndef AVR32_ALWAYS_PIC
++#define AVR32_ALWAYS_PIC 0
++#endif
++
++/* GOT is set to r6 */
++#define PIC_OFFSET_TABLE_REGNUM INTERNAL_REGNUM(6)
++
++/*
++A C expression that is nonzero if X is a legitimate immediate
++operand on the target machine when generating position independent code.
++You can assume that X satisfies CONSTANT_P, so you need not
++check this.  You can also assume flag_pic is true, so you need not
++check it either.  You need not define this macro if all constants
++(including SYMBOL_REF) can be immediate operands when generating
++position independent code.
++*/
++/* We can't directly access anything that contains a symbol,
++   nor can we indirect via the constant pool.  */
++#define LEGITIMATE_PIC_OPERAND_P(X) avr32_legitimate_pic_operand_p(X)
++
++
++/* We need to know when we are making a constant pool; this determines
++   whether data needs to be in the GOT or can be referenced via a GOT
++   offset.  */
++extern int making_const_table;
++
++/******************************************************************************
++ * Defining the Output Assembler Language
++ *****************************************************************************/
++
++
++/*
++A C string constant describing how to begin a comment in the target
++assembler language.  The compiler assumes that the comment will end at
++the end of the line.
++*/
++#define ASM_COMMENT_START "# "
++
++/*
++A C string constant for text to be output before each asm
++statement or group of consecutive ones.  Normally this is
++"#APP", which is a comment that has no effect on most
++assemblers but tells the GNU assembler that it must check the lines
++that follow for all valid assembler constructs.
++*/
++#undef ASM_APP_ON
++#define ASM_APP_ON "#APP\n"
++
++/*
++A C string constant for text to be output after each asm
++statement or group of consecutive ones.  Normally this is
++"#NO_APP", which tells the GNU assembler to resume making the
++time-saving assumptions that are valid for ordinary compiler output.
++*/
++#undef ASM_APP_OFF
++#define ASM_APP_OFF "#NO_APP\n"
++
++
++
++#define FILE_ASM_OP           "\t.file\n"
++#define IDENT_ASM_OP          "\t.ident\t"
++#define SET_ASM_OP            "\t.set\t"
++
++
++/*
++ * Output assembly directives to switch to section name. The section
++ * should have attributes as specified by flags, which is a bit mask
++ * of the SECTION_* flags defined in 'output.h'. If align is nonzero,
++ * it contains an alignment in bytes to be used for the section,
++ * otherwise some target default should be used. Only targets that
++ * must specify an alignment within the section directive need pay
++ * attention to align -- we will still use ASM_OUTPUT_ALIGN.
++ *
++ * NOTE: This one must not be moved to avr32.c
++ */
++#undef TARGET_ASM_NAMED_SECTION
++#define TARGET_ASM_NAMED_SECTION default_elf_asm_named_section
++
++
++/*
++You may define this macro as a C expression.  You should define the
++expression to have a nonzero value if GCC should output the constant
++pool for a function before the code for the function, or a zero value if
++GCC should output the constant pool after the function.  If you do
++not define this macro, the usual case, GCC will output the constant
++pool before the function.
++*/
++#define CONSTANT_POOL_BEFORE_FUNCTION 0
++
++
++/*
++Define this macro as a C expression which is nonzero if the constant
++EXP, of type tree, should be output after the code for a
++function.  The compiler will normally output all constants before the
++function; you need not define this macro if this is OK.
++*/
++#define CONSTANT_AFTER_FUNCTION_P(EXP) 1
++
++
++/*
++Define this macro as a C expression which is nonzero if C is
++used as a logical line separator by the assembler.
++
++If you do not define this macro, the default is that only
++the character ';' is treated as a logical line separator.
++*/
++#define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == '\n')
++
++
++/** Output of Uninitialized Variables **/
++
++/*
++A C statement (sans semicolon) to output to the stdio stream
++STREAM the assembler definition of a common-label named
++NAME whose size is SIZE bytes.  The variable ROUNDED
++is the size rounded up to whatever alignment the caller wants.
++
++Use the expression assemble_name(STREAM, NAME) to
++output the name itself; before and after that, output the additional
++assembler syntax for defining the name, and a newline.
++
++This macro controls how the assembler definitions of uninitialized
++common global variables are output.
++*/
++/*
++#define ASM_OUTPUT_COMMON(STREAM, NAME, SIZE, ROUNDED) \
++  avr32_asm_output_common(STREAM, NAME, SIZE, ROUNDED)
++*/
++
++#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
++  do                                                  \
++    {                                                 \
++      fputs ("\t.comm ", (FILE));                     \
++      assemble_name ((FILE), (NAME));                 \
++      fprintf ((FILE), ",%d\n", (SIZE));              \
++    }                                                 \
++  while (0)
++
++/*
++ * Like ASM_OUTPUT_BSS except takes the required alignment as a
++ * separate, explicit argument.  If you define this macro, it is used
++ * in place of ASM_OUTPUT_BSS, and gives you more flexibility in
++ * handling the required alignment of the variable.  The alignment is
++ * specified as the number of bits.
++ *
++ * Try to use function asm_output_aligned_bss defined in file varasm.c
++ * when defining this macro.
++ */
++#define ASM_OUTPUT_ALIGNED_BSS(STREAM, DECL, NAME, SIZE, ALIGNMENT) \
++  asm_output_aligned_bss (STREAM, DECL, NAME, SIZE, ALIGNMENT)
++
++/*
++A C statement (sans semicolon) to output to the stdio stream
++STREAM the assembler definition of a local-common-label named
++NAME whose size is SIZE bytes.  The variable ROUNDED
++is the size rounded up to whatever alignment the caller wants.
++
++Use the expression assemble_name(STREAM, NAME) to
++output the name itself; before and after that, output the additional
++assembler syntax for defining the name, and a newline.
++
++This macro controls how the assembler definitions of uninitialized
++static variables are output.
++*/
++#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)   \
++  do                                                  \
++    {                                                 \
++      fputs ("\t.lcomm ", (FILE));                    \
++      assemble_name ((FILE), (NAME));                 \
++      fprintf ((FILE), ",%d, %d\n", (SIZE), 2);               \
++    }                                                 \
++  while (0)
++
++
++/*
++A C statement (sans semicolon) to output to the stdio stream
++STREAM the assembler definition of a label named NAME.
++Use the expression assemble_name(STREAM, NAME) to
++output the name itself; before and after that, output the additional
++assembler syntax for defining the name, and a newline.
++*/
++#define ASM_OUTPUT_LABEL(STREAM, NAME) avr32_asm_output_label(STREAM, NAME)
++
++/* A C string containing the appropriate assembler directive to
++ * specify the size of a symbol, without any arguments. On systems
++ * that use ELF, the default (in 'config/elfos.h') is '"\t.size\t"';
++ * on other systems, the default is not to define this macro.
++ *
++ * Define this macro only if it is correct to use the default
++ * definitions of ASM_ OUTPUT_SIZE_DIRECTIVE and
++ * ASM_OUTPUT_MEASURED_SIZE for your system. If you need your own
++ * custom definitions of those macros, or if you do not need explicit
++ * symbol sizes at all, do not define this macro.
++ */
++#define SIZE_ASM_OP "\t.size\t"
++
++
++/*
++A C statement (sans semicolon) to output to the stdio stream
++STREAM some commands that will make the label NAME global;
++that is, available for reference from other files.  Use the expression
++assemble_name(STREAM, NAME) to output the name
++itself; before and after that, output the additional assembler syntax
++for making that name global, and a newline.
++*/
++#define GLOBAL_ASM_OP "\t.globl\t"
++
++
++
++/*
++A C expression which evaluates to true if the target supports weak symbols.
++
++If you don't define this macro, defaults.h provides a default
++definition.  If either ASM_WEAKEN_LABEL or ASM_WEAKEN_DECL
++is defined, the default definition is '1'; otherwise, it is
++'0'.  Define this macro if you want to control weak symbol support
++with a compiler flag such as -melf.
++*/
++#define SUPPORTS_WEAK 1
++
++/*
++A C statement (sans semicolon) to output to the stdio stream
++STREAM a reference in assembler syntax to a label named
++NAME.  This should add '_' to the front of the name, if that
++is customary on your operating system, as it is in most Berkeley Unix
++systems.  This macro is used in assemble_name.
++*/
++#define ASM_OUTPUT_LABELREF(STREAM, NAME) \
++  avr32_asm_output_labelref(STREAM, NAME)
++
++
++
++/*
++A C expression to assign to OUTVAR (which is a variable of type
++char *) a newly allocated string made from the string
++NAME and the number NUMBER, with some suitable punctuation
++added.  Use alloca to get space for the string.
++
++The string will be used as an argument to ASM_OUTPUT_LABELREF to
++produce an assembler label for an internal static variable whose name is
++NAME.  Therefore, the string must be such as to result in valid
++assembler code.  The argument NUMBER is different each time this
++macro is executed; it prevents conflicts between similarly-named
++internal static variables in different scopes.
++
++Ideally this string should not be a valid C identifier, to prevent any
++conflict with the user's own symbols.  Most assemblers allow periods
++or percent signs in assembler symbols; putting at least one of these
++between the name and the number will suffice.
++*/
++#define ASM_FORMAT_PRIVATE_NAME(OUTVAR, NAME, NUMBER)         \
++  do                                                          \
++    {                                                         \
++      (OUTVAR) = (char *) alloca (strlen ((NAME)) + 10);      \
++      sprintf ((OUTVAR), "%s.%d", (NAME), (NUMBER));          \
++    }                                                         \
++  while (0)
++
++
++/** Macros Controlling Initialization Routines **/
++
++
++/*
++If defined, main will not call __main as described above.
++This macro should be defined for systems that control start-up code
++on a symbol-by-symbol basis, such as OSF/1, and should not
++be defined explicitly for systems that support INIT_SECTION_ASM_OP.
++*/
++/*
++  __main is not defined when debugging.
++*/
++#define HAS_INIT_SECTION
++
++
++/** Output of Assembler Instructions **/
++
++/*
++A C initializer containing the assembler's names for the machine
++registers, each one as a C string constant.  This is what translates
++register numbers in the compiler into assembler language.
++*/
++
++#define REGISTER_NAMES        \
++{                     \
++  "pc",  "lr",                \
++  "sp",  "r12",               \
++  "r11", "r10",               \
++  "r9",  "r8",                \
++  "r7",  "r6",                \
++  "r5",  "r4",                \
++  "r3",  "r2",                \
++  "r1",  "r0",                \
++  "f15","f14",                \
++  "f13","f12",                \
++  "f11","f10",                \
++  "f9", "f8",         \
++  "f7", "f6",         \
++  "f5", "f4",         \
++  "f3", "f2",         \
++  "f1", "f0"          \
++}
++
++/*
++A C compound statement to output to stdio stream STREAM the
++assembler syntax for an instruction operand X.  X is an
++RTL expression.
++
++CODE is a value that can be used to specify one of several ways
++of printing the operand.  It is used when identical operands must be
++printed differently depending on the context.  CODE comes from
++the '%' specification that was used to request printing of the
++operand.  If the specification was just '%digit' then
++CODE is 0; if the specification was '%ltr digit'
++then CODE is the ASCII code for ltr.
++
++If X is a register, this macro should print the register's name.
++The names can be found in an array reg_names whose type is
++char *[].  reg_names is initialized from REGISTER_NAMES.
++
++When the machine description has a specification '%punct'
++(a '%' followed by a punctuation character), this macro is called
++with a null pointer for X and the punctuation character for
++CODE.
++*/
++#define PRINT_OPERAND(STREAM, X, CODE) avr32_print_operand(STREAM, X, CODE)
++
++/* A C statement to be executed just prior to the output of
++   assembler code for INSN, to modify the extracted operands so
++   they will be output differently.
++
++   Here the argument OPVEC is the vector containing the operands
++   extracted from INSN, and NOPERANDS is the number of elements of
++   the vector which contain meaningful data for this insn.
++   The contents of this vector are what will be used to convert the insn
++   template into assembler code, so you can change the assembler output
++   by changing the contents of the vector.  */
++#define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) \
++  avr32_final_prescan_insn ((INSN), (OPVEC), (NOPERANDS))
++
++/*
++A C expression which evaluates to true if CODE is a valid
++punctuation character for use in the PRINT_OPERAND macro.  If
++PRINT_OPERAND_PUNCT_VALID_P is not defined, it means that no
++punctuation characters (except for the standard one, '%') are used
++in this way.
++*/
++/*
++  'm' refers to the most significant word in a two-register mode.
++*/
++#define PRINT_OPERAND_PUNCT_VALID_P(CODE) ((CODE) == 'm' || (CODE) == 'e')
++
++/*
++A C compound statement to output to stdio stream STREAM the
++assembler syntax for an instruction operand that is a memory reference
++whose address is X.  X is an RTL expression.
++
++On some machines, the syntax for a symbolic address depends on the
++section that the address refers to.  On these machines, define the macro
++ENCODE_SECTION_INFO to store the information into the
++symbol_ref, and then check for it here.  (see Assembler Format.)
++*/
++#define PRINT_OPERAND_ADDRESS(STREAM, X) avr32_print_operand_address(STREAM, X)
++
++
++/** Output of Dispatch Tables **/
++
++/*
++ * A C statement to output to the stdio stream stream an assembler
++ * pseudo-instruction to generate a difference between two
++ * labels. value and rel are the numbers of two internal labels. The
++ * definitions of these labels are output using
++ * (*targetm.asm_out.internal_label), and they must be printed in the
++ * same way here. For example,
++ *
++ *         fprintf (stream, "\t.word L%d-L%d\n",
++ *                  value, rel)
++ *
++ * You must provide this macro on machines where the addresses in a
++ * dispatch table are relative to the table's own address. If defined,
++ * GCC will also use this macro on all machines when producing
++ * PIC. body is the body of the ADDR_DIFF_VEC; it is provided so that
++ * the mode and flags can be read.
++ */
++#define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL)        \
++    fprintf(STREAM, "\tbral\t%sL%d\n", LOCAL_LABEL_PREFIX, VALUE)
++
++/*
++This macro should be provided on machines where the addresses
++in a dispatch table are absolute.
++
++The definition should be a C statement to output to the stdio stream
++STREAM an assembler pseudo-instruction to generate a reference to
++a label.  VALUE is the number of an internal label whose
++definition is output using ASM_OUTPUT_INTERNAL_LABEL.
++For example,
++
++fprintf(STREAM, "\t.word L%d\n", VALUE)
++*/
++
++#define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE)  \
++  fprintf(STREAM, "\t.long %sL%d\n", LOCAL_LABEL_PREFIX, VALUE)
++
++/** Assembler Commands for Exception Regions */
++
++/* ToDo: All of this subsection */
++
++/** Assembler Commands for Alignment */
++
++
++/*
++A C statement to output to the stdio stream STREAM an assembler
++command to advance the location counter to a multiple of 2 to the
++POWER bytes.  POWER will be a C expression of type int.
++*/
++#define ASM_OUTPUT_ALIGN(STREAM, POWER)                       \
++  do                                                  \
++    {                                                 \
++      if ((POWER) != 0)                                       \
++      fprintf(STREAM, "\t.align\t%d\n", POWER);       \
++    }                                                 \
++  while (0)
++
++/*
++Like ASM_OUTPUT_ALIGN, except that the \nop" instruction is used for padding, if
++necessary.
++*/
++#define ASM_OUTPUT_ALIGN_WITH_NOP(STREAM, POWER) \
++ fprintf(STREAM, "\t.balignw\t%d, 0xd703\n", (1 << POWER))
++
++
++
++/******************************************************************************
++ * Controlling Debugging Information Format
++ *****************************************************************************/
++
++/* How to renumber registers for dbx and gdb.  */
++#define DBX_REGISTER_NUMBER(REGNO) ASM_REGNUM (REGNO)
++
++/* The DWARF 2 CFA column which tracks the return address.  */
++#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM(LR_REGNUM)
++
++/*
++Define this macro if GCC should produce dwarf version 2 format
++debugging output in response to the -g option.
++
++To support optional call frame debugging information, you must also
++define INCOMING_RETURN_ADDR_RTX and either set
++RTX_FRAME_RELATED_P on the prologue insns if you use RTL for the
++prologue, or call dwarf2out_def_cfa and dwarf2out_reg_save
++as appropriate from TARGET_ASM_FUNCTION_PROLOGUE if you don't.
++*/
++#define DWARF2_DEBUGGING_INFO 1
++
++
++#define DWARF2_ASM_LINE_DEBUG_INFO 1
++#define DWARF2_FRAME_INFO 1
++
++
++/******************************************************************************
++ * Miscellaneous Parameters
++ *****************************************************************************/
++
++/* ToDo: a lot */
++
++/*
++An alias for a machine mode name.  This is the machine mode that
++elements of a jump-table should have.
++*/
++#define CASE_VECTOR_MODE SImode
++
++/*
++Define this macro to be a C expression to indicate when jump-tables
++should contain relative addresses.  If jump-tables never contain
++relative addresses, then you need not define this macro.
++*/
++#define CASE_VECTOR_PC_RELATIVE 0
++
++/*
++The maximum number of bytes that a single instruction can move quickly
++between memory and registers or between two memory locations.
++*/
++#define MOVE_MAX (2*UNITS_PER_WORD)
++
++
++/* A C expression that is nonzero if on this machine the number of bits actually used
++   for the count of a shift operation is equal to the number of bits needed to represent
++   the size of the object being shifted. When this macro is nonzero, the compiler will
++   assume that it is safe to omit a sign-extend, zero-extend, and certain bitwise 'and'
++   instructions that truncates the count of a shift operation. On machines that have
++   instructions that act on bit-fields at variable positions, which may include 'bit test'
++   378 GNU Compiler Collection (GCC) Internals
++   instructions, a nonzero SHIFT_COUNT_TRUNCATED also enables deletion of truncations
++   of the values that serve as arguments to bit-field instructions.
++   If both types of instructions truncate the count (for shifts) and position (for bit-field
++   operations), or if no variable-position bit-field instructions exist, you should define
++   this macro.
++   However, on some machines, such as the 80386 and the 680x0, truncation only applies
++   to shift operations and not the (real or pretended) bit-field operations. Define SHIFT_
++   COUNT_TRUNCATED to be zero on such machines. Instead, add patterns to the 'md' file
++   that include the implied truncation of the shift instructions.
++   You need not de\fne this macro if it would always have the value of zero. */
++#define SHIFT_COUNT_TRUNCATED 1
++
++/*
++A C expression which is nonzero if on this machine it is safe to
++convert an integer of INPREC bits to one of OUTPREC
++bits (where OUTPREC is smaller than INPREC) by merely
++operating on it as if it had only OUTPREC bits.
++
++On many machines, this expression can be 1.
++
++When TRULY_NOOP_TRUNCATION returns 1 for a pair of sizes for
++modes for which MODES_TIEABLE_P is 0, suboptimal code can result.
++If this is the case, making TRULY_NOOP_TRUNCATION return 0 in
++such cases may improve things.
++*/
++#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
++
++/*
++An alias for the machine mode for pointers.  On most machines, define
++this to be the integer mode corresponding to the width of a hardware
++pointer; SImode on 32-bit machine or DImode on 64-bit machines.
++On some machines you must define this to be one of the partial integer
++modes, such as PSImode.
++
++The width of Pmode must be at least as large as the value of
++POINTER_SIZE.  If it is not equal, you must define the macro
++POINTERS_EXTEND_UNSIGNED to specify how pointers are extended
++to Pmode.
++*/
++#define Pmode SImode
++
++/*
++An alias for the machine mode used for memory references to functions
++being called, in call RTL expressions.  On most machines this
++should be QImode.
++*/
++#define FUNCTION_MODE SImode
++
++
++#define REG_S_P(x) \
++ (REG_P (x) || (GET_CODE (x) == SUBREG && REG_P (XEXP (x, 0))))
++
++
++/* If defined, modifies the length assigned to instruction INSN as a
++   function of the context in which it is used.  LENGTH is an lvalue
++   that contains the initially computed length of the insn and should
++   be updated with the correct length of the insn.  */
++#define ADJUST_INSN_LENGTH(INSN, LENGTH) \
++  ((LENGTH) = avr32_adjust_insn_length ((INSN), (LENGTH)))
++
++
++#define CLZ_DEFINED_VALUE_AT_ZERO(mode, value) \
++  (value = 32, (mode == SImode))
++
++#define CTZ_DEFINED_VALUE_AT_ZERO(mode, value) \
++  (value = 32, (mode == SImode))
++
++#define UNITS_PER_SIMD_WORD UNITS_PER_WORD
++
++#define STORE_FLAG_VALUE 1
++
++enum avr32_builtins
++{
++  AVR32_BUILTIN_MTSR,
++  AVR32_BUILTIN_MFSR,
++  AVR32_BUILTIN_MTDR,
++  AVR32_BUILTIN_MFDR,
++  AVR32_BUILTIN_CACHE,
++  AVR32_BUILTIN_SYNC,
++  AVR32_BUILTIN_TLBR,
++  AVR32_BUILTIN_TLBS,
++  AVR32_BUILTIN_TLBW,
++  AVR32_BUILTIN_BREAKPOINT,
++  AVR32_BUILTIN_XCHG,
++  AVR32_BUILTIN_LDXI,
++  AVR32_BUILTIN_BSWAP16,
++  AVR32_BUILTIN_BSWAP32,
++  AVR32_BUILTIN_COP,
++  AVR32_BUILTIN_MVCR_W,
++  AVR32_BUILTIN_MVRC_W,
++  AVR32_BUILTIN_MVCR_D,
++  AVR32_BUILTIN_MVRC_D,
++  AVR32_BUILTIN_MULSATHH_H,
++  AVR32_BUILTIN_MULSATHH_W,
++  AVR32_BUILTIN_MULSATRNDHH_H,
++  AVR32_BUILTIN_MULSATRNDWH_W,
++  AVR32_BUILTIN_MULSATWH_W,
++  AVR32_BUILTIN_MACSATHH_W,
++  AVR32_BUILTIN_SATADD_H,
++  AVR32_BUILTIN_SATSUB_H,
++  AVR32_BUILTIN_SATADD_W,
++  AVR32_BUILTIN_SATSUB_W,
++  AVR32_BUILTIN_MULWH_D,
++  AVR32_BUILTIN_MULNWH_D,
++  AVR32_BUILTIN_MACWH_D,
++  AVR32_BUILTIN_MACHH_D,
++  AVR32_BUILTIN_MUSFR,
++  AVR32_BUILTIN_MUSTR,
++  AVR32_BUILTIN_SATS,
++  AVR32_BUILTIN_SATU,
++  AVR32_BUILTIN_SATRNDS,
++  AVR32_BUILTIN_SATRNDU
++};
++
++
++#define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) \
++  ((MODE == SFmode) || (MODE == DFmode))
++
++#define RENAME_LIBRARY_SET ".set"
++
++/* Make ABI_NAME an alias for __GCC_NAME.  */
++#define RENAME_LIBRARY(GCC_NAME, ABI_NAME)            \
++  __asm__ (".globl\t__avr32_" #ABI_NAME "\n"          \
++         ".set\t__avr32_" #ABI_NAME   \
++           ", __" #GCC_NAME "\n");
++
++/* Give libgcc functions avr32 ABI name.  */
++#ifdef L_muldi3
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (muldi3, mul64)
++#endif
++#ifdef L_divdi3
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (divdi3, sdiv64)
++#endif
++#ifdef L_udivdi3
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (udivdi3, udiv64)
++#endif
++#ifdef L_moddi3
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (moddi3, smod64)
++#endif
++#ifdef L_umoddi3
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (umoddi3, umod64)
++#endif
++#ifdef L_ashldi3
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (ashldi3, lsl64)
++#endif
++#ifdef L_lshrdi3
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (lshrdi3, lsr64)
++#endif
++#ifdef L_ashrdi3
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (ashrdi3, asr64)
++#endif
++
++#ifdef L_fixsfdi
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (fixsfdi, f32_to_s64)
++#endif
++#ifdef L_fixunssfdi
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (fixunssfdi, f32_to_u64)
++#endif
++#ifdef L_floatdidf
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (floatdidf, s64_to_f64)
++#endif
++#ifdef L_floatdisf
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (floatdisf, s64_to_f32)
++#endif
++
++#ifdef L_addsub_sf
++#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (addsf3, f32_add); RENAME_LIBRARY (subsf3, f32_sub)
++#endif
++
++#endif
+diff -Nur gcc-4.1.2/gcc/config/avr32/avr32.md gcc-4.1.2-owrt/gcc/config/avr32/avr32.md
+--- gcc-4.1.2/gcc/config/avr32/avr32.md        1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/avr32.md   2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,4694 @@
++;;   AVR32 machine description file.
++;;   Copyright 2003-2006 Atmel Corporation.
++;;
++;;   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++;;
++;;   This file is part of GCC.
++;;
++;;   This program is free software; you can redistribute it and/or modify
++;;   it under the terms of the GNU General Public License as published by
++;;   the Free Software Foundation; either version 2 of the License, or
++;;   (at your option) any later version.
++;;
++;;   This program is distributed in the hope that it will be useful,
++;;   but WITHOUT ANY WARRANTY; without even the implied warranty of
++;;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++;;   GNU General Public License for more details.
++;;
++;;   You should have received a copy of the GNU General Public License
++;;   along with this program; if not, write to the Free Software
++;;   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++
++;; -*- Mode: Scheme -*-
++
++(define_attr "type" "alu,alu2,alu_sat,mulhh,mulwh,mulww_w,mulww_d,div,machh_w,macww_w,macww_d,branch,call,load,load_rm,store,load2,load4,store2,store4,fmul,fcmps,fcmpd,fcast,fmv,fmvcpu,fldd,fstd,flds,fsts,fstm"
++  (const_string "alu"))
++
++
++(define_attr "cc" "none,set_vncz,set_ncz,set_cz,set_z,bld,compare,clobber,call_set,fpcompare,from_fpcc"
++  (const_string "none"))
++
++
++(define_attr "pipeline" "ap,uc"
++  (const_string "ap"))
++
++(define_attr "length" ""
++  (const_int 4))
++
++
++;; Uses of UNSPEC in this file:
++(define_constants
++  [(UNSPEC_PUSHM                0)
++   (UNSPEC_POPM                 1)
++   (UNSPEC_UDIVMODSI4_INTERNAL        2)
++   (UNSPEC_DIVMODSI4_INTERNAL   3)
++   (UNSPEC_STM                  4)
++   (UNSPEC_LDM                  5)
++   (UNSPEC_MOVSICC              6)
++   (UNSPEC_ADDSICC              7)
++   (UNSPEC_COND_MI              8)
++   (UNSPEC_COND_PL              9)
++   (UNSPEC_PIC_SYM              10)
++   (UNSPEC_PIC_BASE             11)
++   (UNSPEC_STORE_MULTIPLE       12)
++   (UNSPEC_STMFP                13)
++   (UNSPEC_FPCC_TO_REG          14)
++   (UNSPEC_REG_TO_CC            15)
++   (UNSPEC_FORCE_MINIPOOL       16)
++   (UNSPEC_SATS                 17)
++   (UNSPEC_SATU                 18)
++   (UNSPEC_SATRNDS              19)
++   (UNSPEC_SATRNDU              20)
++  ])
++
++(define_constants
++  [(VUNSPEC_EPILOGUE   0)
++   (VUNSPEC_CACHE      1)
++   (VUNSPEC_MTSR       2)
++   (VUNSPEC_MFSR       3)
++   (VUNSPEC_BLOCKAGE   4)
++   (VUNSPEC_SYNC       5)
++   (VUNSPEC_TLBR       6)
++   (VUNSPEC_TLBW       7)
++   (VUNSPEC_TLBS       8)
++   (VUNSPEC_BREAKPOINT 9)
++   (VUNSPEC_MTDR       10)
++   (VUNSPEC_MFDR       11)
++   (VUNSPEC_MVCR       12)
++   (VUNSPEC_MVRC       13)
++   (VUNSPEC_COP        14)
++   (VUNSPEC_ALIGN      15)
++   (VUNSPEC_POOL_START 16)
++   (VUNSPEC_POOL_END   17)
++   (VUNSPEC_POOL_4     18)
++   (VUNSPEC_POOL_8     19)
++   (VUNSPEC_MUSFR      20)
++   (VUNSPEC_MUSTR       21)
++   ])
++
++(define_constants
++  [
++   ;; R7 = 15-7 = 8
++   (FP_REGNUM   8)
++   ;; Return Register = R12 = 15 - 12 = 3
++   (RETVAL_REGNUM   3)
++   ;; SP = R13 = 15 - 13 = 2
++   (SP_REGNUM   2)
++   ;; LR = R14 = 15 - 14 = 1
++   (LR_REGNUM   1)
++   ;; PC = R15 = 15 - 15 = 0
++   (PC_REGNUM   0)
++   ;; FPSR = GENERAL_REGS + 1 = 17
++   (FPCC_REGNUM 17)
++   ])
++
++
++
++
++;;******************************************************************************
++;; Macros
++;;******************************************************************************
++
++;; Integer Modes for basic alu insns
++(define_mode_macro INTM [SI HI QI])
++(define_mode_attr  alu_cc_attr [(SI "set_vncz") (HI "clobber") (QI "clobber")])
++
++;; Move word modes
++(define_mode_macro MOVM [SI V2HI V4QI])
++
++;; For mov/addcc insns
++(define_mode_macro ADDCC [SI HI QI])
++(define_mode_macro MOVCC [SI HI QI])
++(define_mode_macro CMP [DI SI HI QI])
++(define_mode_attr  cmp_constraint [(DI "r") (SI "rKs21") (HI "r") (QI "r")])
++(define_mode_attr  cmp_predicate [(DI "register_operand")
++                                  (SI "register_immediate_operand")
++                                  (HI "register_operand")
++                                  (QI "register_operand")])
++
++;; For all conditional insns
++(define_code_macro any_cond [eq ne gt ge lt le gtu geu ltu leu])
++(define_code_attr cond [(eq "eq") (ne "ne") (gt "gt") (ge "ge") (lt "lt") (le "le")
++                        (gtu "hi") (geu "hs") (ltu "lo") (leu "ls")])
++(define_code_attr invcond [(eq "ne") (ne "eq") (gt "le") (ge "lt") (lt "ge") (le "gt")
++                           (gtu "ls") (geu "lo") (ltu "hs") (leu "hi")])
++
++;; For logical operations
++(define_code_macro logical [and ior xor])
++(define_code_attr logical_insn [(and "and") (ior "or") (xor "eor")])
++
++;; Load the predicates
++(include "predicates.md")
++
++
++;;******************************************************************************
++;; Automaton pipeline description for avr32
++;;******************************************************************************
++
++(define_automaton "avr32_ap")
++
++
++(define_cpu_unit "is" "avr32_ap")
++(define_cpu_unit "a1,m1,da" "avr32_ap")
++(define_cpu_unit "a2,m2,d" "avr32_ap")
++
++;;Alu instructions
++(define_insn_reservation "alu_op" 1
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "alu"))
++  "is,a1,a2")
++
++(define_insn_reservation "alu2_op" 2
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "alu2"))
++  "is,is+a1,a1+a2,a2")
++
++(define_insn_reservation "alu_sat_op" 2
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "alu_sat"))
++  "is,a1,a2")
++
++
++;;Mul instructions
++(define_insn_reservation "mulhh_op" 2
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "mulhh,mulwh"))
++  "is,m1,m2")
++
++(define_insn_reservation "mulww_w_op" 3
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "mulww_w"))
++  "is,m1,m1+m2,m2")
++
++(define_insn_reservation "mulww_d_op" 5
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "mulww_d"))
++  "is,m1,m1+m2,m1+m2,m2,m2")
++
++(define_insn_reservation "div_op" 33
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "div"))
++  "is,m1,m1*31 + m2*31,m2")
++
++(define_insn_reservation "machh_w_op" 3
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "machh_w"))
++  "is*2,m1,m2")
++
++
++(define_insn_reservation "macww_w_op" 4
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "macww_w"))
++  "is*2,m1,m1,m2")
++
++
++(define_insn_reservation "macww_d_op" 6
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "macww_d"))
++  "is*2,m1,m1+m2,m1+m2,m2")
++
++;;Bypasses for Mac instructions, because of accumulator cache.
++;;Set latency as low as possible in order to let the compiler let
++;;mul -> mac and mac -> mac combinations which use the same
++;;accumulator cache be placed close together to avoid any
++;;instructions which can ruin the accumulator cache come inbetween.
++(define_bypass 4 "machh_w_op" "alu_op,alu2_op,alu_sat_op,load_op" "avr32_mul_waw_bypass")
++(define_bypass 5 "macww_w_op" "alu_op,alu2_op,alu_sat_op,load_op" "avr32_mul_waw_bypass")
++(define_bypass 7 "macww_d_op" "alu_op,alu2_op,alu_sat_op,load_op" "avr32_mul_waw_bypass")
++
++(define_bypass 3 "mulhh_op" "alu_op,alu2_op,alu_sat_op,load_op" "avr32_mul_waw_bypass")
++(define_bypass 4 "mulww_w_op" "alu_op,alu2_op,alu_sat_op,load_op" "avr32_mul_waw_bypass")
++(define_bypass 6 "mulww_d_op" "alu_op,alu2_op,alu_sat_op,load_op" "avr32_mul_waw_bypass")
++
++
++;;Bypasses for all mul/mac instructions followed by an instruction
++;;which reads the output AND writes the result to the same register.
++;;This will generate an Write After Write hazard which gives an
++;;extra cycle before the result is ready.
++(define_bypass 0 "machh_w_op" "machh_w_op" "avr32_valid_macmac_bypass")
++(define_bypass 0 "macww_w_op" "macww_w_op" "avr32_valid_macmac_bypass")
++(define_bypass 0 "macww_d_op" "macww_d_op" "avr32_valid_macmac_bypass")
++
++(define_bypass 0 "mulhh_op" "machh_w_op" "avr32_valid_mulmac_bypass")
++(define_bypass 0 "mulww_w_op" "macww_w_op" "avr32_valid_mulmac_bypass")
++(define_bypass 0 "mulww_d_op" "macww_d_op" "avr32_valid_mulmac_bypass")
++
++;;Branch and call instructions
++;;We assume that all branches and rcalls are predicted correctly :-)
++;;while calls use a lot of cycles.
++(define_insn_reservation "branch_op" 0
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "branch"))
++  "nothing")
++
++(define_insn_reservation "call_op" 10
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "call"))
++  "nothing")
++
++
++;;Load store instructions
++(define_insn_reservation "load_op" 2
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "load"))
++  "is,da,d")
++
++(define_insn_reservation "load_rm_op" 3
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "load_rm"))
++  "is,da,d")
++
++
++(define_insn_reservation "store_op" 0
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "store"))
++  "is,da,d")
++
++
++(define_insn_reservation "load_double_op" 3
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "load2"))
++  "is,da,da+d,d")
++
++(define_insn_reservation "load_quad_op" 4
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "load4"))
++  "is,da,da+d,da+d,d")
++
++(define_insn_reservation "store_double_op" 0
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "store2"))
++  "is,da,da+d,d")
++
++
++(define_insn_reservation "store_quad_op" 0
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "store4"))
++  "is,da,da+d,da+d,d")
++
++;;For store the operand to write to memory is read in d and
++;;the real latency between any instruction and a store is therefore
++;;one less than for the instructions which reads the operands in the first
++;;excecution stage
++(define_bypass 2 "load_double_op" "store_double_op" "avr32_store_bypass")
++(define_bypass 3 "load_quad_op" "store_quad_op" "avr32_store_bypass")
++(define_bypass 1 "load_op" "store_op" "avr32_store_bypass")
++(define_bypass 2 "load_rm_op" "store_op" "avr32_store_bypass")
++(define_bypass 1 "alu_sat_op" "store_op" "avr32_store_bypass")
++(define_bypass 1 "alu2_op" "store_op" "avr32_store_bypass")
++(define_bypass 1 "mulhh_op" "store_op" "avr32_store_bypass")
++(define_bypass 2 "mulww_w_op" "store_op" "avr32_store_bypass")
++(define_bypass 4 "mulww_d_op" "store_op" "avr32_store_bypass" )
++(define_bypass 2 "machh_w_op" "store_op" "avr32_store_bypass")
++(define_bypass 3 "macww_w_op" "store_op" "avr32_store_bypass")
++(define_bypass 5 "macww_d_op" "store_op" "avr32_store_bypass")
++
++
++; Bypass for load double operation. If only the first loaded word is needed
++; then the latency is 2
++(define_bypass 2 "load_double_op"
++                 "load_op,load_rm_op,alu_sat_op, alu2_op, alu_op, mulhh_op, mulww_w_op,
++                  mulww_d_op, machh_w_op, macww_w_op, macww_d_op"
++                 "avr32_valid_load_double_bypass")
++
++; Bypass for load quad operation. If only the first or second loaded word is needed
++; we set the latency to 2
++(define_bypass 2 "load_quad_op"
++                 "load_op,load_rm_op,alu_sat_op, alu2_op, alu_op, mulhh_op, mulww_w_op,
++                  mulww_d_op, machh_w_op, macww_w_op, macww_d_op"
++                 "avr32_valid_load_quad_bypass")
++
++
++;;******************************************************************************
++;; End of Automaton pipeline description for avr32
++;;******************************************************************************
++
++
++
++;;=============================================================================
++;; move
++;;-----------------------------------------------------------------------------
++
++;;== char - 8 bits ============================================================
++(define_expand "movqi"
++  [(set (match_operand:QI 0 "nonimmediate_operand" "")
++      (match_operand:QI 1 "general_operand" ""))]
++  ""
++  {
++   if ( !no_new_pseudos ){
++     if (GET_CODE (operands[1]) == MEM && optimize){
++         rtx reg = gen_reg_rtx (SImode);
++
++         emit_insn (gen_zero_extendqisi2 (reg, operands[1]));
++         operands[1] = gen_lowpart (QImode, reg);
++     }
++
++     /* One of the ops has to be in a register.  */
++     if (GET_CODE (operands[0]) == MEM)
++       operands[1] = force_reg (QImode, operands[1]);
++   }
++
++  })
++
++(define_insn "*movqi_internal"
++  [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r")
++      (match_operand:QI 1 "general_operand"  "rKs08,m,r,i"))]
++  ""
++  "@
++   mov\t%0, %1
++   ld.ub\t%0, %1
++   st.b\t%0, %1
++   mov\t%0, %1"
++  [(set_attr "length" "2,4,4,4")
++   (set_attr "type" "alu,load_rm,store,alu")])
++
++
++
++;;== short - 16 bits ==========================================================
++(define_expand "movhi"
++  [(set (match_operand:HI 0 "nonimmediate_operand" "")
++      (match_operand:HI 1 "general_operand" ""))]
++  ""
++  {
++   if ( !no_new_pseudos ){
++     if (GET_CODE (operands[1]) == MEM && optimize){
++         rtx reg = gen_reg_rtx (SImode);
++
++         emit_insn (gen_extendhisi2 (reg, operands[1]));
++         operands[1] = gen_lowpart (HImode, reg);
++     }
++
++     /* One of the ops has to be in a register.  */
++     if (GET_CODE (operands[0]) == MEM)
++       operands[1] = force_reg (HImode, operands[1]);
++   }
++
++  })
++
++(define_insn "*movhi_internal"
++  [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r")
++      (match_operand:HI 1 "general_operand"  "rKs08,m,r,i"))]
++  ""
++  "@
++   mov\t%0, %1
++   ld.sh\t%0, %1
++   st.h\t%0, %1
++   mov\t%0, %1"
++  [(set_attr "length" "2,4,4,4")
++   (set_attr "type" "alu,load_rm,store,alu")])
++
++
++;;== int - 32 bits ============================================================
++
++(define_expand "movmisalignsi"
++  [(set (match_operand:SI 0 "nonimmediate_operand" "")
++      (match_operand:SI 1 "nonimmediate_operand" ""))]
++  "TARGET_UNALIGNED_WORD"
++  {
++  }
++)
++
++(define_expand "mov<mode>"
++  [(set (match_operand:MOVM 0 "nonimmediate_operand" "")
++      (match_operand:MOVM 1 "general_operand" ""))]
++  ""
++  {
++
++    /* One of the ops has to be in a register.  */
++    if (GET_CODE (operands[0]) == MEM)
++      operands[1] = force_reg (<MODE>mode, operands[1]);
++
++
++    /* Check for out of range immediate constants as these may
++       occur during reloading, since it seems like reload does
++       not check if the immediate is legitimate. Don't know if
++       this is a bug? */
++    if ( reload_in_progress
++         && GET_CODE(operands[1]) == CONST_INT
++         && !avr32_const_ok_for_constraint_p(INTVAL(operands[1]), 'K', "Ks21") ){
++        operands[1] = force_const_mem(SImode, operands[1]);
++    }
++
++    if ( (flag_pic || TARGET_HAS_ASM_ADDR_PSEUDOS)
++         && !avr32_legitimate_pic_operand_p(operands[1]) )
++      operands[1] = legitimize_pic_address (operands[1], <MODE>mode,
++                                            (no_new_pseudos ? operands[0] : 0));
++    else if ( flag_pic && avr32_address_operand(operands[1], GET_MODE(operands[1])) )
++      /* If we have an address operand then this function uses the pic register. */
++      current_function_uses_pic_offset_table = 1;
++  })
++
++
++(define_insn "mov<mode>_internal"
++  [(set (match_operand:MOVM 0 "nonimmediate_operand"     "=r,r,r,m,r")
++      (match_operand:MOVM 1 "general_operand"  "rKs08,Ks21,m,r,W"))]
++  ""
++  {
++    switch (which_alternative) {
++      case 0:
++      case 1: return "mov\t%0, %1";
++      case 2:
++        if ( (REG_P(XEXP(operands[1], 0))
++              && REGNO(XEXP(operands[1], 0)) == SP_REGNUM)
++             || (GET_CODE(XEXP(operands[1], 0)) == PLUS
++                 && REGNO(XEXP(XEXP(operands[1], 0), 0)) == SP_REGNUM
++               && GET_CODE(XEXP(XEXP(operands[1], 0), 1)) == CONST_INT
++               && INTVAL(XEXP(XEXP(operands[1], 0), 1)) % 4 == 0
++               && INTVAL(XEXP(XEXP(operands[1], 0), 1)) <= 0x1FC) )
++          return "lddsp\t%0, %1";
++      else if ( avr32_const_pool_ref_operand(operands[1], GET_MODE(operands[1])) )
++          return "lddpc\t%0, %1";
++        else
++          return "ld.w\t%0, %1";
++      case 3:
++        if ( (REG_P(XEXP(operands[0], 0))
++              && REGNO(XEXP(operands[0], 0)) == SP_REGNUM)
++             || (GET_CODE(XEXP(operands[0], 0)) == PLUS
++                 && REGNO(XEXP(XEXP(operands[0], 0), 0)) == SP_REGNUM
++               && GET_CODE(XEXP(XEXP(operands[0], 0), 1)) == CONST_INT
++               && INTVAL(XEXP(XEXP(operands[0], 0), 1)) % 4 == 0
++               && INTVAL(XEXP(XEXP(operands[0], 0), 1)) <= 0x1FC) )
++          return "stdsp\t%0, %1";
++      else
++          return "st.w\t%0, %1";
++      case 4:
++        if ( TARGET_HAS_ASM_ADDR_PSEUDOS )
++          return "lda.w\t%0, %1";
++        else
++          return "ld.w\t%0, r6[%1@got]";
++      default:
++      abort();
++    }
++  }
++
++  [(set_attr "length" "2,4,4,4,8")
++   (set_attr "type" "alu,alu,load,store,load")
++   (set_attr "cc" "none,none,none,none,clobber")])
++
++
++;; These instructions are for loading constants which cannot be loaded
++;; directly from the constant pool because the offset is too large
++;; high and lo_sum are used even tough for our case it should be
++;; low and high sum :-)
++(define_insn "mov_symbol_lo"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (high:SI (match_operand:SI 1 "immediate_operand" "i" )))]
++  ""
++  "mov\t%0, lo(%1)"
++  [(set_attr "type" "alu")
++   (set_attr "length" "4")]
++)
++
++(define_insn "add_symbol_hi"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (lo_sum:SI (match_dup 0)
++                   (match_operand:SI 1 "immediate_operand" "i" )))]
++  ""
++  "orh\t%0, hi(%1)"
++  [(set_attr "type" "alu")
++   (set_attr "length" "4")]
++)
++
++
++
++;; When generating pic, we need to load the symbol offset into a register.
++;; So that the optimizer does not confuse this with a normal symbol load
++;; we use an unspec.  The offset will be loaded from a constant pool entry,
++;; since that is the only type of relocation we can use.
++(define_insn "pic_load_addr"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (unspec:SI [(match_operand:SI 1 "" "")] UNSPEC_PIC_SYM))]
++  "flag_pic && CONSTANT_POOL_ADDRESS_P(XEXP(operands[1], 0))"
++  "lddpc\t%0, %1"
++  [(set_attr "type" "load")
++   (set_attr "length" "4")]
++)
++
++(define_insn "pic_compute_got_from_pc"
++  [(set (match_operand:SI 0 "register_operand" "+r")
++      (unspec:SI [(minus:SI (pc)
++                              (match_dup 0))] UNSPEC_PIC_BASE))
++   (use (label_ref (match_operand 1 "" "")))]
++  "flag_pic"
++  {
++   (*targetm.asm_out.internal_label) (asm_out_file, "L",
++                           CODE_LABEL_NUMBER (operands[1]));
++   return \"rsub\t%0, pc\";
++  }
++  [(set_attr "cc" "clobber")
++   (set_attr "length" "2")]
++)
++
++;;== long long int - 64 bits ==================================================
++(define_expand "movdi"
++  [(set (match_operand:DI 0 "nonimmediate_operand" "")
++      (match_operand:DI 1 "general_operand" ""))]
++  ""
++  {
++
++    /* One of the ops has to be in a register.  */
++    if (GET_CODE (operands[0]) != REG)
++      operands[1] = force_reg (DImode, operands[1]);
++
++  })
++
++
++(define_insn_and_split "*movdi_internal"
++  [(set (match_operand:DI 0 "nonimmediate_operand"     "=r,r,r,r,r,m")
++      (match_operand:DI 1 "general_operand"  "r,Ks08,Ks21,G,m,r"))]
++  ""
++  {
++    switch (which_alternative ){
++    case 1:
++    case 2:
++      if ( INTVAL(operands[1]) < 0 )
++        return "mov\t%0, %1\;mov\t%m0, -1";
++      else
++        return "mov\t%0, %1\;mov\t%m0, 0";
++    case 0:
++    case 3:
++      return "mov\t%0, %1\;mov\t%m0, %m1";
++    case 4:
++      if ( avr32_const_pool_ref_operand(operands[1], GET_MODE(operands[1])))
++        return "ld.d\t%0, pc[%1 - .]";
++      else
++        return "ld.d\t%0, %1";
++    case 5:
++      return "st.d\t%0, %1";
++    default:
++      abort();
++    }
++  }
++  "reload_completed &&
++   (REG_P(operands[0]) &&
++   (REG_P(operands[1]) || avr32_const_double_immediate(operands[1]) ||
++    ((GET_CODE(operands[1]) == CONST_INT) && avr32_const_ok_for_constraint_p(INTVAL(operands[1]), 'K', \"Ks21\")) ))"
++  [(set (match_dup 0) (match_dup 1))
++   (set (match_dup 2) (match_dup 3))]
++  {
++    operands[2] = gen_highpart (SImode, operands[0]);
++    operands[0] = gen_lowpart (SImode, operands[0]);
++    if ( REG_P(operands[1]) ){
++      operands[3] = gen_highpart(SImode, operands[1]);
++      operands[1] = gen_lowpart(SImode, operands[1]);
++    } else if ( GET_CODE(operands[1]) == CONST_DOUBLE ){
++      operands[3] = GEN_INT(CONST_DOUBLE_LOW(operands[1]));
++      operands[1] = GEN_INT(CONST_DOUBLE_HIGH(operands[1]));
++    } else if ( GET_CODE(operands[1]) == CONST_INT ){
++      operands[3] = GEN_INT((INTVAL(operands[1]) < 0) ? -1 : 0);
++      operands[1] = operands[1];
++    } else {
++      internal_error("Illegal operand[1] for movdi split!");
++    }
++  }
++
++  [(set_attr "length" "4,6,8,8,4,4")
++   (set_attr "type" "alu2,alu2,alu2,alu2,load2,store2")])
++
++
++;;== 128 bits ==================================================
++(define_expand "movti"
++  [(set (match_operand:TI 0 "nonimmediate_operand" "")
++      (match_operand:TI 1 "general_operand" ""))]
++  ""
++  {
++
++    /* One of the ops has to be in a register.  */
++    if (GET_CODE (operands[0]) != REG)
++      operands[1] = force_reg (TImode, operands[1]);
++
++    /* We must fix any pre_dec for loads and post_inc stores */
++    if ( GET_CODE (operands[0]) == MEM
++         && GET_CODE (XEXP(operands[0],0)) == POST_INC ){
++       emit_move_insn(gen_rtx_MEM(TImode, XEXP(XEXP(operands[0],0),0)), operands[1]);
++       emit_insn(gen_addsi3(XEXP(XEXP(operands[0],0),0), XEXP(XEXP(operands[0],0),0), GEN_INT(GET_MODE_SIZE(TImode))));
++       DONE;
++    }
++
++    if ( GET_CODE (operands[1]) == MEM
++         && GET_CODE (XEXP(operands[1],0)) == PRE_DEC ){
++       emit_insn(gen_addsi3(XEXP(XEXP(operands[1],0),0), XEXP(XEXP(operands[1],0),0), GEN_INT(-GET_MODE_SIZE(TImode))));
++       emit_move_insn(operands[0], gen_rtx_MEM(TImode, XEXP(XEXP(operands[1],0),0)));
++       DONE;
++    }
++
++    if (GET_CODE (operands[1]) == CONST_INT){
++      unsigned int sign_extend = (INTVAL(operands[1]) < 0) ? 0xFFFFFFFF : 0;
++      emit_move_insn(gen_rtx_SUBREG(SImode, operands[0], 12), operands[1]);
++      emit_move_insn(gen_rtx_SUBREG(SImode, operands[0], 8), GEN_INT(sign_extend));
++      emit_move_insn(gen_rtx_SUBREG(SImode, operands[0], 4), GEN_INT(sign_extend));
++      emit_move_insn(gen_rtx_SUBREG(SImode, operands[0], 0), GEN_INT(sign_extend));
++      DONE;
++    }
++
++    if (GET_CODE (operands[0]) == REG
++        && GET_CODE (operands[1]) == REG){
++      emit_move_insn(gen_rtx_SUBREG(SImode, operands[0], 12), gen_rtx_SUBREG(SImode, operands[1], 12));
++      emit_move_insn(gen_rtx_SUBREG(SImode, operands[0], 8), gen_rtx_SUBREG(SImode, operands[1], 8));
++      emit_move_insn(gen_rtx_SUBREG(SImode, operands[0], 4), gen_rtx_SUBREG(SImode, operands[1], 4));
++      emit_move_insn(gen_rtx_SUBREG(SImode, operands[0], 0), gen_rtx_SUBREG(SImode, operands[1], 0));
++      DONE;
++    }
++  })
++
++
++(define_insn "*movti_internal"
++  [(set (match_operand:TI 0 "nonimmediate_operand"  "=r,r, <RKu00,r")
++      (match_operand:TI 1 "loadti_operand"   " r,RKu00>,r,m"))]
++  ""
++  "@
++   mov\t%T0, %T1\;mov\t%U0, %U1\;mov\t%L0, %L1\;mov\t%B0, %B1
++   ldm\t%p1, %0
++   stm\t%p0, %1
++   ldm\t%p1, %0"
++  [(set_attr "length" "8,4,4,4")
++   (set_attr "type" "alu,load4,store4,load4")])
++
++
++;;== float - 32 bits ==========================================================
++(define_expand "movsf"
++  [(set (match_operand:SF 0 "nonimmediate_operand" "")
++      (match_operand:SF 1 "general_operand" ""))]
++  ""
++  {
++
++
++    /* One of the ops has to be in a register.  */
++    if (GET_CODE (operands[0]) != REG)
++      operands[1] = force_reg (SFmode, operands[1]);
++
++  })
++
++(define_insn "*movsf_internal"
++  [(set (match_operand:SF 0 "nonimmediate_operand"     "=r,r,r,m")
++      (match_operand:SF 1 "general_operand"  "r,G,m,r"))]
++  "TARGET_SOFT_FLOAT"
++  {
++    switch (which_alternative) {
++      case 0:
++      case 1: return "mov\t%0, %1";
++      case 2:
++        if ( (REG_P(XEXP(operands[1], 0))
++              && REGNO(XEXP(operands[1], 0)) == SP_REGNUM)
++             || (GET_CODE(XEXP(operands[1], 0)) == PLUS
++                 && REGNO(XEXP(XEXP(operands[1], 0), 0)) == SP_REGNUM
++               && GET_CODE(XEXP(XEXP(operands[1], 0), 1)) == CONST_INT
++               && INTVAL(XEXP(XEXP(operands[1], 0), 1)) % 4 == 0
++               && INTVAL(XEXP(XEXP(operands[1], 0), 1)) <= 0x1FC) )
++          return "lddsp\t%0, %1";
++          else if ( avr32_const_pool_ref_operand(operands[1], GET_MODE(operands[1])) )
++          return "lddpc\t%0, %1";
++        else
++          return "ld.w\t%0, %1";
++      case 3:
++        if ( (REG_P(XEXP(operands[0], 0))
++              && REGNO(XEXP(operands[0], 0)) == SP_REGNUM)
++             || (GET_CODE(XEXP(operands[0], 0)) == PLUS
++                 && REGNO(XEXP(XEXP(operands[0], 0), 0)) == SP_REGNUM
++               && GET_CODE(XEXP(XEXP(operands[0], 0), 1)) == CONST_INT
++               && INTVAL(XEXP(XEXP(operands[0], 0), 1)) % 4 == 0
++               && INTVAL(XEXP(XEXP(operands[0], 0), 1)) <= 0x1FC) )
++          return "stdsp\t%0, %1";
++      else
++          return "st.w\t%0, %1";
++      default:
++      abort();
++    }
++  }
++
++  [(set_attr "length" "2,4,4,4")
++   (set_attr "type" "alu,alu,load,store")])
++
++
++
++;;== double - 64 bits =========================================================
++(define_expand "movdf"
++  [(set (match_operand:DF 0 "nonimmediate_operand" "")
++      (match_operand:DF 1 "general_operand" ""))]
++  ""
++  {
++    /* One of the ops has to be in a register.  */
++    if (GET_CODE (operands[0]) != REG){
++      operands[1] = force_reg (DFmode, operands[1]);
++    }
++  })
++
++
++(define_insn_and_split "*movdf_internal"
++  [(set (match_operand:DF 0 "nonimmediate_operand"     "=r,r,r,m")
++      (match_operand:DF 1 "general_operand"  "r,G,m,r"))]
++  "TARGET_SOFT_FLOAT"
++  {
++    switch (which_alternative ){
++    case 0:
++    case 1:
++      return "mov\t%0, %1\;mov\t%m0, %m1";
++    case 2:
++      if ( avr32_const_pool_ref_operand(operands[1], GET_MODE(operands[1])))
++        return "ld.d\t%0, pc[%1 - .]";
++      else
++        return "ld.d\t%0, %1";
++    case 3:
++      return "st.d\t%0, %1";
++    default:
++      abort();
++    }
++  }
++  "TARGET_SOFT_FLOAT
++   && reload_completed
++   && (REG_P(operands[0]) && REG_P(operands[1]))"
++  [(set (match_dup 0) (match_dup 1))
++   (set (match_dup 2) (match_dup 3))]
++  "
++   {
++    operands[2] = gen_highpart (SImode, operands[0]);
++    operands[0] = gen_lowpart (SImode, operands[0]);
++    operands[3] = gen_highpart(SImode, operands[1]);
++    operands[1] = gen_lowpart(SImode, operands[1]);
++   }
++  "
++
++  [(set_attr "length" "4,8,4,4")
++   (set_attr "type" "alu2,alu2,load2,store2")])
++
++
++
++
++;;=============================================================================
++;; Move chunks of memory
++;;=============================================================================
++
++(define_expand "movmemsi"
++  [(match_operand:BLK 0 "general_operand" "")
++   (match_operand:BLK 1 "general_operand" "")
++   (match_operand:SI 2 "const_int_operand" "")
++   (match_operand:SI 3 "const_int_operand" "")]
++  ""
++  "
++   if (avr32_gen_movmemsi (operands))
++     DONE;
++   FAIL;
++  "
++  )
++
++
++
++
++;;=============================================================================
++;; Bit field instructions
++;;-----------------------------------------------------------------------------
++;; Instructions to insert or extract bit-fields
++;;=============================================================================
++
++(define_insn "insv"
++  [ (set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
++                          (match_operand:SI 1 "immediate_operand" "Ku05")
++                          (match_operand:SI 2 "immediate_operand" "Ku05"))
++         (match_operand 3 "register_operand" "r"))]
++  ""
++  "bfins\t%0, %3, %2, %1"
++  [(set_attr "type" "alu")
++   (set_attr "length" "4")
++   (set_attr "cc" "set_ncz")])
++
++
++
++
++(define_insn "extv"
++  [ (set (match_operand:SI 0 "register_operand" "=r")
++         (sign_extract:SI (match_operand:SI 1 "register_operand" "r")
++                          (match_operand:SI 2 "immediate_operand" "Ku05")
++                          (match_operand:SI 3 "immediate_operand" "Ku05")))]
++  ""
++  "bfexts\t%0, %1, %3, %2"
++  [(set_attr "type" "alu")
++   (set_attr "length" "4")
++   (set_attr "cc" "set_ncz")])
++
++
++(define_insn "extzv"
++  [ (set (match_operand:SI 0 "register_operand" "=r")
++         (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
++                          (match_operand:SI 2 "immediate_operand" "Ku05")
++                          (match_operand:SI 3 "immediate_operand" "Ku05")))]
++  ""
++  "bfextu\t%0, %1, %3, %2"
++  [(set_attr "type" "alu")
++   (set_attr "length" "4")
++   (set_attr "cc" "set_ncz")])
++
++
++
++;;=============================================================================
++;; Some peepholes for avoiding unnecessary cast instructions
++;; followed by bfins.
++;;-----------------------------------------------------------------------------
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (zero_extend:SI (match_operand:QI 1 "register_operand" "")))
++   (set (zero_extract:SI (match_operand 2 "register_operand" "")
++                         (match_operand:SI 3 "immediate_operand" "")
++                         (match_operand:SI 4 "immediate_operand" ""))
++        (match_dup 0))]
++  "((peep2_reg_dead_p(2, operands[0]) &&
++    (INTVAL(operands[3]) <= 8)))"
++  [(set (zero_extract:SI (match_dup 2)
++                         (match_dup 3)
++                         (match_dup 4))
++        (match_dup 1))]
++  )
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (zero_extend:SI (match_operand:HI 1 "register_operand" "")))
++   (set (zero_extract:SI (match_operand 2 "register_operand" "")
++                         (match_operand:SI 3 "immediate_operand" "")
++                         (match_operand:SI 4 "immediate_operand" ""))
++        (match_dup 0))]
++  "((peep2_reg_dead_p(2, operands[0]) &&
++    (INTVAL(operands[3]) <= 16)))"
++  [(set (zero_extract:SI (match_dup 2)
++                         (match_dup 3)
++                         (match_dup 4))
++        (match_dup 1))]
++  )
++
++;;=============================================================================
++;; push bytes
++;;-----------------------------------------------------------------------------
++;; Implements the push instruction
++;;=============================================================================
++(define_insn "pushm"
++  [(set (mem:BLK (pre_dec:BLK (reg:SI SP_REGNUM)))
++        (unspec:BLK [(match_operand 0 "const_int_operand" "")]
++                    UNSPEC_PUSHM))]
++  ""
++  {
++    if (INTVAL(operands[0])) {
++      return "pushm\t%r0";
++    } else {
++      return "";
++    }
++  }
++  [(set_attr "type" "store")
++   (set_attr "length" "2")
++   (set_attr "cc" "none")])
++
++(define_insn "stm"
++  [(unspec [(match_operand 0 "register_operand" "r")
++            (match_operand 1 "const_int_operand" "")
++            (match_operand 2 "const_int_operand" "")]
++         UNSPEC_STM)]
++  ""
++  {
++    if (INTVAL(operands[1])) {
++      if (INTVAL(operands[2]) != 0)
++         return "stm\t--%0, %s1";
++      else
++         return "stm\t%0, %s1";
++    } else {
++      return "";
++    }
++  }
++  [(set_attr "type" "store")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++
++
++(define_insn "popm"
++  [(unspec [(match_operand 0 "const_int_operand" "")]
++         UNSPEC_POPM)]
++  ""
++  {
++    if (INTVAL(operands[0])) {
++      return "popm   %r0";
++    } else {
++      return "";
++    }
++  }
++  [(set_attr "type" "load")
++   (set_attr "length" "2")])
++
++
++
++;;=============================================================================
++;; add
++;;-----------------------------------------------------------------------------
++;; Adds reg1 with reg2 and puts the result in reg0.
++;;=============================================================================
++(define_insn "add<mode>3"
++  [(set (match_operand:INTM 0 "register_operand" "=r,r,r,r,r")
++      (plus:INTM (match_operand:INTM 1 "register_operand" "%0,r,0,r,0")
++                   (match_operand:INTM 2 "avr32_add_operand" "r,r,Is08,Is16,Is21")))]
++  ""
++  "@
++   add     %0, %2
++   add     %0, %1, %2
++   sub     %0, %n2
++   sub     %0, %1, %n2
++   sub     %0, %n2"
++
++  [(set_attr "length" "2,4,2,4,4")
++   (set_attr "cc" "<INTM:alu_cc_attr>")])
++
++(define_insn "*addsi3_lsl"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (plus:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
++                            (match_operand:SI 3 "avr32_add_shift_immediate_operand" "Ku02"))
++                 (match_operand:SI 2 "register_operand" "r")))]
++  ""
++  "add     %0, %2, %1 << %3"
++  [(set_attr "length" "4")
++   (set_attr "cc" "set_vncz")])
++
++
++(define_insn "*addsi3_mul"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "r")
++                          (match_operand:SI 3 "immediate_operand" "Ku04" ))
++                 (match_operand:SI 2 "register_operand" "r")))]
++  "(INTVAL(operands[3]) == 0) || (INTVAL(operands[3]) == 2) ||
++   (INTVAL(operands[3]) == 4) || (INTVAL(operands[3]) == 8)"
++  "add     %0, %2, %1 << %p3"
++  [(set_attr "length" "4")
++   (set_attr "cc" "set_vncz")])
++
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (ashift:SI (match_operand:SI 1 "register_operand" "")
++                   (match_operand:SI 2 "immediate_operand" "")))
++   (set (match_operand:SI 3 "register_operand" "")
++      (plus:SI (match_dup 0)
++                 (match_operand:SI 4 "register_operand" "")))]
++  "(peep2_reg_dead_p(2, operands[0]) &&
++    (INTVAL(operands[2]) < 4 && INTVAL(operands[2]) > 0))"
++  [(set (match_dup 3)
++      (plus:SI (ashift:SI (match_dup 1)
++                            (match_dup 2))
++                 (match_dup 4)))]
++  )
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (ashift:SI (match_operand:SI 1 "register_operand" "")
++                   (match_operand:SI 2 "immediate_operand" "")))
++   (set (match_operand:SI 3 "register_operand" "")
++      (plus:SI (match_operand:SI 4 "register_operand" "")
++                 (match_dup 0)))]
++  "(peep2_reg_dead_p(2, operands[0]) &&
++    (INTVAL(operands[2]) < 4 && INTVAL(operands[2]) > 0))"
++  [(set (match_dup 3)
++      (plus:SI (ashift:SI (match_dup 1)
++                            (match_dup 2))
++                 (match_dup 4)))]
++  )
++
++(define_insn "adddi3"
++  [(set (match_operand:DI 0 "register_operand" "=r,r")
++      (plus:DI (match_operand:DI 1 "register_operand" "%r,0")
++               (match_operand:DI 2 "register_operand" "r,r")))]
++  ""
++  "@
++   add     %0, %1, %2\;adc    %m0, %m1, %m2
++   add     %0, %2\;adc    %m0, %m0, %m2"
++  [(set_attr "length" "8,6")
++   (set_attr "type" "alu2")
++   (set_attr "cc" "set_vncz")])
++
++
++
++;;=============================================================================
++;; subtract
++;;-----------------------------------------------------------------------------
++;; Subtract reg2 or immediate value from reg0 and puts the result in reg0.
++;;=============================================================================
++
++(define_peephole2
++  [(set (match_operand:QI 0 "register_operand" "")
++      (minus:QI (match_operand:QI 1 "general_operand" "")
++                (match_operand:QI 2 "general_operand" "")))
++   (set (match_operand:QI 3 "register_operand" "")
++        (match_dup 0))]
++  "peep2_reg_dead_p(2, operands[0])"
++  [(set (match_dup 3)
++        (minus:QI (match_dup 1) (match_dup 2)))]
++  )
++
++(define_peephole
++  [(set (match_operand:QI 0 "register_operand" "")
++      (minus:QI (match_operand:QI 1 "immediate_operand" "Ks08")
++                (match_operand:QI 2 "register_operand" "r")))
++   (set (match_operand:QI 3 "register_operand" "r")
++        (match_dup 0))]
++  "dead_or_set_p(insn, operands[0])"
++  "rsub    %3, %2, %1"
++  [(set_attr "length" "4")
++   (set_attr "cc" "clobber")]
++  )
++
++
++
++(define_insn "sub<mode>3"
++  [(set (match_operand:INTM 0 "general_operand" "=r,r,r,r,r,r,r")
++      (minus:INTM (match_operand:INTM 1 "nonmemory_operand" "0,r,0,r,0,r,Ks08")
++                (match_operand:INTM 2 "nonmemory_operand" "r,r,Ks08,Ks16,Ks21,0,r")))]
++  ""
++  "@
++   sub     %0, %2
++   sub     %0, %1, %2
++   sub     %0, %2
++   sub     %0, %1, %2
++   sub     %0, %2
++   rsub    %0, %1
++   rsub    %0, %2, %1"
++  [(set_attr "length" "2,4,2,4,4,2,4")
++   (set_attr "cc" "<INTM:alu_cc_attr>")])
++
++(define_insn "*sub<mode>3_mul"
++  [(set (match_operand:INTM 0 "register_operand" "=r,r,r")
++      (minus:INTM (match_operand:INTM 1 "register_operand" "r,0,r")
++                    (mult:INTM (match_operand:INTM 2 "register_operand" "r,r,0")
++                               (match_operand:SI 3 "immediate_operand" "Ku04,Ku04,Ku04" ))))]
++  "(INTVAL(operands[3]) == 0) || (INTVAL(operands[3]) == 2) ||
++   (INTVAL(operands[3]) == 4) || (INTVAL(operands[3]) == 8)"
++  "@
++   sub     %0, %1, %2 << %p3
++   sub     %0, %0, %2 << %p3
++   sub     %0, %1, %0 << %p3"
++  [(set_attr "length" "4,4,4")
++   (set_attr "cc" "<INTM:alu_cc_attr>")])
++
++(define_insn "*sub<mode>3_lsl"
++  [(set (match_operand:INTM 0 "register_operand" "=r")
++      (minus:INTM (ashift:INTM (match_operand:INTM 1 "register_operand" "r")
++                                 (match_operand:SI 3 "avr32_add_shift_immediate_operand" "Ku02"))
++                    (match_operand:INTM 2 "register_operand" "r")))]
++  ""
++  "sub     %0, %2, %1 << %3"
++  [(set_attr "length" "4")
++   (set_attr "cc" "<INTM:alu_cc_attr>")])
++
++
++(define_insn "subdi3"
++  [(set (match_operand:DI 0 "register_operand" "=r,r")
++      (minus:DI (match_operand:DI 1 "register_operand" "%r,0")
++               (match_operand:DI 2 "register_operand" "r,r")))]
++  ""
++  "@
++   sub     %0, %1, %2\;sbc    %m0, %m1, %m2
++   sub     %0, %2\;sbc    %m0, %m0, %m2"
++  [(set_attr "length" "8,6")
++   (set_attr "type" "alu2")
++   (set_attr "cc" "set_vncz")])
++
++
++
++;;=============================================================================
++;; multiply
++;;-----------------------------------------------------------------------------
++;; Multiply op1 and op2 and put the value in op0.
++;;=============================================================================
++
++
++(define_insn "mulqi3"
++  [(set (match_operand:QI 0 "register_operand"         "=r,r,r")
++      (mult:QI (match_operand:QI 1 "register_operand" "%0,r,r")
++               (match_operand:QI 2 "avr32_mul_operand" "r,r,Ks08")))]
++  ""
++  {
++   switch (which_alternative){
++    case 0:
++      return "mul     %0, %2";
++    case 1:
++      return "mul     %0, %1, %2";
++    case 2:
++      return "mul     %0, %1, %2";
++    default:
++      abort();
++   }
++  }
++  [(set_attr "type" "mulww_w,mulww_w,mulwh")
++   (set_attr "length" "2,4,4")
++   (set_attr "cc" "none")])
++
++(define_insn "mulsi3"
++  [(set (match_operand:SI 0 "register_operand"         "=r,r,r")
++      (mult:SI (match_operand:SI 1 "register_operand" "%0,r,r")
++               (match_operand:SI 2 "avr32_mul_operand" "r,r,Ks08")))]
++  ""
++  {
++   switch (which_alternative){
++    case 0:
++      return "mul     %0, %2";
++    case 1:
++      return "mul     %0, %1, %2";
++    case 2:
++      return "mul     %0, %1, %2";
++    default:
++      abort();
++   }
++  }
++  [(set_attr "type" "mulww_w,mulww_w,mulwh")
++   (set_attr "length" "2,4,4")
++   (set_attr "cc" "none")])
++
++
++(define_insn "mulhisi3"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (mult:SI
++       (sign_extend:SI (match_operand:HI 1 "register_operand" "%r"))
++       (sign_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
++  "TARGET_DSP"
++  "mulhh.w %0, %1:b, %2:b"
++  [(set_attr "type" "mulhh")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++(define_peephole2
++  [(match_scratch:DI 6 "r")
++   (set (match_operand:SI 0 "register_operand" "")
++      (mult:SI
++       (sign_extend:SI (match_operand:HI 1 "register_operand" ""))
++         (sign_extend:SI (match_operand:HI 2 "register_operand" ""))))
++   (set (match_operand:SI 3 "register_operand" "")
++        (ashiftrt:SI (match_dup 0)
++                     (const_int 16)))]
++  "TARGET_DSP
++   && (peep2_reg_dead_p(1, operands[0]) || (REGNO(operands[0]) == REGNO(operands[3])))"
++  [(set (match_dup 4) (sign_extend:SI (match_dup 1)))
++   (set (match_dup 6)
++        (ashift:DI (mult:DI (sign_extend:DI (match_dup 4))
++                            (sign_extend:DI (match_dup 2)))
++                   (const_int 16)))
++   (set (match_dup 3) (match_dup 5))]
++
++  "{
++     operands[4] = gen_rtx_REG(SImode, REGNO(operands[1]));
++     operands[5] = gen_highpart (SImode, operands[4]);
++   }"
++  )
++
++(define_insn "mulnhisi3"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++        (mult:SI
++         (sign_extend:SI (neg:HI (match_operand:HI 1 "register_operand" "r")))
++         (sign_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
++  "TARGET_DSP"
++  "mulnhh.w %0, %1:b, %2:b"
++  [(set_attr "type" "mulhh")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++(define_insn "machisi3"
++  [(set (match_operand:SI 0 "register_operand" "+r")
++      (plus:SI (mult:SI
++                  (sign_extend:SI (match_operand:HI 1 "register_operand" "%r"))
++                  (sign_extend:SI (match_operand:HI 2 "register_operand" "r")))
++                 (match_dup 0)))]
++  "TARGET_DSP"
++  "machh.w %0, %1:b, %2:b"
++  [(set_attr "type" "machh_w")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++
++
++(define_insn "mulsidi3"
++  [(set (match_operand:DI 0 "register_operand" "=r")
++      (mult:DI
++       (sign_extend:DI (match_operand:SI 1 "register_operand" "%r"))
++       (sign_extend:DI (match_operand:SI 2 "register_operand" "r"))))]
++  ""
++  "muls.d  %0, %1, %2"
++  [(set_attr "type" "mulww_d")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++(define_insn "umulsidi3"
++  [(set (match_operand:DI 0 "register_operand" "=r")
++      (mult:DI
++       (zero_extend:DI (match_operand:SI 1 "register_operand" "%r"))
++       (zero_extend:DI (match_operand:SI 2 "register_operand" "r"))))]
++  ""
++  "mulu.d  %0, %1, %2"
++  [(set_attr "type" "mulww_d")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++(define_insn "*mulaccsi3"
++  [(set (match_operand:SI 0 "register_operand" "+r")
++      (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "%r")
++                        (match_operand:SI 2 "register_operand" "r"))
++               (match_dup 0)))]
++  ""
++  "mac     %0, %1, %2"
++  [(set_attr "type" "macww_w")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++(define_insn "mulaccsidi3"
++  [(set (match_operand:DI 0 "register_operand" "+r")
++      (plus:DI (mult:DI
++                (sign_extend:DI (match_operand:SI 1 "register_operand" "%r"))
++                (sign_extend:DI (match_operand:SI 2 "register_operand" "r")))
++               (match_dup 0)))]
++  ""
++  "macs.d  %0, %1, %2"
++  [(set_attr "type" "macww_d")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++(define_insn "umulaccsidi3"
++  [(set (match_operand:DI 0 "register_operand" "+r")
++      (plus:DI (mult:DI
++                (zero_extend:DI (match_operand:SI 1 "register_operand" "%r"))
++                (zero_extend:DI (match_operand:SI 2 "register_operand" "r")))
++               (match_dup 0)))]
++  ""
++  "macu.d  %0, %1, %2"
++  [(set_attr "type" "macww_d")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++
++
++;; Try to avoid Write-After-Write hazards for mul operations
++;; if it can be done
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++      (mult:SI
++       (sign_extend:SI (match_operand 1 "general_operand" ""))
++         (sign_extend:SI (match_operand 2 "general_operand" ""))))
++   (set (match_dup 0)
++      (match_operator:SI 3 "alu_operator" [(match_dup 0)
++                                             (match_operand 4 "general_operand" "")]))]
++  "peep2_reg_dead_p(1, operands[2])"
++  [(set (match_dup 5)
++        (mult:SI
++         (sign_extend:SI (match_dup 1))
++         (sign_extend:SI (match_dup 2))))
++   (set (match_dup 0)
++      (match_op_dup 3 [(match_dup 5)
++                         (match_dup 4)]))]
++  "{operands[5] = gen_rtx_REG(SImode, REGNO(operands[2]));}"
++  )
++
++
++
++;;=============================================================================
++;; DSP instructions
++;;=============================================================================
++(define_insn "mulsathh_h"
++  [(set (match_operand:HI 0 "register_operand" "=r")
++        (ss_truncate:HI (ashiftrt:SI (mult:SI (sign_extend:SI (match_operand:HI 1 "register_operand" "%r"))
++                                              (sign_extend:SI (match_operand:HI 2 "register_operand" "r")))
++                                     (const_int 15))))]
++  "TARGET_DSP"
++  "mulsathh.h\t%0, %1:b, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulhh")])
++
++(define_insn "mulsatrndhh_h"
++  [(set (match_operand:HI 0 "register_operand" "=r")
++        (ss_truncate:HI (ashiftrt:SI
++                         (plus:SI (mult:SI (sign_extend:SI (match_operand:HI 1 "register_operand" "%r"))
++                                           (sign_extend:SI (match_operand:HI 2 "register_operand" "r")))
++                                  (const_int 1073741824))
++                         (const_int 15))))]
++  "TARGET_DSP"
++  "mulsatrndhh.h\t%0, %1:b, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulhh")])
++
++(define_insn "mulsathh_w"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++        (ss_truncate:SI (ashift:DI (mult:DI (sign_extend:DI (match_operand:HI 1 "register_operand" "%r"))
++                                            (sign_extend:DI (match_operand:HI 2 "register_operand" "r")))
++                                   (const_int 1))))]
++  "TARGET_DSP"
++  "mulsathh.w\t%0, %1:b, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulhh")])
++
++(define_insn "mulsatwh_w"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++        (ss_truncate:SI (ashiftrt:DI (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "r"))
++                                              (sign_extend:DI (match_operand:HI 2 "register_operand" "r")))
++                                     (const_int 15))))]
++  "TARGET_DSP"
++  "mulsatwh.w\t%0, %1, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulwh")])
++
++(define_insn "mulsatrndwh_w"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++        (ss_truncate:SI (ashiftrt:DI (plus:DI (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "r"))
++                                                       (sign_extend:DI (match_operand:HI 2 "register_operand" "r")))
++                                              (const_int 1073741824))
++                                     (const_int 15))))]
++  "TARGET_DSP"
++  "mulsatrndwh.w\t%0, %1, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulwh")])
++
++(define_insn "macsathh_w"
++  [(set (match_operand:SI 0 "register_operand" "+r")
++        (plus:SI (match_dup 0)
++                 (ss_truncate:SI (ashift:DI (mult:DI (sign_extend:DI (match_operand:HI 1 "register_operand" "%r"))
++                                                     (sign_extend:DI (match_operand:HI 2 "register_operand" "r")))
++                                            (const_int 1)))))]
++  "TARGET_DSP"
++  "macsathh.w\t%0, %1:b, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulhh")])
++
++
++(define_insn "mulwh_d"
++  [(set (match_operand:DI 0 "register_operand" "=r")
++        (ashift:DI (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "r"))
++                            (sign_extend:DI (match_operand:HI 2 "register_operand" "r")))
++                   (const_int 16)))]
++  "TARGET_DSP"
++  "mulwh.d\t%0, %1, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulwh")])
++
++
++(define_insn "mulnwh_d"
++  [(set (match_operand:DI 0 "register_operand" "=r")
++        (ashift:DI (mult:DI (not:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "r")))
++                            (sign_extend:DI (match_operand:HI 2 "register_operand" "r")))
++                   (const_int 16)))]
++  "TARGET_DSP"
++  "mulnwh.d\t%0, %1, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulwh")])
++
++(define_insn "macwh_d"
++  [(set (match_operand:DI 0 "register_operand" "+r")
++        (plus:DI (match_dup 0)
++                 (ashift:DI (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "%r"))
++                                     (sign_extend:DI (match_operand:HI 2 "register_operand" "r")))
++                            (const_int 16))))]
++  "TARGET_DSP"
++  "macwh.d\t%0, %1, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulwh")])
++
++(define_insn "machh_d"
++  [(set (match_operand:DI 0 "register_operand" "+r")
++        (plus:DI (match_dup 0)
++                 (mult:DI (sign_extend:DI (match_operand:HI 1 "register_operand" "%r"))
++                          (sign_extend:DI (match_operand:HI 2 "register_operand" "r")))))]
++  "TARGET_DSP"
++  "machh.d\t%0, %1:b, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "mulwh")])
++
++(define_insn "satadd_w"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++        (ss_plus:SI (match_operand:SI 1 "register_operand" "r")
++                    (match_operand:SI 2 "register_operand" "r")))]
++  "TARGET_DSP"
++  "satadd.w\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "alu_sat")])
++
++(define_insn "satsub_w"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++        (ss_minus:SI (match_operand:SI 1 "register_operand" "r")
++                     (match_operand:SI 2 "register_operand" "r")))]
++  "TARGET_DSP"
++  "satsub.w\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "alu_sat")])
++
++(define_insn "satadd_h"
++  [(set (match_operand:HI 0 "register_operand" "=r")
++        (ss_plus:HI (match_operand:HI 1 "register_operand" "r")
++                    (match_operand:HI 2 "register_operand" "r")))]
++  "TARGET_DSP"
++  "satadd.h\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "alu_sat")])
++
++(define_insn "satsub_h"
++  [(set (match_operand:HI 0 "register_operand" "=r")
++        (ss_minus:HI (match_operand:HI 1 "register_operand" "r")
++                     (match_operand:HI 2 "register_operand" "r")))]
++  "TARGET_DSP"
++  "satsub.h\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")
++   (set_attr "type" "alu_sat")])
++
++
++;;=============================================================================
++;; smin
++;;-----------------------------------------------------------------------------
++;; Set reg0 to the smallest value of reg1 and reg2. It is used for signed
++;; values in the registers.
++;;=============================================================================
++(define_insn "sminsi3"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (smin:SI (match_operand:SI 1 "register_operand" "r")
++               (match_operand:SI 2 "register_operand" "r")))]
++  ""
++  "min     %0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++;;=============================================================================
++;; smax
++;;-----------------------------------------------------------------------------
++;; Set reg0 to the largest value of reg1 and reg2. It is used for signed
++;; values in the registers.
++;;=============================================================================
++(define_insn "smaxsi3"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (smax:SI (match_operand:SI 1 "register_operand" "r")
++               (match_operand:SI 2 "register_operand" "r")))]
++  ""
++  "max     %0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++
++;;=============================================================================
++;; Logical operations
++;;-----------------------------------------------------------------------------
++
++;; Split up simple DImode logical operations.  Simply perform the logical
++;; operation on the upper and lower halves of the registers.
++(define_split
++  [(set (match_operand:DI 0 "register_operand" "")
++      (match_operator:DI 6 "logical_binary_operator"
++        [(match_operand:DI 1 "register_operand" "")
++         (match_operand:DI 2 "register_operand" "")]))]
++  "reload_completed"
++  [(set (match_dup 0) (match_op_dup:SI 6 [(match_dup 1) (match_dup 2)]))
++   (set (match_dup 3) (match_op_dup:SI 6 [(match_dup 4) (match_dup 5)]))]
++  "
++  {
++    operands[3] = gen_highpart (SImode, operands[0]);
++    operands[0] = gen_lowpart (SImode, operands[0]);
++    operands[4] = gen_highpart (SImode, operands[1]);
++    operands[1] = gen_lowpart (SImode, operands[1]);
++    operands[5] = gen_highpart (SImode, operands[2]);
++    operands[2] = gen_lowpart (SImode, operands[2]);
++  }"
++)
++
++;;=============================================================================
++;; Logical operations with shifted operand
++;;=============================================================================
++(define_insn "<code>si_lshift"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++        (logical:SI (match_operator:SI 4 "logical_shift_operator"
++                                       [(match_operand:SI 2 "register_operand" "r")
++                                        (match_operand:SI 3 "immediate_operand" "Ku05")])
++                    (match_operand:SI 1 "register_operand" "r")))]
++  ""
++  {
++   if ( GET_CODE(operands[4]) == ASHIFT )
++      return "<logical_insn>\t%0, %1, %2 << %3";
++   else
++      return "<logical_insn>\t%0, %1, %2 >> %3";
++      }
++
++  [(set_attr "cc" "set_z")]
++)
++
++
++;;************************************************
++;; Peepholes for detecting logical operantions
++;; with shifted operands
++;;************************************************
++
++(define_peephole
++  [(set (match_operand:SI 3 "register_operand" "")
++        (match_operator:SI 5 "logical_shift_operator"
++                           [(match_operand:SI 1 "register_operand" "")
++                            (match_operand:SI 2 "immediate_operand" "")]))
++   (set (match_operand:SI 0 "register_operand" "")
++        (logical:SI (match_operand:SI 4 "register_operand" "")
++                    (match_dup 3)))]
++  "(dead_or_set_p(insn, operands[3])) || (REGNO(operands[3]) == REGNO(operands[0]))"
++  {
++   if ( GET_CODE(operands[5]) == ASHIFT )
++      return "<logical_insn>\t%0, %4, %1 << %2";
++   else
++      return "<logical_insn>\t%0, %4, %1 >> %2";
++  }
++  [(set_attr "cc" "set_z")]
++  )
++
++(define_peephole
++  [(set (match_operand:SI 3 "register_operand" "")
++        (match_operator:SI 5 "logical_shift_operator"
++                           [(match_operand:SI 1 "register_operand" "")
++                            (match_operand:SI 2 "immediate_operand" "")]))
++   (set (match_operand:SI 0 "register_operand" "")
++        (logical:SI (match_dup 3)
++                    (match_operand:SI 4 "register_operand" "")))]
++  "(dead_or_set_p(insn, operands[3])) || (REGNO(operands[3]) == REGNO(operands[0]))"
++  {
++   if ( GET_CODE(operands[5]) == ASHIFT )
++      return "<logical_insn>\t%0, %4, %1 << %2";
++   else
++      return "<logical_insn>\t%0, %4, %1 >> %2";
++  }
++  [(set_attr "cc" "set_z")]
++  )
++
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (match_operator:SI 5 "logical_shift_operator"
++                           [(match_operand:SI 1 "register_operand" "")
++                            (match_operand:SI 2 "immediate_operand" "")]))
++   (set (match_operand:SI 3 "register_operand" "")
++        (logical:SI (match_operand:SI 4 "register_operand" "")
++                    (match_dup 0)))]
++  "(peep2_reg_dead_p(2, operands[0])) || (REGNO(operands[3]) == REGNO(operands[0]))"
++
++  [(set (match_dup 3)
++        (logical:SI  (match_op_dup:SI 5 [(match_dup 1) (match_dup 2)])
++                     (match_dup 4)))]
++
++  ""
++)
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (match_operator:SI 5 "logical_shift_operator"
++                           [(match_operand:SI 1 "register_operand" "")
++                            (match_operand:SI 2 "immediate_operand" "")]))
++   (set (match_operand:SI 3 "register_operand" "")
++        (logical:SI (match_dup 0)
++                    (match_operand:SI 4 "register_operand" "")))]
++  "(peep2_reg_dead_p(2, operands[0])) || (REGNO(operands[3]) == REGNO(operands[0]))"
++
++  [(set (match_dup 3)
++        (logical:SI (match_op_dup:SI 5 [(match_dup 1) (match_dup 2)])
++                    (match_dup 4)))]
++
++  ""
++)
++
++
++;;=============================================================================
++;; and
++;;-----------------------------------------------------------------------------
++;; Store the result after a bitwise logical-and between reg0 and reg2 in reg0.
++;;=============================================================================
++
++(define_insn "andnsi"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++        (and:SI (match_operand:SI 1 "register_operand" "0")
++                (not:SI (match_operand:SI 2 "register_operand" "r"))))]
++  ""
++  "andn    %0, %2"
++  [(set_attr "cc" "set_z")
++   (set_attr "length" "2")]
++)
++
++
++
++
++(define_insn "andsi3"
++  [(set (match_operand:SI 0 "register_operand" "=r, r, r, r")
++      (and:SI (match_operand:SI 1 "register_operand" "%0, r, 0, r")
++                (match_operand:SI 2 "nonmemory_operand" "r, M, i, r")))]
++  ""
++  {
++   switch (which_alternative){
++    case 0:
++         return "and\t%0, %2";
++    case 1:
++        {
++         int i, first_set = -1;
++         /* Search for first bit set in mask */
++         for ( i = 31; i >= 0; --i )
++           if ( INTVAL(operands[2]) & (1 << i) ){
++             first_set = i;
++             break;
++           }
++         operands[2] = gen_rtx_CONST_INT(SImode, first_set + 1);
++         return "bfextu\t%0, %1, 0, %2";
++        }
++    case 2:
++         if ( one_bit_cleared_operand(operands[2], VOIDmode) ){
++             int bitpos;
++             for ( bitpos = 0; bitpos < 32; bitpos++ )
++               if ( !(INTVAL(operands[2]) & (1 << bitpos)) )
++                 break;
++             operands[2] = gen_rtx_CONST_INT(SImode, bitpos);
++             return "cbr\t%0, %2";
++         } else if ( (INTVAL(operands[2]) >= 0) &&
++                     (INTVAL(operands[2]) <= 65535) )
++             return "andl\t%0, %2, COH";
++         else if ( (INTVAL(operands[2]) < 0) &&
++                   (INTVAL(operands[2]) >= -65536 ) )
++             return "andl\t%0, lo(%2)";
++         else if ( ((INTVAL(operands[2]) & 0xffff) == 0xffff) )
++             return "andh\t%0, hi(%2)";
++         else if ( ((INTVAL(operands[2]) & 0xffff) == 0x0) )
++             return "andh\t%0, hi(%2), COH";
++         else
++             return "andh\t%0, hi(%2)\;andl\t%0, lo(%2)";
++    case 3:
++         return "and\t%0, %1, %2";
++    default:
++       abort();
++    }
++  }
++
++  [(set_attr "length" "2,4,8,4")
++   (set_attr "cc" "set_z")])
++
++
++(define_insn "anddi3"
++  [(set (match_operand:DI 0 "register_operand" "=&r,&r")
++      (and:DI (match_operand:DI 1 "register_operand" "%0,r")
++                (match_operand:DI 2 "register_operand" "r,r")))]
++  ""
++  "#"
++  [(set_attr "length" "8")
++   (set_attr "cc" "clobber")]
++)
++
++;;=============================================================================
++;; or
++;;-----------------------------------------------------------------------------
++;; Store the result after a bitwise inclusive-or between reg0 and reg2 in reg0.
++;;=============================================================================
++
++(define_insn "iorsi3"
++  [(set (match_operand:SI 0 "register_operand"          "=r,r,r")
++      (ior:SI (match_operand:SI 1 "register_operand"  "%0,0,r" )
++              (match_operand:SI 2 "nonmemory_operand" "r ,i,r")))]
++  ""
++  {
++   switch (which_alternative){
++    case 0:
++         return "or\t%0, %2";
++    case 1:
++         if ( one_bit_set_operand(operands[2], VOIDmode) ){
++             int bitpos;
++             for (bitpos = 0; bitpos < 32; bitpos++)
++               if (INTVAL(operands[2]) & (1 << bitpos))
++                 break;
++             operands[2] = gen_rtx_CONST_INT( SImode, bitpos);
++             return "sbr\t%0, %2";
++         } else if ( (INTVAL(operands[2]) >= 0) &&
++              (INTVAL(operands[2]) <= 65535) )
++             return "orl\t%0, %2";
++         else if ( ((INTVAL(operands[2]) & 0xffff) == 0x0) )
++             return "orh\t%0, hi(%2)";
++         else
++             return "orh\t%0, hi(%2)\;orl\t%0, lo(%2)";
++    case 2:
++         return "or\t%0, %1, %2";
++    default:
++       abort();
++    }
++  }
++  [(set_attr "length" "2,8,4")
++   (set_attr "cc" "set_z")])
++
++
++;(define_insn "iorsi3"
++;  [(set (match_operand:SI 0 "register_operand" "=r, r, r")
++;     (ior:SI (match_operand:SI 1 "avr32_logical_insn_operand" "r, r, rA" )
++;             (match_operand:SI 2 "register_operand" "0, i, r")))]
++;  ""
++;  {
++;   switch (which_alternative){
++;    case 0:
++;         return "or     %0, %2";
++;    case 1:
++;         if ( one_bit_set_operand(operands[2], VOIDmode) ){
++;             int i, bitpos;
++;             for ( i = 0; i < 32; i++ )
++;                if ( INTVAL(operands[2]) & (1 << i) ){
++;                   bitpos = i;
++;                   break;
++;                }
++;             operands[2] = gen_rtx_CONST_INT( SImode, bitpos);
++;             return "sbr    %0, %2";
++;         } else if ( (INTVAL(operands[2]) >= 0) &&
++;              (INTVAL(operands[2]) <= 65535) )
++;             return "orl    %0, %2";
++;         else if ( ((INTVAL(operands[2]) & 0xffff) == 0x0) )
++;             return "orh    %0, hi(%2)";
++;         else
++;             return "orh    %0, hi(%2)\;orl    %0, lo(%2)";
++;    case 2:
++;         return "or     %0, %2, %1";
++;    }
++;  }
++;  [(set_attr "length" "2,8,4")
++;   (set_attr "cc" "set_z")])
++
++(define_insn "iordi3"
++  [(set (match_operand:DI 0 "register_operand" "=&r,&r")
++      (ior:DI (match_operand:DI 1 "register_operand" "%0,r")
++                (match_operand:DI 2 "register_operand" "r,r")))]
++  ""
++  "#"
++  [(set_attr "length" "8")
++   (set_attr "cc" "clobber")]
++)
++
++;;=============================================================================
++;; xor bytes
++;;-----------------------------------------------------------------------------
++;; Store the result after a bitwise exclusive-or between reg0 and reg2 in reg0.
++;;=============================================================================
++
++(define_insn "xorsi3"
++  [(set (match_operand:SI 0 "register_operand" "=r,r,r")
++      (xor:SI (match_operand:SI 1 "register_operand" "0,0,r")
++              (match_operand:SI 2 "nonmemory_operand" "r,i,r")))]
++  ""
++  {
++   switch (which_alternative){
++    case 0:
++         return "eor     %0, %2";
++    case 1:
++         if ( (INTVAL(operands[2]) >= 0) &&
++              (INTVAL(operands[2]) <= 65535) )
++             return "eorl    %0, %2";
++         else if ( ((INTVAL(operands[2]) & 0xffff) == 0x0) )
++             return "eorh    %0, hi(%2)";
++         else
++             return "eorh    %0, hi(%2)\;eorl    %0, lo(%2)";
++    case 2:
++         return "eor     %0, %1, %2";
++    default:
++       abort();
++    }
++  }
++
++  [(set_attr "length" "2,8,4")
++   (set_attr "cc" "set_z")])
++
++(define_insn "xordi3"
++  [(set (match_operand:DI 0 "register_operand" "=&r,&r")
++      (xor:DI (match_operand:DI 1 "register_operand" "%0,r")
++                (match_operand:DI 2 "register_operand" "r,r")))]
++  ""
++  "#"
++  [(set_attr "length" "8")
++   (set_attr "cc" "clobber")]
++)
++
++;;=============================================================================
++;; divmod
++;;-----------------------------------------------------------------------------
++;; Signed division that produces both a quotient and a remainder.
++;;=============================================================================
++(define_expand "divmodsi4"
++  [(parallel [
++     (parallel [
++       (set (match_operand:SI 0 "register_operand" "=r")
++          (div:SI (match_operand:SI 1 "register_operand" "r")
++                  (match_operand:SI 2 "register_operand" "r")))
++       (set (match_operand:SI 3 "register_operand" "=r")
++          (mod:SI (match_dup 1)
++                  (match_dup 2)))])
++     (use (match_dup 4))])]
++  ""
++  {
++    if (! no_new_pseudos) {
++      operands[4] = gen_reg_rtx (DImode);
++
++      emit_insn(gen_divmodsi4_internal(operands[4],operands[1],operands[2]));
++      emit_move_insn(operands[0], gen_rtx_SUBREG( SImode, operands[4], 4));
++      emit_move_insn(operands[3], gen_rtx_SUBREG( SImode, operands[4], 0));
++
++      DONE;
++    } else {
++      FAIL;
++    }
++
++  })
++
++
++(define_insn "divmodsi4_internal"
++  [(set (match_operand:DI 0 "register_operand" "=r")
++      (unspec:DI [(match_operand:SI 1 "register_operand" "r")
++                  (match_operand:SI 2 "register_operand" "r")]
++                 UNSPEC_DIVMODSI4_INTERNAL))]
++  ""
++  "divs    %0, %1, %2"
++  [(set_attr "type" "div")
++   (set_attr "cc" "none")])
++
++
++;;=============================================================================
++;; udivmod
++;;-----------------------------------------------------------------------------
++;; Unsigned division that produces both a quotient and a remainder.
++;;=============================================================================
++(define_expand "udivmodsi4"
++ [(parallel [
++    (parallel [
++      (set (match_operand:SI 0 "register_operand" "=r")
++         (udiv:SI (match_operand:SI 1 "register_operand" "r")
++                  (match_operand:SI 2 "register_operand" "r")))
++      (set (match_operand:SI 3 "register_operand" "=r")
++         (umod:SI (match_dup 1)
++                  (match_dup 2)))])
++    (use (match_dup 4))])]
++  ""
++  {
++    if (! no_new_pseudos) {
++      operands[4] = gen_reg_rtx (DImode);
++
++      emit_insn(gen_udivmodsi4_internal(operands[4],operands[1],operands[2]));
++      emit_move_insn(operands[0], gen_rtx_SUBREG( SImode, operands[4], 4));
++      emit_move_insn(operands[3], gen_rtx_SUBREG( SImode, operands[4], 0));
++
++      DONE;
++    } else {
++      FAIL;
++    }
++  })
++
++(define_insn "udivmodsi4_internal"
++  [(set (match_operand:DI 0 "register_operand" "=r")
++      (unspec:DI [(match_operand:SI 1 "register_operand" "r")
++                  (match_operand:SI 2 "register_operand" "r")]
++                 UNSPEC_UDIVMODSI4_INTERNAL))]
++  ""
++  "divu    %0, %1, %2"
++  [(set_attr "type" "div")
++   (set_attr "cc" "none")])
++
++
++;;=============================================================================
++;; Arithmetic-shift left
++;;-----------------------------------------------------------------------------
++;; Arithmetic-shift reg0 left by reg2 or immediate value.
++;;=============================================================================
++
++(define_insn "ashlsi3"
++  [(set (match_operand:SI 0 "register_operand"           "=r,r,r")
++      (ashift:SI (match_operand:SI 1 "register_operand" "r,0,r")
++                 (match_operand:SI 2 "nonmemory_operand" "r,Ku05,Ku05")))]
++  ""
++  "@
++   lsl     %0, %1, %2
++   lsl     %0, %2
++   lsl     %0, %1, %2"
++  [(set_attr "length" "4,2,4")
++   (set_attr "cc" "set_ncz")])
++
++;;=============================================================================
++;; Arithmetic-shift right
++;;-----------------------------------------------------------------------------
++;; Arithmetic-shift reg0 right by an immediate value.
++;;=============================================================================
++
++(define_insn "ashrsi3"
++  [(set (match_operand:SI 0 "register_operand"             "=r,r,r")
++      (ashiftrt:SI (match_operand:SI 1 "register_operand" "r,0,r")
++                   (match_operand:SI 2 "nonmemory_operand" "r,Ku05,Ku05")))]
++  ""
++  "@
++   asr     %0, %1, %2
++   asr     %0, %2
++   asr     %0, %1, %2"
++  [(set_attr "length" "4,2,4")
++   (set_attr "cc" "set_ncz")])
++
++;;=============================================================================
++;; Logical shift right
++;;-----------------------------------------------------------------------------
++;; Logical shift reg0 right by an immediate value.
++;;=============================================================================
++
++(define_insn "lshrsi3"
++  [(set (match_operand:SI 0 "register_operand" "=r,r,r")
++      (lshiftrt:SI (match_operand:SI 1 "register_operand" "r,0,r")
++                   (match_operand:SI 2 "nonmemory_operand" "r,Ku05,Ku05")))]
++  ""
++  "@
++   lsr     %0, %1, %2
++   lsr     %0, %2
++   lsr     %0, %1, %2"
++  [(set_attr "length" "4,2,4")
++   (set_attr "cc" "set_ncz")])
++
++
++;;=============================================================================
++;; neg
++;;-----------------------------------------------------------------------------
++;; Negate operand 1 and store the result in operand 0.
++;;=============================================================================
++(define_insn "negsi2"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (neg:SI (match_operand:SI 1 "register_operand" "0")))]
++  ""
++  "neg     %0"
++  [(set_attr "length" "2")
++   (set_attr "cc" "set_vncz")])
++
++;;=============================================================================
++;; abs
++;;-----------------------------------------------------------------------------
++;; Store the absolute value of operand 1 into operand 0.
++;;=============================================================================
++(define_insn "abssi2"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (abs:SI (match_operand:SI 1 "register_operand" "0")))]
++  ""
++  "abs     %0"
++  [(set_attr "length" "2")
++   (set_attr "cc" "set_z")])
++
++
++;;=============================================================================
++;; one_cmpl
++;;-----------------------------------------------------------------------------
++;; Store the bitwise-complement of operand 1 into operand 0.
++;;=============================================================================
++
++(define_insn "one_cmplsi2"
++  [(set (match_operand:SI 0 "register_operand" "=r,r")
++      (not:SI (match_operand:SI 1 "register_operand" "r,0")))]
++  ""
++  "@
++   rsub    %0, %1, -1
++   com     %0"
++  [(set_attr "length" "4,2")
++   (set_attr "cc" "set_z")])
++
++
++;;=============================================================================
++;; Bit load
++;;-----------------------------------------------------------------------------
++;; Load a bit into Z and C flags
++;;=============================================================================
++(define_insn "bldsi"
++  [(set (cc0)
++        (and:SI (match_operand:SI 0 "register_operand" "r")
++                (match_operand:SI 1 "one_bit_set_operand" "i")))]
++  ""
++  "bld\t%0, %p1"
++  [(set_attr "length" "4")
++   (set_attr "cc" "bld")]
++  )
++
++
++;;=============================================================================
++;; Compare
++;;-----------------------------------------------------------------------------
++;; Compare reg0 with reg1 or an immediate value.
++;;=============================================================================
++
++(define_expand "cmpqi"
++  [(set (cc0)
++      (compare:QI
++       (match_operand:QI 0 "general_operand" "")
++       (match_operand:QI 1 "general_operand"  "")))]
++  ""
++  "{
++
++   if ( GET_CODE(operands[0]) != REG
++        && GET_CODE(operands[0]) != SUBREG)
++     operands[0] = force_reg(QImode, operands[0]);
++
++
++   if ( GET_CODE(operands[1]) != REG
++        && GET_CODE(operands[1]) != SUBREG )
++     operands[1] = force_reg(QImode, operands[1]);
++
++   avr32_compare_op0 = operands[0];
++   avr32_compare_op1 = operands[1];
++   emit_insn(gen_cmpqi_internal(operands[0], operands[1]));
++   DONE;
++  }"
++)
++
++(define_insn "cmpqi_internal"
++  [(set (cc0)
++        (compare:QI
++         (match_operand:QI 0 "register_operand" "r")
++         (match_operand:QI 1 "register_operand" "r")))]
++  ""
++  {
++   set_next_insn_cond(insn,
++                      avr32_output_cmp(get_next_insn_cond(insn), QImode, operands[0], operands[1]));
++   return "";
++  }
++  [(set_attr "length" "4")
++   (set_attr "cc" "compare")])
++
++(define_expand "cmphi"
++  [(set (cc0)
++      (compare:HI
++       (match_operand:HI 0 "general_operand" "")
++       (match_operand:HI 1 "general_operand"  "")))]
++  ""
++  "{
++   if ( GET_CODE(operands[0]) != REG
++        && GET_CODE(operands[0]) != SUBREG )
++     operands[0] = force_reg(HImode, operands[0]);
++
++
++   if ( GET_CODE(operands[1]) != REG
++        && GET_CODE(operands[1]) != SUBREG)
++     operands[1] = force_reg(HImode, operands[1]);
++
++   avr32_compare_op0 = operands[0];
++   avr32_compare_op1 = operands[1];
++   emit_insn(gen_cmphi_internal(operands[0], operands[1]));
++   DONE;
++  }"
++)
++
++
++(define_insn "cmphi_internal"
++  [(set (cc0)
++        (compare:HI
++         (match_operand:HI 0 "register_operand" "r")
++         (match_operand:HI 1 "register_operand" "r")))]
++  ""
++  {
++   set_next_insn_cond(insn,
++     avr32_output_cmp(get_next_insn_cond(insn), HImode, operands[0], operands[1]));
++   return "";
++  }
++  [(set_attr "length" "4")
++   (set_attr "cc" "compare")])
++
++
++(define_expand "cmpsi"
++  [(set (cc0)
++      (compare:SI
++       (match_operand:SI 0 "general_operand" "")
++       (match_operand:SI 1 "general_operand"  "")))]
++  ""
++  "{
++   if ( GET_CODE(operands[0]) != REG
++        && GET_CODE(operands[0]) != SUBREG )
++     operands[0] = force_reg(SImode, operands[0]);
++
++   if ( GET_CODE(operands[1]) != REG
++        && GET_CODE(operands[1]) != SUBREG
++        && GET_CODE(operands[1]) != CONST_INT )
++     operands[1] = force_reg(SImode, operands[1]);
++
++   avr32_compare_op0 = operands[0];
++   avr32_compare_op1 = operands[1];
++
++
++   emit_insn(gen_cmpsi_internal(operands[0], operands[1]));
++   DONE;
++  }"
++)
++
++
++
++
++(define_insn "cmpsi_internal"
++  [(set (cc0)
++      (compare:SI
++       (match_operand:SI 0 "register_operand" "r, r, r")
++       (match_operand:SI 1 "nonmemory_operand"  "r, Ks06, Ks21")))]
++  ""
++  {
++   set_next_insn_cond(insn,
++     avr32_output_cmp(get_next_insn_cond(insn), SImode, operands[0], operands[1]));
++   return "";
++  }
++
++  [(set_attr "length" "2,2,4")
++   (set_attr "cc" "compare")])
++
++
++(define_expand "cmpdi"
++  [(set (cc0)
++      (compare:DI
++       (match_operand:DI 0 "register_operand" "")
++       (match_operand:DI 1 "register_operand"  "")))]
++  ""
++  {
++   avr32_compare_op0 = operands[0];
++   avr32_compare_op1 = operands[1];
++   emit_insn(gen_cmpdi_internal(operands[0], operands[1]));
++   DONE;
++  }
++)
++
++(define_insn "cmpdi_internal"
++  [(set (cc0)
++      (compare:DI
++       (match_operand:DI 0 "register_operand" "r")
++       (match_operand:DI 1 "register_operand"  "r")))]
++  ""
++  {
++   set_next_insn_cond(insn,
++     avr32_output_cmp(get_next_insn_cond(insn), DImode, operands[0], operands[1]));
++   return "";
++  }
++
++  [(set_attr "length" "6")
++   (set_attr "type" "alu2")
++   (set_attr "cc" "compare")])
++
++
++
++;;=============================================================================
++;; Test if zero
++;;-----------------------------------------------------------------------------
++;; Compare reg against zero and set the condition codes.
++;;=============================================================================
++
++
++(define_expand "tstsi"
++  [(set (cc0)
++      (match_operand:SI 0 "register_operand" ""))]
++  ""
++  {
++   avr32_compare_op0 = operands[0];
++   avr32_compare_op1 = gen_rtx_CONST_INT(SImode, 0);
++   emit_insn(gen_tstsi_internal(operands[0]));
++   DONE;
++  }
++)
++
++(define_insn "tstsi_internal"
++  [(set (cc0)
++      (match_operand:SI 0 "register_operand" "r"))]
++  ""
++  {
++   set_next_insn_cond(insn,
++     avr32_output_cmp(get_next_insn_cond(insn), SImode, operands[0], const0_rtx));
++
++   return "";
++  }
++  [(set_attr "length" "2")
++   (set_attr "cc" "compare")])
++
++
++(define_expand "tstdi"
++  [(set (cc0)
++      (match_operand:DI 0 "register_operand" ""))]
++  ""
++  {
++   avr32_compare_op0 = operands[0];
++   avr32_compare_op1 = gen_rtx_CONST_INT(DImode, 0);
++   emit_insn(gen_tstdi_internal(operands[0]));
++   DONE;
++  }
++)
++
++(define_insn "tstdi_internal"
++  [(set (cc0)
++      (match_operand:DI 0 "register_operand" "r"))]
++  ""
++  {
++   set_next_insn_cond(insn,
++     avr32_output_cmp(get_next_insn_cond(insn), DImode, operands[0], const0_rtx));
++   return "";
++  }
++  [(set_attr "length" "4")
++   (set_attr "type" "alu2")
++   (set_attr "cc" "compare")])
++
++
++
++;;=============================================================================
++;; Convert operands
++;;-----------------------------------------------------------------------------
++;;
++;;=============================================================================
++(define_insn "truncdisi2"
++  [(set (match_operand:SI 0 "general_operand" "")
++      (truncate:SI (match_operand:DI 1 "general_operand" "")))]
++  ""
++  "truncdisi2")
++
++;;=============================================================================
++;; Extend
++;;-----------------------------------------------------------------------------
++;;
++;;=============================================================================
++
++
++(define_insn "extendhisi2"
++  [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
++      (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "0,r,<RKu00>,m")))]
++  ""
++  {
++   switch ( which_alternative ){
++     case 0:
++       return    "casts.h\t%0";
++     case 1:
++       return    "bfexts\t%0, %1, 0, 16";
++     case 2:
++     case 3:
++       return    "ld.sh\t%0, %1";
++     default:
++       abort();
++   }
++  }
++  [(set_attr "length" "2,4,2,4")
++   (set_attr "cc" "set_ncz,set_ncz,none,none")
++   (set_attr "type" "alu,alu,load_rm,load_rm")])
++
++(define_insn "extendqisi2"
++  [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
++      (sign_extend:SI (match_operand:QI 1 "extendqi_operand" "0,r,RKu00,m")))]
++  ""
++  {
++   switch ( which_alternative ){
++     case 0:
++       return    "casts.b\t%0";
++     case 1:
++       return    "bfexts\t%0, %1, 0, 8";
++     case 2:
++     case 3:
++       return    "ld.sb\t%0, %1";
++     default:
++       abort();
++   }
++  }
++  [(set_attr "length" "2,4,2,4")
++   (set_attr "cc" "set_ncz,set_ncz,none,none")
++   (set_attr "type" "alu,alu,load_rm,load_rm")])
++
++(define_insn "extendqihi2"
++  [(set (match_operand:HI 0 "register_operand" "=r,r,r,r")
++      (sign_extend:HI (match_operand:QI 1 "extendqi_operand" "0,r,RKu00,m")))]
++  ""
++  {
++   switch ( which_alternative ){
++     case 0:
++       return    "casts.b\t%0";
++     case 1:
++       return    "bfexts\t%0, %1, 0, 8";
++     case 2:
++     case 3:
++       return    "ld.sb\t%0, %1";
++     default:
++       abort();
++   }
++  }
++  [(set_attr "length" "2,4,2,4")
++   (set_attr "cc" "set_ncz,set_ncz,none,none")
++   (set_attr "type" "alu,alu,load_rm,load_rm")])
++
++
++;;=============================================================================
++;; Zero-extend
++;;-----------------------------------------------------------------------------
++;;
++;;=============================================================================
++
++(define_insn "zero_extendhisi2"
++  [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
++      (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "0,r,<RKu00>,m")))]
++  ""
++  {
++   switch ( which_alternative ){
++     case 0:
++       return    "castu.h\t%0";
++     case 1:
++       return    "bfextu\t%0, %1, 0, 16";
++     case 2:
++     case 3:
++       return    "ld.uh\t%0, %1";
++     default:
++       abort();
++   }
++  }
++
++  [(set_attr "length" "2,4,2,4")
++   (set_attr "cc" "set_ncz,set_ncz,none,none")
++   (set_attr "type" "alu,alu,load_rm,load_rm")])
++
++(define_insn "zero_extendqisi2"
++  [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
++      (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "0,r,<RKu00>,m")))]
++  ""
++  {
++   switch ( which_alternative ){
++     case 0:
++       return    "castu.b\t%0";
++     case 1:
++       return    "bfextu\t%0, %1, 0, 8";
++     case 2:
++     case 3:
++       return    "ld.ub\t%0, %1";
++     default:
++       abort();
++   }
++  }
++  [(set_attr "length" "2,4,2,4")
++   (set_attr "cc" "set_ncz, set_ncz, none, none")
++   (set_attr "type" "alu, alu, load_rm, load_rm")])
++
++(define_insn "zero_extendqihi2"
++  [(set (match_operand:HI 0 "register_operand" "=r,r,r,r")
++      (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "0,r,<RKu00>,m")))]
++  ""
++  {
++   switch ( which_alternative ){
++     case 0:
++       return    "castu.b\t%0";
++     case 1:
++       return    "bfextu\t%0, %1, 0, 8";
++     case 2:
++     case 3:
++       return    "ld.ub\t%0, %1";
++     default:
++       abort();
++   }
++  }
++  [(set_attr "length" "2,4,2,4")
++   (set_attr "cc" "set_ncz, set_ncz, none, none")
++   (set_attr "type" "alu, alu, load_rm, load_rm")])
++
++
++
++;;=============================================================================
++;; Conditional set register
++;; sr{cond4}  rd
++;;-----------------------------------------------------------------------------
++
++;;Because of the same issue as with conditional moves and adds we must
++;;not separate the compare instrcution from the scc instruction as
++;;they might be sheduled "badly".
++
++(define_expand "s<code>"
++  [(set (match_operand:SI 0 "register_operand" "")
++      (any_cond (cc0)
++            (const_int 0)))]
++  ""
++  {
++   if ( !avr32_expand_scc(<CODE>, operands) ){
++      FAIL;
++   }
++   DONE;
++  }
++  )
++
++
++(define_insn "comparesi_and_set"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (match_operator 1 "avr32_comparison_operator"
++                        [ (compare (match_operand:SI 2 "register_operand" "r")
++                                   (match_operand:SI 3 "general_operand" "rKs06Ks21"))
++                          (const_int 0)]))]
++  ""
++  {
++   operands[1] = avr32_output_cmp(operands[1], GET_MODE(operands[2]), operands[2], operands[3]);
++   return "sr%1\t%0";
++   }
++  [(set_attr "length" "6")
++   (set_attr "cc" "clobber")])
++
++(define_insn "comparehi_and_set"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (match_operator 1 "avr32_comparison_operator"
++                        [ (compare (match_operand:HI 2 "register_operand" "r")
++                                      (match_operand:HI 3 "register_operand" "r"))
++                          (const_int 0)]))]
++  ""
++  {
++   operands[1] = avr32_output_cmp(operands[1], GET_MODE(operands[2]), operands[2], operands[3]);
++   return "sr%1\t%0";
++  }
++  [(set_attr "length" "6")
++   (set_attr "cc" "clobber")])
++
++(define_insn "compareqi_and_set"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (match_operator 1 "avr32_comparison_operator"
++                        [ (compare (match_operand:QI 2 "register_operand" "r")
++                                      (match_operand:QI 3 "register_operand" "r"))
++                          (const_int 0)]))]
++  ""
++  {
++   operands[1] = avr32_output_cmp(operands[1], GET_MODE(operands[2]), operands[2], operands[3]);
++   return "sr%1\t%0";
++  }
++  [(set_attr "length" "6")
++   (set_attr "cc" "clobber")])
++
++(define_insn "*comparedi_and_set"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (match_operator 1 "avr32_comparison_operator"
++                        [ (compare (match_operand:DI 2 "register_operand" "r")
++                                      (match_operand:DI 3 "register_operand" "r"))
++                          (const_int 0)]))]
++  ""
++  {
++   operands[1] = avr32_output_cmp(operands[1], GET_MODE(operands[2]), operands[2], operands[3]);
++   return "sr%1\t%0";
++  }
++  [(set_attr "length" "6")
++   (set_attr "cc" "clobber")])
++
++(define_insn "*tstdi_and_set"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (match_operator 1 "avr32_comparison_operator"
++                        [ (compare (match_operand:DI 2 "register_operand" "r")
++                                   (const_int 0))
++                          (const_int 0)]))]
++  ""
++  {
++   operands[1] = avr32_output_cmp(operands[1], GET_MODE(operands[2]), operands[2], const0_rtx);
++   return "sr%1\t%0";
++  }
++  [(set_attr "length" "6")
++   (set_attr "cc" "clobber")])
++
++
++
++;;=============================================================================
++;; Conditional branch
++;;-----------------------------------------------------------------------------
++;; Branch to label if the specified condition codes are set.
++;;=============================================================================
++; branch if negative
++(define_insn "bmi"
++  [(set (pc)
++      (if_then_else (unspec:CC [(cc0) (const_int 0)] UNSPEC_COND_MI)
++                    (label_ref (match_operand 0 "" ""))
++                    (pc)))]
++  ""
++  "brmi    %0"
++  [(set_attr "type" "branch")
++   (set (attr "length")
++      (cond [(and (le (minus (match_dup 0) (pc)) (const_int 254))
++                  (le (minus (pc) (match_dup 0)) (const_int 256)))
++             (const_int 2)] ; use compact branch
++              (const_int 4))) ; use extended branch
++   (set_attr "cc" "none")])
++
++(define_insn "*bmi-reverse"
++  [(set (pc)
++      (if_then_else (unspec:CC [(cc0) (const_int 0)] UNSPEC_COND_MI)
++                    (pc)
++                    (label_ref (match_operand 0 "" ""))))]
++  ""
++  "brpl    %0"
++  [(set_attr "type" "branch")
++   (set (attr "length")
++      (cond [(and (le (minus (match_dup 0) (pc)) (const_int 254))
++                  (le (minus (pc) (match_dup 0)) (const_int 256)))
++             (const_int 2)] ; use compact branch
++              (const_int 4))) ; use extended branch
++   (set_attr "cc" "none")])
++
++; branch if positive
++(define_insn "bpl"
++  [(set (pc)
++      (if_then_else (unspec:CC [(cc0) (const_int 0)] UNSPEC_COND_PL)
++                    (label_ref (match_operand 0 "" ""))
++                    (pc)))]
++  ""
++  "brpl    %0"
++  [(set_attr "type" "branch")
++   (set (attr "length")
++      (cond [(and (le (minus (match_dup 0) (pc)) (const_int 254))
++                  (le (minus (pc) (match_dup 0)) (const_int 256)))
++             (const_int 2)] ; use compact branch
++              (const_int 4))) ; use extended branch
++   (set_attr "cc" "none")])
++
++(define_insn "*bpl-reverse"
++  [(set (pc)
++      (if_then_else (unspec:CC [(cc0) (const_int 0)] UNSPEC_COND_PL)
++                    (pc)
++                    (label_ref (match_operand 0 "" ""))))]
++  ""
++  "brmi    %0"
++  [(set_attr "type" "branch")
++   (set (attr "length")
++      (cond [(and (le (minus (match_dup 0) (pc)) (const_int 254))
++                  (le (minus (pc) (match_dup 0)) (const_int 256)))
++             (const_int 2)] ; use compact branch
++              (const_int 4))) ; use extended branch
++   (set_attr "cc" "none")])
++
++; branch if equal
++(define_insn "b<code>"
++  [(set (pc)
++      (if_then_else (any_cond:CC (cc0)
++                        (const_int 0))
++                    (label_ref (match_operand 0 "" ""))
++                    (pc)))]
++  ""
++  "br<cond>    %0 "
++  [(set_attr "type" "branch")
++   (set (attr "length")
++      (cond [(and (le (minus (match_dup 0) (pc)) (const_int 254))
++                  (le (minus (pc) (match_dup 0)) (const_int 256)))
++             (const_int 2)] ; use compact branch
++              (const_int 4))) ; use extended branch
++   (set_attr "cc" "none")])
++
++
++(define_insn "*b<code>-reverse"
++  [(set (pc)
++      (if_then_else (any_cond:CC (cc0)
++                        (const_int 0))
++                    (pc)
++                    (label_ref (match_operand 0 "" ""))))]
++  ""
++  "br<invcond>    %0 "
++  [(set_attr "type" "branch")
++   (set (attr "length")
++      (cond [(and (le (minus (match_dup 0) (pc)) (const_int 254))
++                  (le (minus (pc) (match_dup 0)) (const_int 256)))
++             (const_int 2)] ; use compact branch
++              (const_int 4))) ; use extended branch
++   (set_attr "cc" "none")])
++
++
++
++;=============================================================================
++; Conditional Add/Subtract
++;-----------------------------------------------------------------------------
++; sub{cond4}  Rd, imm
++;=============================================================================
++
++
++(define_expand "add<mode>cc"
++  [(set (match_operand:ADDCC 0 "register_operand" "")
++      (if_then_else:ADDCC (match_operand 1 "avr32_comparison_operator" "")
++                         (match_operand:ADDCC 2 "register_immediate_operand" "")
++                         (match_operand:ADDCC 3 "register_immediate_operand" "")))]
++  ""
++  {
++   if ( avr32_expand_addcc(<MODE>mode, operands ) )
++      DONE;
++   else
++      FAIL;
++  }
++  )
++
++
++(define_insn "add<ADDCC:mode>cc_cmp<CMP:mode>"
++  [(set (match_operand:ADDCC 0 "register_operand" "=&r")
++      (unspec:ADDCC [(match_operand 1 "avr32_comparison_operator" "")
++                       (match_operand:ADDCC 2 "register_operand" "0")
++                       (match_operand:ADDCC 3 "immediate_operand" "Ks08")
++                       (match_operand:CMP 4 "register_operand" "r")
++                       (match_operand:CMP 5 "<CMP:cmp_predicate>" "<CMP:cmp_constraint>")
++                       ]
++                      UNSPEC_ADDSICC ))]
++  ""
++  {
++   operands[1] = avr32_output_cmp(operands[1], GET_MODE(operands[4]), operands[4], operands[5]);
++
++   return "sub%1\t%0, %3";
++  }
++  [(set_attr "length" "8")
++   (set_attr "cc" "clobber")])
++
++
++;=============================================================================
++; Conditional Move
++;-----------------------------------------------------------------------------
++; mov{cond4}  Rd, (Rs/imm)
++;=============================================================================
++(define_expand "mov<mode>cc"
++  [(set (match_operand:ADDCC 0 "register_operand" "")
++      (if_then_else:ADDCC (match_operand 1 "avr32_comparison_operator" "")
++                            (match_operand:ADDCC 2 "register_immediate_operand" "")
++                            (match_operand:ADDCC 3 "register_immediate_operand" "")))]
++  ""
++  {
++   if ( avr32_expand_movcc(<MODE>mode, operands ) )
++      DONE;
++   else
++      FAIL;
++  }
++  )
++
++(define_insn "mov<MOVCC:mode>cc_cmp<CMP:mode>"
++  [(set (match_operand:MOVCC 0 "register_operand" "=r,r,r")
++      (unspec:MOVCC [(match_operand 1 "avr32_comparison_operator" "")
++                       (match_operand:MOVCC 2 "register_immediate_operand" "0,rKs08,rKs08")
++                       (match_operand:MOVCC 3 "register_immediate_operand" "rKs08,0,rKs08")
++                       (match_operand:CMP 4 "register_operand" "r, r, r")
++                       (match_operand:CMP 5 "<CMP:cmp_predicate>" "<CMP:cmp_constraint>, <CMP:cmp_constraint>, <CMP:cmp_constraint>")
++                       ]
++                      UNSPEC_MOVSICC ))]
++  ""
++  {
++   operands[1] = avr32_output_cmp(operands[1], GET_MODE(operands[4]), operands[4], operands[5]);
++
++   switch( which_alternative ){
++    case 0:
++      return "mov%i1    %0, %3";
++    case 1:
++      return "mov%1    %0, %2";
++    case 2:
++      return "mov%1    %0, %2\;mov%i1    %0, %3";
++    default:
++      abort();
++    }
++
++
++  }
++  [(set_attr "length" "8,8,12")
++   (set_attr "cc" "clobber")])
++
++
++;;=============================================================================
++;; jump
++;;-----------------------------------------------------------------------------
++;; Jump inside a function; an unconditional branch to a label.
++;;=============================================================================
++(define_insn "jump"
++  [(set (pc)
++      (label_ref (match_operand 0 "" "")))]
++  ""
++  {
++    if (get_attr_length(insn) > 4)
++      return "Can't jump this far";
++    return (get_attr_length(insn) == 2 ?
++          "rjmp    %0" : "bral    %0");
++  }
++  [(set_attr "type" "branch")
++   (set (attr "length")
++      (cond [(and (le (minus (match_dup 0) (pc)) (const_int 1022))
++                  (le (minus (pc) (match_dup 0)) (const_int 1024)))
++             (const_int 2) ; use rjmp
++             (le (match_dup 0) (const_int 1048575))
++             (const_int 4)] ; use bral
++            (const_int 8))) ; do something else
++   (set_attr "cc" "none")])
++
++;;=============================================================================
++;; call
++;;-----------------------------------------------------------------------------
++;; Subroutine call instruction returning no value.
++;;=============================================================================
++(define_insn "call_internal"
++  [(parallel [(call (mem:SI (match_operand:SI 0 "avr32_call_operand" "r,U,T,W"))
++                    (match_operand 1 "" ""))
++              (clobber (reg:SI LR_REGNUM))])]
++  ""
++  {
++   switch (which_alternative){
++    case 0:
++      return "icall\t%0";
++    case 1:
++      return "rcall\t%0";
++    case 2:
++      return "mcall\t%0";
++    case 3:
++      if ( TARGET_HAS_ASM_ADDR_PSEUDOS )
++        return "call\t%0";
++      else
++        return "mcall\tr6[%0@got]";
++    default:
++      abort();
++   }
++  }
++  [(set_attr "type" "call")
++   (set_attr "length" "2,4,4,10")
++   (set_attr "cc" "clobber")])
++
++
++(define_expand "call"
++  [(parallel [(call (match_operand:SI 0 "" "")
++                    (match_operand 1 "" ""))
++              (clobber (reg:SI LR_REGNUM))])]
++  ""
++  {
++   rtx call_address;
++   if ( GET_CODE(operands[0]) != MEM )
++      FAIL;
++
++   call_address = XEXP(operands[0], 0);
++
++   /* If assembler supports call pseudo insn and the call
++      address is a symbol then nothing special needs to be done. */
++   if ( TARGET_HAS_ASM_ADDR_PSEUDOS
++        && (GET_CODE(call_address) == SYMBOL_REF) ){
++      /* We must however mark the function as using the GOT if
++         flag_pic is set, since the call insn might turn into
++         a mcall using the GOT ptr register. */
++      if ( flag_pic ){
++         current_function_uses_pic_offset_table = 1;
++         emit_call_insn(gen_call_internal(call_address, operands[1]));
++         DONE;
++      }
++   } else {
++     if ( flag_pic &&
++          GET_CODE(call_address) == SYMBOL_REF ){
++       current_function_uses_pic_offset_table = 1;
++       emit_call_insn(gen_call_internal(call_address, operands[1]));
++       DONE;
++     }
++
++     if ( !SYMBOL_REF_RCALL_FUNCTION_P(operands[0]) ){
++       if ( optimize_size &&
++             GET_CODE(call_address) == SYMBOL_REF ){
++         call_address = force_const_mem(SImode, call_address);
++       } else {
++         call_address = force_reg(SImode, call_address);
++       }
++     }
++   }
++   emit_call_insn(gen_call_internal(call_address, operands[1]));
++   DONE;
++  }
++)
++
++;;=============================================================================
++;; call_value
++;;-----------------------------------------------------------------------------
++;; Subrutine call instruction returning a value.
++;;=============================================================================
++(define_expand "call_value"
++   [(parallel [(set (match_operand:SI 0 "" "")
++                    (call (match_operand:SI 1 "" "")
++                          (match_operand 2 "" "")))
++               (clobber (reg:SI LR_REGNUM))])]
++   ""
++   {
++    rtx call_address;
++    if ( GET_CODE(operands[1]) != MEM )
++      FAIL;
++
++    call_address = XEXP(operands[1], 0);
++
++    /* If assembler supports call pseudo insn and the call
++       address is a symbol then nothing special needs to be done. */
++    if ( TARGET_HAS_ASM_ADDR_PSEUDOS
++         && (GET_CODE(call_address) == SYMBOL_REF) ){
++       /* We must however mark the function as using the GOT if
++          flag_pic is set, since the call insn might turn into
++          a mcall using the GOT ptr register. */
++       if ( flag_pic ) {
++          current_function_uses_pic_offset_table = 1;
++          emit_call_insn(gen_call_value_internal(operands[0], call_address, operands[2]));
++          DONE;
++       }
++    } else {
++      if ( flag_pic &&
++           GET_CODE(call_address) == SYMBOL_REF ){
++        current_function_uses_pic_offset_table = 1;
++        emit_call_insn(gen_call_value_internal(operands[0], call_address, operands[2]));
++        DONE;
++      }
++
++      if ( !SYMBOL_REF_RCALL_FUNCTION_P(operands[1]) ){
++        if ( optimize_size &&
++             GET_CODE(call_address) == SYMBOL_REF){
++          call_address = force_const_mem(SImode, call_address);
++        } else {
++          call_address = force_reg(SImode, call_address);
++        }
++      }
++    }
++    emit_call_insn(gen_call_value_internal(operands[0], call_address,
++                                           operands[2]));
++    DONE;
++
++   })
++
++(define_insn "call_value_internal"
++  [(parallel [(set (match_operand 0 "register_operand" "=r,r,r,r")
++                   (call (mem:SI (match_operand:SI 1 "avr32_call_operand" "r,U,T,W"))
++                         (match_operand 2 "" "")))
++              (clobber (reg:SI LR_REGNUM))])]
++  ;; Operand 2 not used on the AVR32.
++  ""
++  {
++   switch (which_alternative){
++    case 0:
++      return "icall\t%1";
++    case 1:
++      return "rcall\t%1";
++    case 2:
++      return "mcall\t%1";
++    case 3:
++      if ( TARGET_HAS_ASM_ADDR_PSEUDOS )
++        return "call\t%1";
++      else
++        return "mcall\tr6[%1@got]";
++    default:
++      abort();
++   }
++  }
++  [(set_attr "type" "call")
++   (set_attr "length" "2,4,4,10")
++   (set_attr "cc" "call_set")])
++
++
++;;=============================================================================
++;; untyped_call
++;;-----------------------------------------------------------------------------
++;; Subrutine call instruction returning a value of any type.
++;; The code is copied from m68k.md (except gen_blockage is removed)
++;; Fixme!
++;;=============================================================================
++(define_expand "untyped_call"
++  [(parallel [(call (match_operand 0 "avr32_call_operand" "")
++                  (const_int 0))
++            (match_operand 1 "" "")
++            (match_operand 2 "" "")])]
++  ""
++  {
++    int i;
++
++    emit_call_insn (GEN_CALL (operands[0], const0_rtx, NULL, const0_rtx));
++
++    for (i = 0; i < XVECLEN (operands[2], 0); i++) {
++      rtx set = XVECEXP (operands[2], 0, i);
++      emit_move_insn (SET_DEST (set), SET_SRC (set));
++    }
++
++    /* The optimizer does not know that the call sets the function value
++       registers we stored in the result block.  We avoid problems by
++       claiming that all hard registers are used and clobbered at this
++       point.  */
++    emit_insn (gen_blockage ());
++
++    DONE;
++  })
++
++
++;;=============================================================================
++;; return
++;;=============================================================================
++
++(define_insn "return"
++  [(return)]
++  "USE_RETURN_INSN (FALSE)"
++  {
++   avr32_output_return_instruction(TRUE, FALSE, NULL, NULL);
++   return "";
++  }
++  [(set_attr "length" "4")
++   (set_attr "type" "call")]
++  )
++
++(define_insn "*return_value_imm"
++  [(parallel [(set (reg RETVAL_REGNUM) (match_operand 0 "immediate_operand" "i"))
++              (use (reg RETVAL_REGNUM))
++              (return)])]
++  "USE_RETURN_INSN (FALSE) &&
++   ((INTVAL(operands[0]) == -1) || (INTVAL(operands[0]) == 0) || (INTVAL(operands[0]) == 1))"
++  {
++   avr32_output_return_instruction(TRUE, FALSE, NULL, operands[0]);
++   return "";
++  }
++  [(set_attr "length" "4")
++   (set_attr "type" "call")]
++  )
++
++(define_insn "*return_value_si"
++  [(set (reg RETVAL_REGNUM) (match_operand:SI 0 "register_operand" "r"))
++   (use (reg RETVAL_REGNUM))
++   (return)]
++  "USE_RETURN_INSN (TRUE)"
++  "retal    %0";
++  [(set_attr "type" "call")]
++  )
++
++(define_insn "*return_value_hi"
++  [(parallel [(set (reg RETVAL_REGNUM) (match_operand:HI 0 "register_operand" "r"))
++              (use (reg RETVAL_REGNUM))
++              (return)])]
++  "USE_RETURN_INSN (TRUE)"
++  "retal    %0"
++  [(set_attr "type" "call")]
++  )
++
++(define_insn "*return_value_qi"
++  [(parallel [(set (reg RETVAL_REGNUM) (match_operand:QI 0 "register_operand" "r"))
++              (use (reg RETVAL_REGNUM))
++              (return)])]
++  "USE_RETURN_INSN (TRUE)"
++  "retal    %0"
++  [(set_attr "type" "call")]
++  )
++
++;;=============================================================================
++;; nop
++;;-----------------------------------------------------------------------------
++;; No-op instruction.
++;;=============================================================================
++(define_insn "nop"
++  [(const_int 0)]
++  ""
++  "nop"
++  [(set_attr "length" "2")
++   (set_attr "type" "alu")
++   (set_attr "cc" "none")])
++
++;;=============================================================================
++;; nonlocal_goto
++;;-----------------------------------------------------------------------------
++;; Jump from one function to a label in an outer function.
++;; Must invalidate return stack, since the function will be exited without
++;; a return
++;;=============================================================================
++(define_expand "nonlocal_goto"
++  [(use (match_operand 0 "" ""))
++   (use (match_operand 1 "" ""))
++   (use (match_operand 2 "" ""))
++   (use (match_operand 3 "" ""))]
++  ""
++  {
++   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__nonlocal_goto"),
++                   0, VOIDmode, 3,
++                   operands[0], SImode,
++                   operands[1], Pmode,
++                     operands[2], SImode);
++
++   DONE;
++   }
++)
++
++
++(define_expand "builtin_longjmp"
++  [(use (match_operand 0 "" ""))]
++  ""
++  {
++   rtx ops[3];
++
++   ops[0] = gen_rtx_MEM (Pmode, gen_rtx_PLUS(SImode, operands[0], gen_rtx_CONST_INT(SImode,0)));
++   ops[1] = gen_rtx_MEM (Pmode, gen_rtx_PLUS(SImode, operands[0], gen_rtx_CONST_INT(SImode,4)));
++   ops[2] = gen_rtx_MEM (Pmode, gen_rtx_PLUS(SImode, operands[0], gen_rtx_CONST_INT(SImode,8)));
++
++
++   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__nonlocal_goto"),
++                   0, VOIDmode, 3,
++                   ops[0], SImode,
++                   ops[1], Pmode,
++                     ops[2], SImode);
++
++   DONE;
++   }
++  )
++
++
++;;=============================================================================
++;; indirect_jump
++;;-----------------------------------------------------------------------------
++;; Jump to an address in reg or memory.
++;;=============================================================================
++(define_expand "indirect_jump"
++  [(set (pc)
++      (match_operand:SI 0 "general_operand" "r,m"))]
++  ""
++  {
++    /* One of the ops has to be in a register.  */
++    if ( (flag_pic || TARGET_HAS_ASM_ADDR_PSEUDOS )
++         && !avr32_legitimate_pic_operand_p(operands[0]) )
++      operands[0] = legitimize_pic_address (operands[0], SImode, 0);
++    else if ( flag_pic && avr32_address_operand(operands[0], GET_MODE(operands[0])) )
++      /* If we have an address operand then this function uses the pic register. */
++      current_function_uses_pic_offset_table = 1;
++  })
++
++
++(define_insn "indirect_jump_internal"
++  [(set (pc)
++      (match_operand:SI 0 "general_operand" "r,m,W"))]
++  ""
++  {
++    switch( which_alternative ){
++      case 0:
++        return "mov\tpc, %0";
++      case 1:
++        if ( avr32_const_pool_ref_operand(operands[0], GET_MODE(operands[0])) )
++          return "lddpc\tpc, %0";
++        else
++          return "ld.w\tpc, %0";
++      case 2:
++        if ( flag_pic )
++          return "ld.w\tpc, r6[%0@got]";
++        else
++          return "lda.w\tpc, %0";
++      default:
++      abort();
++    }
++   }
++  [(set_attr "length" "2,4,8")
++   (set_attr "type" "call,call,call")
++   (set_attr "cc" "none,none,clobber")])
++
++
++;;=============================================================================
++;; casesi
++;;=============================================================================
++
++
++(define_expand "casesi"
++  [(match_operand:SI 0 "register_operand" "") ; index to jump on
++   (match_operand:SI 1 "const_int_operand" "")        ; lower bound
++   (match_operand:SI 2 "const_int_operand" "")        ; total range
++   (match_operand:SI 3 "" "")                 ; table label
++   (match_operand:SI 4 "" "")]                        ; Out of range label
++  ""
++  "
++  {
++    rtx reg;
++    if (operands[1] != const0_rtx)
++      {
++        if (!avr32_const_ok_for_constraint_p(INTVAL (operands[1]), 'I', \"Is21\")){
++          reg = force_reg(SImode, GEN_INT (INTVAL (operands[1])));
++        emit_insn (gen_subsi3 (reg, operands[0],
++                               reg));
++        } else {
++          reg = gen_reg_rtx (SImode);
++          emit_insn (gen_addsi3 (reg, operands[0],
++                               GEN_INT (-INTVAL (operands[1]))));
++        }
++      operands[0] = reg;
++      }
++
++    if (!avr32_const_ok_for_constraint_p(INTVAL (operands[2]), 'K', \"Ks21\"))
++      operands[2] = force_reg (SImode, operands[2]);
++
++    emit_jump_insn (gen_casesi_internal (operands[0], operands[2], operands[3],
++                                       operands[4], gen_reg_rtx(SImode)));
++    DONE;
++  }"
++)
++
++;; The USE in this pattern is needed to tell flow analysis that this is
++;; a CASESI insn.  It has no other purpose.
++(define_insn "casesi_internal"
++  [(parallel [(set (pc)
++             (if_then_else
++              (leu (match_operand:SI 0 "register_operand" "r")
++                   (match_operand:SI 1 "register_immediate_operand" "rKu03"))
++              (mem:SI (plus:SI (mult:SI (match_dup 0) (const_int 4))
++                               (label_ref (match_operand 2 "" ""))))
++              (label_ref (match_operand 3 "" ""))))
++              (clobber (match_operand:SI 4 "register_operand" "=r"))
++            (use (label_ref (match_dup 2)))])]
++  ""
++  {
++    if (flag_pic)
++      return "cp.w\t%0, %1\;brhi\t%3\;sub\t%4, pc, -(%2 - .)\;add\tpc, %4, %0 << 2";
++    return   "cp.w\t%0, %1\;brhi\t%3\;sub\t%4, pc, -(%2 - .)\;ld.w\tpc, %4[%0 << 2]";
++  }
++  [(set_attr "cc" "clobber")
++   (set_attr "length" "16")]
++)
++
++
++(define_insn "prefetch"
++  [(prefetch (match_operand:SI 0 "register_operand" "r")
++           (match_operand 1 "const_int_operand" "")
++           (match_operand 2 "const_int_operand" ""))]
++  ""
++  {
++     return "pref\t%0[0]";
++  }
++
++  [(set_attr "length" "4")
++   (set_attr "type" "load")
++   (set_attr "cc" "none")])
++
++
++
++;;=============================================================================
++;; prologue
++;;-----------------------------------------------------------------------------
++;; This pattern, if defined, emits RTL for entry to a function. The function
++;; entry i responsible for setting up the stack frame, initializing the frame
++;; pointer register, saving callee saved registers, etc.
++;;=============================================================================
++(define_expand "prologue"
++  [(clobber (const_int 0))]
++  ""
++  "
++  avr32_expand_prologue();
++  DONE;
++  "
++  )
++
++;;=============================================================================
++;; eh_return
++;;-----------------------------------------------------------------------------
++;; This pattern, if defined, affects the way __builtin_eh_return, and
++;; thence the call frame exception handling library routines, are
++;; built. It is intended to handle non-trivial actions needed along
++;; the abnormal return path.
++;;
++;; The address of the exception handler to which the function should
++;; return is passed as operand to this pattern. It will normally need
++;; to copied by the pattern to some special register or memory
++;; location. If the pattern needs to determine the location of the
++;; target call frame in order to do so, it may use
++;; EH_RETURN_STACKADJ_RTX, if defined; it will have already been
++;; assigned.
++;;
++;; If this pattern is not defined, the default action will be to
++;; simply copy the return address to EH_RETURN_HANDLER_RTX. Either
++;; that macro or this pattern needs to be defined if call frame
++;; exception handling is to be used.
++(define_expand "eh_return"
++  [(use (match_operand 0 "general_operand" ""))]
++  ""
++  "
++  avr32_set_return_address (operands[0]);
++  DONE;
++  "
++  )
++
++;;=============================================================================
++;; ffssi2
++;;-----------------------------------------------------------------------------
++(define_insn "ffssi2"
++  [ (set (match_operand:SI 0 "register_operand" "=r")
++         (ffs:SI (match_operand:SI 1 "register_operand" "r"))) ]
++  ""
++  "mov    %0, %1
++   brev   %0
++   clz    %0, %0
++   sub    %0, -1
++   cp     %0, 33
++   moveq  %0, 0"
++  [(set_attr "length" "18")
++   (set_attr "cc" "clobber")]
++  )
++
++
++
++;;=============================================================================
++;; swap_h
++;;-----------------------------------------------------------------------------
++(define_insn "*swap_h"
++  [ (set (match_operand:SI 0 "register_operand" "=r")
++         (ior:SI (ashift:SI (match_dup 0) (const_int 16))
++                 (lshiftrt:SI (match_dup 0) (const_int 16))))]
++  ""
++  "swap.h    %0"
++  [(set_attr "length" "2")]
++  )
++
++(define_insn_and_split "bswap_16"
++  [ (set (match_operand:HI 0 "avr32_bswap_operand" "=r,RKs13,r")
++         (ior:HI (and:HI (lshiftrt:HI (match_operand:HI 1 "avr32_bswap_operand" "r,r,RKs13")
++                                      (const_int 8))
++                         (const_int 255))
++                 (ashift:HI (and:HI (match_dup 1)
++                                    (const_int 255))
++                            (const_int 8))))]
++  ""
++  {
++   switch ( which_alternative ){
++     case 0:
++       if ( REGNO(operands[0]) == REGNO(operands[1]))
++         return "swap.bh\t%0";
++       else
++         return "mov\t%0, %1\;swap.bh\t%0";
++     case 1:
++       return "stswp.h\t%0, %1";
++     case 2:
++       return "ldswp.sh\t%0, %1";
++     default:
++       abort();
++     }
++  }
++
++  "(reload_completed &&
++     REG_P(operands[0]) && REG_P(operands[1])
++     && (REGNO(operands[0]) != REGNO(operands[1])))"
++  [(set (match_dup 0) (match_dup 1))
++   (set (match_dup 0)
++        (ior:HI (and:HI (lshiftrt:HI (match_dup 0)
++                                     (const_int 8))
++                        (const_int 255))
++                (ashift:HI (and:HI (match_dup 0)
++                                   (const_int 255))
++                           (const_int 8))))]
++  ""
++
++  [(set_attr "length" "4,4,4")
++   (set_attr "type" "alu,store,load_rm")]
++  )
++
++(define_insn_and_split "bswap_32"
++  [ (set (match_operand:SI 0 "avr32_bswap_operand" "=r,RKs14,r")
++         (ior:SI (ior:SI (lshiftrt:SI (and:SI (match_operand:SI 1 "avr32_bswap_operand" "=r,r,RKs14")
++                                              (const_int 4278190080))
++                                      (const_int 24))
++                         (lshiftrt:SI (and:SI (match_dup 1)
++                                              (const_int 16711680))
++                                      (const_int 8)))
++                 (ior:SI (ashift:SI (and:SI (match_dup 1)
++                                            (const_int 65280))
++                                    (const_int 8))
++                         (ashift:SI (and:SI (match_dup 1)
++                                            (const_int 255))
++                                    (const_int 24)))))]
++  ""
++  {
++    switch ( which_alternative ){
++     case 0:
++       if ( REGNO(operands[0]) == REGNO(operands[1]))
++         return "swap.b\t%0";
++       else
++         return "mov\t%0, %1\;swap.b\t%0";
++     case 1:
++       return "stswp.w\t%0, %1";
++     case 2:
++       return "ldswp.w\t%0, %1";
++     default:
++       abort();
++    }
++  }
++  "(reload_completed &&
++    REG_P(operands[0]) && REG_P(operands[1])
++    && (REGNO(operands[0]) != REGNO(operands[1])))"
++  [(set (match_dup 0) (match_dup 1))
++   (set (match_dup 0)
++        (ior:SI (ior:SI (lshiftrt:SI (and:SI (match_dup 0)
++                                             (const_int 4278190080))
++                                     (const_int 24))
++                        (lshiftrt:SI (and:SI (match_dup 0)
++                                             (const_int 16711680))
++                                     (const_int 8)))
++                (ior:SI (ashift:SI (and:SI (match_dup 0)
++                                           (const_int 65280))
++                                   (const_int 8))
++                        (ashift:SI (and:SI (match_dup 0)
++                                           (const_int 255))
++                                   (const_int 24)))))]
++  ""
++
++  [(set_attr "length" "4,4,4")
++   (set_attr "type" "alu,store,load_rm")]
++  )
++
++
++;;=============================================================================
++;; blockage
++;;-----------------------------------------------------------------------------
++;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
++;; all of memory.  This blocks insns from being moved across this point.
++
++(define_insn "blockage"
++  [(unspec_volatile [(const_int 0)] VUNSPEC_BLOCKAGE)]
++  ""
++  ""
++  [(set_attr "length" "0")]
++)
++
++;;=============================================================================
++;; clzsi2
++;;-----------------------------------------------------------------------------
++(define_insn "clzsi2"
++  [ (set (match_operand:SI 0 "register_operand" "=r")
++         (clz:SI (match_operand:SI 1 "register_operand" "r"))) ]
++  ""
++  "clz    %0, %1"
++  [(set_attr "length" "4")
++   (set_attr "cc" "set_z")]
++  )
++
++;;=============================================================================
++;; ctzsi2
++;;-----------------------------------------------------------------------------
++(define_insn "ctzsi2"
++  [ (set (match_operand:SI 0 "register_operand" "=r,r")
++         (ctz:SI (match_operand:SI 1 "register_operand" "0,r"))) ]
++  ""
++  "@
++   brev\t%0\;clz\t%0, %0
++   mov\t%0, %1\;brev\t%0\;clz\t%0, %0"
++  [(set_attr "length" "8")
++   (set_attr "cc" "set_z")]
++  )
++
++;;=============================================================================
++;; cache instructions
++;;-----------------------------------------------------------------------------
++(define_insn "cache"
++  [ (unspec_volatile [(match_operand:SI 0 "register_operand" "r")
++                      (match_operand:SI 1 "immediate_operand" "Ku05")] VUNSPEC_CACHE)]
++  ""
++  "cache    %0[0], %1"
++  [(set_attr "length" "4")]
++  )
++
++(define_insn "sync"
++  [ (unspec_volatile [(match_operand:SI 0 "immediate_operand" "Ku08")] VUNSPEC_SYNC)]
++  ""
++  "sync    %0"
++  [(set_attr "length" "4")]
++  )
++
++;;=============================================================================
++;; TLB instructions
++;;-----------------------------------------------------------------------------
++(define_insn "tlbr"
++  [ (unspec_volatile [(const_int 0)] VUNSPEC_TLBR)]
++  ""
++  "tlbr"
++  [(set_attr "length" "2")]
++  )
++
++(define_insn "tlbw"
++  [ (unspec_volatile [(const_int 0)] VUNSPEC_TLBW)]
++  ""
++  "tlbw"
++  [(set_attr "length" "2")]
++  )
++
++(define_insn "tlbs"
++  [ (unspec_volatile [(const_int 0)] VUNSPEC_TLBS)]
++  ""
++  "tlbs"
++  [(set_attr "length" "2")]
++  )
++
++;;=============================================================================
++;; Breakpoint instruction
++;;-----------------------------------------------------------------------------
++(define_insn "breakpoint"
++  [ (unspec_volatile [(const_int 0)] VUNSPEC_BREAKPOINT)]
++  ""
++  "breakpoint"
++  [(set_attr "length" "2")]
++  )
++
++;;=============================================================================
++;; Xchg instruction
++;;-----------------------------------------------------------------------------
++(define_insn "xchg"
++  [ (parallel [(set (match_operand:SI 0 "register_operand" "=&r")
++                    (mem:SI (match_operand:SI 1 "register_operand" "r")))
++               (set (mem:SI (match_operand:SI 2 "register_operand" "=1"))
++                    (match_operand:SI 3 "register_operand" "r"))])]
++  ""
++  "xchg\t%0, %1, %3"
++  [(set_attr "length" "4")]
++  )
++
++;;=============================================================================
++;; mtsr/mfsr instruction
++;;-----------------------------------------------------------------------------
++(define_insn "mtsr"
++  [ (unspec_volatile [(match_operand 0 "immediate_operand" "i")
++                      (match_operand:SI 1 "register_operand" "r")] VUNSPEC_MTSR)]
++  ""
++  "mtsr\t%0, %1"
++  [(set_attr "length" "4")]
++  )
++
++(define_insn "mfsr"
++  [ (set (match_operand:SI 0 "register_operand" "=r")
++         (unspec_volatile:SI [(match_operand 1 "immediate_operand" "i")] VUNSPEC_MFSR)) ]
++  ""
++  "mfsr\t%0, %1"
++  [(set_attr "length" "4")]
++  )
++
++;;=============================================================================
++;; mtdr/mfdr instruction
++;;-----------------------------------------------------------------------------
++(define_insn "mtdr"
++  [ (unspec_volatile [(match_operand 0 "immediate_operand" "i")
++                      (match_operand:SI 1 "register_operand" "r")] VUNSPEC_MTDR)]
++  ""
++  "mtdr\t%0, %1"
++  [(set_attr "length" "4")]
++  )
++
++(define_insn "mfdr"
++  [ (set (match_operand:SI 0 "register_operand" "=r")
++         (unspec_volatile:SI [(match_operand 1 "immediate_operand" "i")] VUNSPEC_MFDR)) ]
++  ""
++  "mfdr\t%0, %1"
++  [(set_attr "length" "4")]
++  )
++
++;;=============================================================================
++;; musfr
++;;-----------------------------------------------------------------------------
++(define_insn "musfr"
++  [ (unspec_volatile [(match_operand:SI 0 "register_operand" "r")] VUNSPEC_MUSFR)]
++  ""
++  "musfr\t%0"
++  [(set_attr "length" "2")
++   (set_attr "cc" "clobber")]
++  )
++
++(define_insn "mustr"
++  [ (set (match_operand:SI 0 "register_operand" "=r")
++         (unspec_volatile:SI [(const_int 0)] VUNSPEC_MUSTR)) ]
++  ""
++  "mustr\t%0"
++  [(set_attr "length" "2")]
++  )
++
++;;=============================================================================
++;; Saturation Round Scale instruction
++;;-----------------------------------------------------------------------------
++(define_insn "sats"
++  [ (set (match_operand:SI 0 "register_operand" "+r")
++         (unspec:SI [(match_dup 0)
++                     (match_operand 1 "immediate_operand" "Ku05")
++                     (match_operand 2 "immediate_operand" "Ku05")]
++                    UNSPEC_SATS)) ]
++  "TARGET_DSP"
++  "sats\t%0 >> %1, %2"
++  [(set_attr "type" "alu_sat")
++   (set_attr "length" "4")]
++  )
++
++(define_insn "satu"
++  [ (set (match_operand:SI 0 "register_operand" "+r")
++         (unspec:SI [(match_dup 0)
++                     (match_operand 1 "immediate_operand" "Ku05")
++                     (match_operand 2 "immediate_operand" "Ku05")]
++                    UNSPEC_SATU)) ]
++  "TARGET_DSP"
++  "satu\t%0 >> %1, %2"
++  [(set_attr "type" "alu_sat")
++   (set_attr "length" "4")]
++  )
++
++(define_insn "satrnds"
++  [ (set (match_operand:SI 0 "register_operand" "+r")
++         (unspec:SI [(match_dup 0)
++                     (match_operand 1 "immediate_operand" "Ku05")
++                     (match_operand 2 "immediate_operand" "Ku05")]
++                    UNSPEC_SATRNDS)) ]
++  "TARGET_DSP"
++  "satrnds\t%0 >> %1, %2"
++  [(set_attr "type" "alu_sat")
++   (set_attr "length" "4")]
++  )
++
++(define_insn "satrndu"
++  [ (set (match_operand:SI 0 "register_operand" "+r")
++         (unspec:SI [(match_dup 0)
++                     (match_operand 1 "immediate_operand" "Ku05")
++                     (match_operand 2 "immediate_operand" "Ku05")]
++                    UNSPEC_SATRNDU)) ]
++  "TARGET_DSP"
++  "sats\t%0 >> %1, %2"
++  [(set_attr "type" "alu_sat")
++   (set_attr "length" "4")]
++  )
++
++;; Special patterns for dealing with the constant pool
++
++(define_insn "align_4"
++  [(unspec_volatile [(const_int 0)] VUNSPEC_ALIGN)]
++  ""
++  {
++   assemble_align (32);
++   return "";
++  }
++  [(set_attr "length" "2")]
++)
++
++(define_insn "consttable_start"
++  [(unspec_volatile [(const_int 0)] VUNSPEC_POOL_START)]
++  ""
++  {
++   return ".cpool";
++  }
++  [(set_attr "length" "0")]
++  )
++
++(define_insn "consttable_end"
++  [(unspec_volatile [(const_int 0)] VUNSPEC_POOL_END)]
++  ""
++  {
++   making_const_table = FALSE;
++   return "";
++  }
++  [(set_attr "length" "0")]
++)
++
++
++(define_insn "consttable_4"
++  [(unspec_volatile [(match_operand 0 "" "")] VUNSPEC_POOL_4)]
++  ""
++  {
++    making_const_table = TRUE;
++    switch (GET_MODE_CLASS (GET_MODE (operands[0])))
++      {
++      case MODE_FLOAT:
++      {
++        REAL_VALUE_TYPE r;
++        char real_string[1024];
++        REAL_VALUE_FROM_CONST_DOUBLE (r, operands[0]);
++        real_to_decimal(real_string, &r, 1024, 0, 1);
++        asm_fprintf (asm_out_file, "\t.float\t%s\n", real_string);
++        break;
++      }
++      default:
++        assemble_integer (operands[0], 4, 0, 1);
++        break;
++      }
++    return "";
++  }
++  [(set_attr "length" "4")]
++)
++
++(define_insn "consttable_8"
++  [(unspec_volatile [(match_operand 0 "" "")] VUNSPEC_POOL_8)]
++  ""
++  {
++    making_const_table = TRUE;
++    switch (GET_MODE_CLASS (GET_MODE (operands[0])))
++      {
++       case MODE_FLOAT:
++        {
++         REAL_VALUE_TYPE r; 
++         char real_string[1024];
++         REAL_VALUE_FROM_CONST_DOUBLE (r, operands[0]);
++         real_to_decimal(real_string, &r, 1024, 0, 1);
++         asm_fprintf (asm_out_file, "\t.double\t%s\n", real_string);
++         break;
++        }
++       default:
++         assemble_integer(operands[0], 8, 0, 1);
++        break;
++     }
++    return "";
++  }
++  [(set_attr "length" "8")]
++)
++
++;;=============================================================================
++;; coprocessor instructions
++;;-----------------------------------------------------------------------------
++(define_insn "cop"
++  [ (unspec_volatile [(match_operand 0 "immediate_operand" "Ku03")
++                      (match_operand 1 "immediate_operand" "Ku04")
++                      (match_operand 2 "immediate_operand" "Ku04")
++                      (match_operand 3 "immediate_operand" "Ku04")
++                      (match_operand 4 "immediate_operand" "Ku07")] VUNSPEC_COP)]
++  ""
++  "cop\tcp%0, cr%1, cr%2, cr%3, %4"
++  [(set_attr "length" "4")]
++  )
++
++(define_insn "mvcrsi"
++  [ (set (match_operand:SI 0 "avr32_cop_move_operand" "=r,<,Z")
++         (unspec_volatile:SI [(match_operand 1 "immediate_operand" "Ku03,Ku03,Ku03")
++                              (match_operand 2 "immediate_operand" "Ku04,Ku04,Ku04")]
++                             VUNSPEC_MVCR)) ]
++  ""
++  "@
++   mvcr.w\tcp%1, %0, cr%2
++   stcm.w\tcp%1, %0, cr%2
++   stc.w\tcp%1, %0, cr%2"
++  [(set_attr "length" "4")]
++  )
++
++(define_insn "mvcrdi"
++  [ (set (match_operand:DI 0 "avr32_cop_move_operand" "=r,<,Z")
++         (unspec_volatile:DI [(match_operand 1 "immediate_operand" "Ku03,Ku03,Ku03")
++                              (match_operand 2 "immediate_operand" "Ku04,Ku04,Ku04")]
++                             VUNSPEC_MVCR)) ]
++  ""
++  "@
++   mvcr.d\tcp%1, %0, cr%2
++   stcm.d\tcp%1, %0, cr%2-cr%i2
++   stc.d\tcp%1, %0, cr%2"
++  [(set_attr "length" "4")]
++  )
++
++(define_insn "mvrcsi"
++  [ (unspec_volatile:SI [(match_operand 0 "immediate_operand" "Ku03,Ku03,Ku03")
++                         (match_operand 1 "immediate_operand" "Ku04,Ku04,Ku04")
++                         (match_operand:SI 2 "avr32_cop_move_operand" "r,>,Z")]
++                        VUNSPEC_MVRC)]
++  ""
++  {
++   switch (which_alternative){
++    case 0:
++      return "mvrc.w\tcp%0, cr%1, %2";
++    case 1:
++      return "ldcm.w\tcp%0, %2, cr%1";
++    case 2:
++      return "ldc.w\tcp%0, cr%1, %2";
++    default:
++      abort();
++   }
++  }
++  [(set_attr "length" "4")]
++  )
++
++(define_insn "mvrcdi"
++  [ (unspec_volatile:DI [(match_operand 0 "immediate_operand" "Ku03,Ku03,Ku03")
++                         (match_operand 1 "immediate_operand" "Ku04,Ku04,Ku04")
++                         (match_operand:DI 2 "avr32_cop_move_operand" "r,>,Z")]
++                        VUNSPEC_MVRC)]
++  ""
++  {
++   switch (which_alternative){
++    case 0:
++      return "mvrc.d\tcp%0, cr%1, %2";
++    case 1:
++      return "ldcm.d\tcp%0, %2, cr%1-cr%i1";
++    case 2:
++      return "ldc.d\tcp%0, cr%1, %2";
++    default:
++      abort();
++   }
++  }
++  [(set_attr "length" "4")]
++  )
++
++;;=============================================================================
++;; epilogue
++;;-----------------------------------------------------------------------------
++;; This pattern emits RTL for exit from a function. The function exit is
++;; responsible for deallocating the stack frame, restoring callee saved
++;; registers and emitting the return instruction.
++;; ToDo: using TARGET_ASM_FUNCTION_PROLOGUE instead.
++;;=============================================================================
++(define_expand "epilogue"
++  [(unspec_volatile [(return)] VUNSPEC_EPILOGUE)]
++  ""
++  "
++  if (USE_RETURN_INSN (FALSE)){
++      emit_jump_insn (gen_return ());
++      DONE;
++  }
++  emit_jump_insn (gen_rtx_UNSPEC_VOLATILE (VOIDmode,
++      gen_rtvec (1,
++              gen_rtx_RETURN (VOIDmode)),
++      VUNSPEC_EPILOGUE));
++  DONE;
++  "
++  )
++
++(define_insn "*epilogue_insns"
++  [(unspec_volatile [(return)] VUNSPEC_EPILOGUE)]
++  ""
++  {
++    avr32_output_return_instruction (FALSE, FALSE, NULL, NULL);
++    return "";
++  }
++  ; Length is absolute worst case
++  [(set_attr "type" "branch")
++   (set_attr "length" "12")]
++  )
++
++(define_insn "*epilogue_insns_ret_imm"
++  [(parallel [(set (reg RETVAL_REGNUM) (match_operand 0 "immediate_operand" "i"))
++              (use (reg RETVAL_REGNUM))
++              (unspec_volatile [(return)] VUNSPEC_EPILOGUE)])]
++  "((INTVAL(operands[0]) == -1) || (INTVAL(operands[0]) == 0) || (INTVAL(operands[0]) == 1))"
++  {
++    avr32_output_return_instruction (FALSE, FALSE, NULL, operands[0]);
++    return "";
++  }
++  ; Length is absolute worst case
++  [(set_attr "type" "branch")
++   (set_attr "length" "12")]
++  )
++
++(define_insn "sibcall_epilogue"
++  [(unspec_volatile [(const_int 0)] VUNSPEC_EPILOGUE)]
++  ""
++  {
++   avr32_output_return_instruction (FALSE, FALSE,  NULL, NULL);
++   return "";
++  }
++;; Length is absolute worst case
++  [(set_attr "type" "branch")
++   (set_attr "length" "12")]
++  )
++
++(define_insn "*sibcall_epilogue_insns_ret_imm"
++  [(parallel [(set (reg RETVAL_REGNUM) (match_operand 0 "immediate_operand" "i"))
++              (use (reg RETVAL_REGNUM))
++              (unspec_volatile [(const_int 0)] VUNSPEC_EPILOGUE)])]
++  "((INTVAL(operands[0]) == -1) || (INTVAL(operands[0]) == 0) || (INTVAL(operands[0]) == 1))"
++  {
++    avr32_output_return_instruction (FALSE, FALSE, NULL, operands[0]);
++    return "";
++  }
++  ; Length is absolute worst case
++  [(set_attr "type" "branch")
++   (set_attr "length" "12")]
++  )
++
++(define_insn "ldxi"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (mem:SI (plus:SI
++                 (match_operand:SI 1 "register_operand" "r")
++                 (mult:SI (zero_extract:SI (match_operand:SI 2 "register_operand" "r")
++                                           (const_int 8)
++                                           (match_operand:SI 3 "immediate_operand" "Ku05"))
++                          (const_int 4)))))]
++  "(INTVAL(operands[3]) == 24 || INTVAL(operands[3]) == 16 || INTVAL(operands[3]) == 8
++   || INTVAL(operands[3]) == 0)"
++  {
++   switch ( INTVAL(operands[3]) ){
++    case 0:
++         return "ld.w    %0, %1[%2:b << 2]";
++    case 8:
++         return "ld.w    %0, %1[%2:l << 2]";
++    case 16:
++         return "ld.w    %0, %1[%2:u << 2]";
++    case 24:
++         return "ld.w    %0, %1[%2:t << 2]";
++    default:
++         internal_error("illegal operand for ldxi");
++   }
++  }
++  [(set_attr "type" "load")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
++
++
++
++
++
++
++;;=============================================================================
++;; Peephole optimizing
++;;-----------------------------------------------------------------------------
++;; Changing
++;;   sub     r8, r7, 8
++;;   st.w    r8[0x0], r12
++;; to
++;;   sub     r8, r7, 8
++;;   st.w    r7[-0x8], r12
++;;=============================================================================
++; (set (reg:SI 9 r8)
++;      (plus:SI (reg/f:SI 6 r7)
++;               (const_int ...)))
++; (set (mem:SI (reg:SI 9 r8))
++;      (reg:SI 12 r12))
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++      (plus:SI (match_operand:SI 1 "register_operand" "")
++               (match_operand:SI 2 "immediate_operand" "")))
++   (set (mem:SI (match_dup 0))
++      (match_operand:SI 3 "register_operand" ""))]
++  "REGNO(operands[0]) != REGNO(operands[1]) && avr32_const_ok_for_constraint_p(INTVAL(operands[2]), 'K', \"Ks16\")"
++  [(set (match_dup 0)
++      (plus:SI (match_dup 1)
++               (match_dup 2)))
++   (set (mem:SI (plus:SI (match_dup 1)
++                       (match_dup 2)))
++      (match_dup 3))]
++  "")
++
++;;=============================================================================
++;; Peephole optimizing
++;;-----------------------------------------------------------------------------
++;; Changing
++;;   sub     r6, r7, 4
++;;   ld.w    r6, r6[0x0]
++;; to
++;;   sub     r6, r7, 4
++;;   ld.w    r6, r7[-0x4]
++;;=============================================================================
++; (set (reg:SI 7 r6)
++;      (plus:SI (reg/f:SI 6 r7)
++;               (const_int -4 [0xfffffffc])))
++; (set (reg:SI 7 r6)
++;      (mem:SI (reg:SI 7 r6)))
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++      (plus:SI (match_operand:SI 1 "register_operand" "")
++               (match_operand:SI 2 "immediate_operand" "")))
++   (set (match_operand:SI 3 "register_operand" "")
++      (mem:SI (match_dup 0)))]
++  "REGNO(operands[0]) != REGNO(operands[1]) && avr32_const_ok_for_constraint_p(INTVAL(operands[2]), 'K', \"Ks16\")"
++  [(set (match_dup 0)
++      (plus:SI (match_dup 1)
++               (match_dup 2)))
++   (set (match_dup 3)
++      (mem:SI (plus:SI (match_dup 1)
++                       (match_dup 2))))]
++  "")
++
++;;=============================================================================
++;; Peephole optimizing
++;;-----------------------------------------------------------------------------
++;; Changing
++;;   ld.sb   r0, r7[-0x6]
++;;   cashs.b r0
++;; to
++;;   ld.sb   r0, r7[-0x6]
++;;=============================================================================
++(define_peephole2
++  [(set (match_operand:QI 0 "register_operand" "")
++      (match_operand:QI 1 "load_sb_memory_operand" ""))
++   (set (match_operand:SI 2 "register_operand" "")
++      (sign_extend:SI (match_dup 0)))]
++  "(REGNO(operands[0]) == REGNO(operands[2]) || peep2_reg_dead_p(2, operands[0]))"
++  [(set (match_dup 2)
++      (sign_extend:SI (match_dup 1)))]
++  "")
++
++;;=============================================================================
++;; Peephole optimizing
++;;-----------------------------------------------------------------------------
++;; Changing
++;;   ld.ub   r0, r7[-0x6]
++;;   cashu.b r0
++;; to
++;;   ld.ub   r0, r7[-0x6]
++;;=============================================================================
++(define_peephole2
++  [(set (match_operand:QI 0 "register_operand" "")
++      (match_operand:QI 1 "memory_operand" ""))
++   (set (match_operand:SI 2 "register_operand" "")
++      (zero_extend:SI (match_dup 0)))]
++  "(REGNO(operands[0]) == REGNO(operands[2])) || peep2_reg_dead_p(2, operands[0])"
++  [(set (match_dup 2)
++      (zero_extend:SI (match_dup 1)))]
++  "")
++
++;;=============================================================================
++;; Peephole optimizing
++;;-----------------------------------------------------------------------------
++;; Changing
++;;   ld.sh   r0, r7[-0x6]
++;;   casts.h r0
++;; to
++;;   ld.sh   r0, r7[-0x6]
++;;=============================================================================
++(define_peephole2
++  [(set (match_operand:HI 0 "register_operand" "")
++      (match_operand:HI 1 "memory_operand" ""))
++   (set (match_operand:SI 2 "register_operand" "")
++      (sign_extend:SI (match_dup 0)))]
++  "(REGNO(operands[0]) == REGNO(operands[2])) || peep2_reg_dead_p(2, operands[0])"
++  [(set (match_dup 2)
++      (sign_extend:SI (match_dup 1)))]
++  "")
++
++;;=============================================================================
++;; Peephole optimizing
++;;-----------------------------------------------------------------------------
++;; Changing
++;;   ld.uh   r0, r7[-0x6]
++;;   castu.h r0
++;; to
++;;   ld.uh   r0, r7[-0x6]
++;;=============================================================================
++(define_peephole2
++  [(set (match_operand:HI 0 "register_operand" "")
++      (match_operand:HI 1 "memory_operand" ""))
++   (set (match_operand:SI 2 "register_operand" "")
++      (zero_extend:SI (match_dup 0)))]
++  "(REGNO(operands[0]) == REGNO(operands[2])) || peep2_reg_dead_p(2, operands[0])"
++  [(set (match_dup 2)
++      (zero_extend:SI (match_dup 1)))]
++  "")
++
++;;=============================================================================
++;; Peephole optimizing
++;;-----------------------------------------------------------------------------
++;; Changing
++;;   mul     rd, rx, ry
++;;   add     rd2, rd
++;; to
++;;   mac     rd2, rx, ry
++;;=============================================================================
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (mult:SI (match_operand:SI 1 "register_operand" "")
++                (match_operand:SI 2 "register_operand" "")))
++   (set (match_operand:SI 3 "register_operand" "")
++        (plus:SI (match_dup 3)
++                 (match_dup 0)))]
++  "peep2_reg_dead_p(2, operands[0])"
++  [(set (match_dup 3)
++      (plus:SI (mult:SI (match_dup 1)
++                        (match_dup 2))
++               (match_dup 3)))]
++  "")
++
++
++
++;;=============================================================================
++;; Peephole optimizing
++;;-----------------------------------------------------------------------------
++;; Changing
++;;   bfextu  rd, rs, k5, 1 or and(h/l) rd, one_bit_set_mask
++;; to
++;;   bld     rs, k5
++;;
++;; If rd is dead after the operation.
++;;=============================================================================
++(define_peephole2
++  [ (set (match_operand:SI 0 "register_operand" "")
++         (zero_extract:SI (match_operand:SI 1 "register_operand" "")
++                          (const_int 1)
++                          (match_operand:SI 2 "immediate_operand" "")))
++    (set (cc0)
++         (match_dup 0))]
++  "peep2_reg_dead_p(2, operands[0])"
++  [(set (cc0)
++        (and:SI (match_dup 1)
++                (match_dup 2)))]
++  "operands[2] = GEN_INT(1 << INTVAL(operands[2]));")
++
++(define_peephole2
++  [ (set (match_operand:SI 0 "register_operand" "")
++         (and:SI (match_operand:SI 1 "register_operand" "")
++                 (match_operand:SI 2 "one_bit_set_operand" "")))
++    (set (cc0)
++         (match_dup 0))]
++  "peep2_reg_dead_p(2, operands[0])"
++  [(set (cc0)
++        (and:SI (match_dup 1)
++                (match_dup 2)))]
++  "")
++
++;;=============================================================================
++;; Peephole optimizing
++;;-----------------------------------------------------------------------------
++;; Load with extracted index: ld.w  Rd, Rb[Ri:{t/u/b/l} << 2]
++;;
++;;=============================================================================
++
++
++(define_peephole
++  [(set (match_operand:SI 0 "register_operand" "")
++        (zero_extract:SI (match_operand:SI 1 "register_operand" "")
++                         (const_int 8)
++                         (match_operand:SI 2 "avr32_extract_shift_operand" "")))
++   (set (match_operand:SI 3 "register_operand" "")
++        (mem:SI (plus:SI (mult:SI (match_dup 0) (const_int 4))
++                         (match_operand:SI 4 "register_operand" ""))))]
++
++  "(dead_or_set_p(insn, operands[0]))"
++  {
++   switch ( INTVAL(operands[2]) ){
++    case 0:
++         return "ld.w    %3, %4[%1:b << 2]";
++    case 8:
++         return "ld.w    %3, %4[%1:l << 2]";
++    case 16:
++         return "ld.w    %3, %4[%1:u << 2]";
++    case 24:
++         return "ld.w    %3, %4[%1:t << 2]";
++    default:
++         internal_error("illegal operand for ldxi");
++   }
++  }
++  [(set_attr "type" "load")
++   (set_attr "length" "4")
++   (set_attr "cc" "clobber")]
++  )
++
++
++
++(define_peephole
++  [(set (match_operand:SI 0 "register_operand" "")
++        (and:SI (match_operand:SI 1 "register_operand" "") (const_int 255)))
++   (set (match_operand:SI 2 "register_operand" "")
++        (mem:SI (plus:SI (mult:SI (match_dup 0) (const_int 4))
++                         (match_operand:SI 3 "register_operand" ""))))]
++
++  "(dead_or_set_p(insn, operands[0]))"
++
++  "ld.w    %2, %3[%1:b << 2]"
++  [(set_attr "type" "load")
++   (set_attr "length" "4")
++   (set_attr "cc" "clobber")]
++  )
++
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (zero_extract:SI (match_operand:SI 1 "register_operand" "")
++                         (const_int 8)
++                         (match_operand:SI 2 "avr32_extract_shift_operand" "")))
++   (set (match_operand:SI 3 "register_operand" "")
++        (mem:SI (plus:SI (mult:SI (match_dup 0) (const_int 4))
++                         (match_operand:SI 4 "register_operand" ""))))]
++
++  "(peep2_reg_dead_p(2, operands[0]))
++   || (REGNO(operands[0]) == REGNO(operands[3]))"
++  [(set (match_dup 3)
++      (mem:SI (plus:SI
++                 (match_dup 4)
++                 (mult:SI (zero_extract:SI (match_dup 1)
++                                           (const_int 8)
++                                           (match_dup 2))
++                          (const_int 4)))))]
++  )
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (zero_extend:SI (match_operand:QI 1 "register_operand" "")))
++   (set (match_operand:SI 2 "register_operand" "")
++        (mem:SI (plus:SI (mult:SI (match_dup 0) (const_int 4))
++                         (match_operand:SI 3 "register_operand" ""))))]
++
++  "(peep2_reg_dead_p(2, operands[0]))
++   || (REGNO(operands[0]) == REGNO(operands[2]))"
++  [(set (match_dup 2)
++      (mem:SI (plus:SI
++                 (match_dup 3)
++                 (mult:SI (zero_extract:SI (match_dup 1)
++                                           (const_int 8)
++                                           (const_int 0))
++                          (const_int 4)))))]
++  "operands[1] = gen_rtx_REG(SImode, REGNO(operands[1]));"
++  )
++
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (and:SI (match_operand:SI 1 "register_operand" "")
++                (const_int 255)))
++   (set (match_operand:SI 2 "register_operand" "")
++        (mem:SI (plus:SI (mult:SI (match_dup 0) (const_int 4))
++                         (match_operand:SI 3 "register_operand" ""))))]
++
++  "(peep2_reg_dead_p(2, operands[0]))
++   || (REGNO(operands[0]) == REGNO(operands[2]))"
++  [(set (match_dup 2)
++      (mem:SI (plus:SI
++                 (match_dup 3)
++                 (mult:SI (zero_extract:SI (match_dup 1)
++                                           (const_int 8)
++                                           (const_int 0))
++                          (const_int 4)))))]
++  ""
++  )
++
++
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (lshiftrt:SI (match_operand:SI 1 "register_operand" "")
++                     (const_int 24)))
++   (set (match_operand:SI 2 "register_operand" "")
++        (mem:SI (plus:SI (mult:SI (match_dup 0) (const_int 4))
++                         (match_operand:SI 3 "register_operand" ""))))]
++
++  "(peep2_reg_dead_p(2, operands[0]))
++   || (REGNO(operands[0]) == REGNO(operands[2]))"
++  [(set (match_dup 2)
++      (mem:SI (plus:SI
++                 (match_dup 3)
++                 (mult:SI (zero_extract:SI (match_dup 1)
++                                           (const_int 8)
++                                           (const_int 24))
++                          (const_int 4)))))]
++  ""
++  )
++
++
++;;************************************************
++;; ANDN
++;;
++;;************************************************
++
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (not:SI (match_operand:SI 1 "register_operand" "")))
++   (set (match_operand:SI 2 "register_operand" "")
++        (and:SI (match_dup 2)
++                (match_dup 0)))]
++  "peep2_reg_dead_p(2, operands[0])"
++
++  [(set (match_dup 2)
++        (and:SI  (match_dup 2)
++                 (not:SI (match_dup 1))
++                 ))]
++  ""
++)
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++        (not:SI (match_operand:SI 1 "register_operand" "")))
++   (set (match_operand:SI 2 "register_operand" "")
++        (and:SI (match_dup 0)
++                (match_dup 2)
++                ))]
++  "peep2_reg_dead_p(2, operands[0])"
++
++  [(set (match_dup 2)
++        (and:SI  (match_dup 2)
++                 (not:SI (match_dup 1))
++                 ))]
++
++  ""
++)
++
++
++;;=================================================================
++;; Addabs peephole
++;;=================================================================
++
++(define_peephole
++  [(set (match_operand:SI 2 "register_operand" "=r")
++      (abs:SI (match_operand:SI 1 "register_operand" "r")))
++   (set (match_operand:SI 0 "register_operand" "=r")
++      (plus:SI (match_operand:SI 3 "register_operand" "r")
++               (match_dup 2)))]
++  "dead_or_set_p(insn, operands[2])"
++  "addabs  %0, %3, %1"
++  [(set_attr "length" "4")
++   (set_attr "cc" "set_z")])
++
++(define_peephole
++  [(set (match_operand:SI 2 "register_operand" "=r")
++      (abs:SI (match_operand:SI 1 "register_operand" "r")))
++   (set (match_operand:SI 0 "register_operand" "=r")
++      (plus:SI (match_dup 2)
++                 (match_operand:SI 3 "register_operand" "r")))]
++  "dead_or_set_p(insn, operands[2])"
++  "addabs  %0, %3, %1"
++  [(set_attr "length" "4")
++   (set_attr "cc" "set_z")])
++
++
++;;=================================================================
++;; Detect roundings
++;;=================================================================
++
++(define_insn "*round"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++        (ashiftrt:SI (plus:SI (match_operand:SI 1 "register_operand" "0")
++                              (match_operand:SI 2 "immediate_operand" "i"))
++                     (match_operand:SI 3 "immediate_operand" "i")))]
++  "avr32_rnd_operands(operands[2], operands[3])"
++
++  "satrnds    %0 >> %3, 31"
++
++  [(set_attr "type" "alu_sat")
++   (set_attr "length" "4")]
++
++  )
++
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand" "")
++      (plus:SI (match_dup 0)
++                 (match_operand:SI 1 "immediate_operand" "")))
++   (set (match_dup 0)
++      (ashiftrt:SI (match_dup 0)
++                     (match_operand:SI 2 "immediate_operand" "")))]
++  "avr32_rnd_operands(operands[1], operands[2])"
++
++  [(set (match_dup 0)
++        (ashiftrt:SI (plus:SI (match_dup 0)
++                              (match_dup 1))
++                     (match_dup 2)))]
++  )
++
++(define_peephole
++  [(set (match_operand:SI 0 "register_operand" "r")
++      (plus:SI (match_dup 0)
++                 (match_operand:SI 1 "immediate_operand" "i")))
++   (set (match_dup 0)
++      (ashiftrt:SI (match_dup 0)
++                     (match_operand:SI 2 "immediate_operand" "i")))]
++  "avr32_rnd_operands(operands[1], operands[2])"
++
++  "satrnds    %0 >> %2, 31"
++
++  [(set_attr "type" "alu_sat")
++   (set_attr "length" "4")
++   (set_attr "cc" "clobber")]
++
++  )
++
++
++
++
++;;=================================================================
++;; Conditional Subtract
++;;=================================================================
++
++
++(define_peephole
++  [(set (match_operand:SI 0 "register_operand" "")
++      (minus:SI (match_operand:SI 1 "register_operand" "")
++                (match_operand:SI 2 "immediate_operand" "")))
++   (set (match_dup 1)
++      (unspec:SI [(match_operand 5 "avr32_comparison_operator" "")
++                    (match_dup 0)
++                    (match_dup 1)
++                      (match_operand 3 "general_operand" "")
++                      (match_operand 4 "general_operand" "")]
++                      UNSPEC_MOVSICC))]
++
++  "(dead_or_set_p(insn, operands[0])) && avr32_const_ok_for_constraint_p(INTVAL(operands[2]), 'K', \"Ks08\")"
++
++  {
++
++   operands[5] = avr32_output_cmp(operands[5], GET_MODE(operands[3]), operands[3], operands[4]);
++
++   return "sub%5    %1, %2";
++  }
++
++  [(set_attr "length" "10")
++   (set_attr "cc" "clobber")]
++  )
++
++(define_peephole
++  [(set (match_operand:SI 0 "register_operand" "")
++      (plus:SI (match_operand:SI 1 "register_operand" "")
++                (match_operand:SI 2 "immediate_operand" "")))
++   (set (match_dup 1)
++      (unspec:SI [(match_operand 5 "avr32_comparison_operator" "")
++                    (match_dup 0)
++                    (match_dup 1)
++                    (match_operand 3 "general_operand" "")
++                    (match_operand 4 "general_operand" "")]
++                   UNSPEC_MOVSICC))]
++
++  "(dead_or_set_p(insn, operands[0]) && avr32_const_ok_for_constraint_p(INTVAL(operands[2]), 'I', \"Is08\"))"
++
++  {
++   operands[5] = avr32_output_cmp(operands[5], GET_MODE(operands[3]), operands[3], operands[4]);
++
++   return "sub%5    %1, %n2";
++  }
++  [(set_attr "length" "10")
++   (set_attr "cc" "clobber")]
++  )
++
++;;=================================================================
++;; mcall
++;;=================================================================
++(define_peephole
++  [(set (match_operand:SI 0 "register_operand"        "")
++      (match_operand 1 "avr32_const_pool_ref_operand"  ""))
++   (parallel [(call (mem:SI (match_dup 0))
++                    (match_operand 2 "" ""))
++              (clobber (reg:SI LR_REGNUM))])]
++  "dead_or_set_p(insn, operands[0])"
++  "mcall    %1"
++  [(set_attr "type" "call")
++   (set_attr "length" "4")
++   (set_attr "cc" "clobber")]
++)
++
++(define_peephole
++  [(set (match_operand:SI 2 "register_operand"        "")
++      (match_operand 1 "avr32_const_pool_ref_operand"  ""))
++   (parallel [(set (match_operand 0 "register_operand" "")
++                   (call (mem:SI (match_dup 2))
++                         (match_operand 3 "" "")))
++              (clobber (reg:SI LR_REGNUM))])]
++  "dead_or_set_p(insn, operands[2])"
++  "mcall    %1"
++  [(set_attr "type" "call")
++   (set_attr "length" "4")
++   (set_attr "cc" "call_set")]
++)
++
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand"    "")
++      (match_operand 1 "avr32_const_pool_ref_operand"  ""))
++   (parallel [(call (mem:SI (match_dup 0))
++                    (match_operand 2 "" ""))
++              (clobber (reg:SI LR_REGNUM))])]
++  "peep2_reg_dead_p(2, operands[0])"
++  [(parallel [(call (mem:SI (match_dup 1))
++                    (match_dup 2))
++              (clobber (reg:SI LR_REGNUM))])]
++  ""
++)
++
++(define_peephole2
++  [(set (match_operand:SI 0 "register_operand"        "")
++      (match_operand 1 "avr32_const_pool_ref_operand"  ""))
++   (parallel [(set (match_operand 2 "register_operand" "")
++                   (call (mem:SI (match_dup 0))
++                         (match_operand 3 "" "")))
++              (clobber (reg:SI LR_REGNUM))])]
++  "(peep2_reg_dead_p(2, operands[0]) || (REGNO(operands[2]) == REGNO(operands[0])))"
++  [(parallel [(set (match_dup 2)
++                   (call (mem:SI (match_dup 1))
++                         (match_dup 3)))
++              (clobber (reg:SI LR_REGNUM))])]
++  ""
++)
++
++;;=================================================================
++;; Returning a value
++;;=================================================================
++
++
++(define_peephole
++  [(set (match_operand 0 "register_operand" "")
++        (match_operand 1 "register_operand" ""))
++   (return)]
++  "USE_RETURN_INSN (TRUE) && (REGNO(operands[0]) == RETVAL_REGNUM)
++   && (REGNO(operands[1]) != LR_REGNUM)
++   && (REGNO_REG_CLASS(REGNO(operands[1])) == GENERAL_REGS)"
++  "retal    %1"
++  [(set_attr "type" "call")
++   (set_attr "length" "2")]
++  )
++
++
++(define_peephole
++  [(set (match_operand 0 "register_operand" "r")
++        (match_operand 1 "immediate_operand" "i"))
++   (return)]
++  "(USE_RETURN_INSN (FALSE) && (REGNO(operands[0]) == RETVAL_REGNUM) &&
++   ((INTVAL(operands[1]) == -1) || (INTVAL(operands[1]) == 0) || (INTVAL(operands[1]) == 1)))"
++  {
++    avr32_output_return_instruction (TRUE, FALSE, NULL, operands[1]);
++    return "";
++  }
++  [(set_attr "type" "call")
++   (set_attr "length" "4")]
++  )
++
++(define_peephole
++  [(set (match_operand 0 "register_operand" "r")
++        (match_operand 1 "immediate_operand" "i"))
++   (unspec_volatile [(return)] VUNSPEC_EPILOGUE)]
++  "(REGNO(operands[0]) == RETVAL_REGNUM) &&
++   ((INTVAL(operands[1]) == -1) || (INTVAL(operands[1]) == 0) || (INTVAL(operands[1]) == 1))"
++  {
++    avr32_output_return_instruction (FALSE, FALSE, NULL, operands[1]);
++    return "";
++  }
++  ; Length is absolute worst case
++  [(set_attr "type" "branch")
++   (set_attr "length" "12")]
++  )
++
++(define_peephole
++  [(set (match_operand 0 "register_operand" "r")
++      (unspec [(match_operand 1 "avr32_comparison_operator" "")
++                 (match_operand 2 "register_immediate_operand" "rKs08")
++                 (match_operand 3 "register_immediate_operand" "rKs08")
++                 (match_operand 4 "register_immediate_operand" "r")
++                 (match_operand 5 "register_immediate_operand" "rKs21")
++                 ]
++                UNSPEC_MOVSICC ))
++   (return)]
++  "USE_RETURN_INSN (TRUE) && (REGNO(operands[0]) == RETVAL_REGNUM) &&
++   ((GET_MODE(operands[4]) == SImode) ||
++   ((GET_MODE(operands[4]) != SImode) && (GET_CODE(operands[5]) == REG)))"
++  {
++   operands[1] = avr32_output_cmp(operands[1], GET_MODE(operands[4]), operands[4], operands[5]);
++
++   if ( GET_CODE(operands[2]) == REG
++        && GET_CODE(operands[3]) == REG
++        && REGNO(operands[2]) != LR_REGNUM
++        && REGNO(operands[3]) != LR_REGNUM ){
++      return "ret%1    %2\;ret%i1    %3";
++   } else if ( GET_CODE(operands[2]) == REG
++               && GET_CODE(operands[3]) == CONST_INT ){
++      if ( INTVAL(operands[3]) == -1
++           || INTVAL(operands[3]) == 0
++           || INTVAL(operands[3]) == 1 ){
++        return "ret%1    %2\;ret%i1    %d3";
++      } else {
++        return "mov%1    r12, %2\;mov%i1    r12, %3\;retal    r12";
++      }
++   } else if ( GET_CODE(operands[2]) == CONST_INT
++               && GET_CODE(operands[3]) == REG ){
++      if ( INTVAL(operands[2]) == -1
++           || INTVAL(operands[2]) == 0
++           || INTVAL(operands[2]) == 1 ){
++        return "ret%1    %d2\;ret%i1    %3";
++      } else {
++        return "mov%1    r12, %2\;mov%i1    r12, %3\;retal    r12";
++      }
++   } else {
++      if ( (INTVAL(operands[2]) == -1
++            || INTVAL(operands[2]) == 0
++            || INTVAL(operands[2]) == 1 )
++           && (INTVAL(operands[3]) == -1
++               || INTVAL(operands[3]) == 0
++               || INTVAL(operands[3]) == 1 )){
++        return "ret%1    %d2\;ret%i1    %d3";
++      } else {
++        return "mov%1    r12, %2\;mov%i1    r12, %3\;retal    r12";
++      }
++   }
++  }
++
++  [(set_attr "length" "14")
++   (set_attr "cc" "clobber")
++   (set_attr "type" "call")])
++
++
++;;=================================================================
++;; mulnhh.w
++;;=================================================================
++
++(define_peephole2
++  [(set (match_operand:HI 0 "register_operand" "")
++        (neg:HI (match_operand:HI 1 "register_operand" "")))
++   (set (match_operand:SI 2 "register_operand" "")
++        (mult:SI
++         (sign_extend:SI (match_dup 0))
++         (sign_extend:SI (match_operand:HI 3 "register_operand" ""))))]
++  "(peep2_reg_dead_p(2, operands[0])) || (REGNO(operands[2]) == REGNO(operands[0]))"
++  [ (set (match_dup 2)
++         (mult:SI
++          (sign_extend:SI (neg:HI (match_dup 1)))
++          (sign_extend:SI (match_dup 3))))]
++  ""
++  )
++
++(define_peephole2
++  [(set (match_operand:HI 0 "register_operand" "")
++        (neg:HI (match_operand:HI 1 "register_operand" "")))
++   (set (match_operand:SI 2 "register_operand" "")
++        (mult:SI
++         (sign_extend:SI (match_operand:HI 3 "register_operand" ""))
++         (sign_extend:SI (match_dup 0))))]
++  "(peep2_reg_dead_p(2, operands[0])) || (REGNO(operands[2]) == REGNO(operands[0]))"
++  [ (set (match_dup 2)
++         (mult:SI
++          (sign_extend:SI (neg:HI (match_dup 1)))
++          (sign_extend:SI (match_dup 3))))]
++  ""
++  )
++
++
++
++;;=================================================================
++;; sthh.w
++;;=================================================================
++(define_insn "vec_setv2hi"
++  [(set (match_operand:V2HI 0 "register_operand" "=r")
++        (vec_merge:V2HI
++         (match_dup 0)
++         (vec_duplicate:V2HI
++          (match_operand:HI 1 "register_operand" "r"))
++         (const_int 1)))]
++  ""
++  "bfins\t%0, %1, 16, 16"
++  [(set_attr "type" "alu")
++   (set_attr "length" "4")
++   (set_attr "cc" "clobber")])
++
++(define_insn "vec_setv2lo"
++  [(set (match_operand:V2HI 0 "register_operand" "+r")
++        (vec_merge:V2HI
++         (match_dup 0)
++         (vec_duplicate:V2HI
++          (match_operand:HI 1 "register_operand" "r"))
++         (const_int 2)))]
++  ""
++  "bfins\t%0, %1, 0, 16"
++  [(set_attr "type" "alu")
++   (set_attr "length" "4")
++   (set_attr "cc" "clobber")])
++
++(define_expand "vec_setv2"
++  [(set (match_operand:V2HI 0 "register_operand" "")
++        (vec_merge:V2HI
++         (match_dup 0)
++         (vec_duplicate:V2HI
++          (match_operand:HI 1 "register_operand" ""))
++         (match_operand 2 "immediate_operand" "")))]
++  ""
++  { operands[2] = GEN_INT(INTVAL(operands[2]) + 1); }
++  )
++
++(define_insn "vec_extractv2hi"
++  [(set (match_operand:HI 0 "register_operand" "=r")
++        (vec_select:HI
++         (match_operand:V2HI 1 "register_operand" "r")
++         (parallel [(match_operand:SI 2 "immediate_operand" "i")])))]
++  ""
++  {
++   if ( INTVAL(operands[2]) == 0 )
++      return "bfextu\t%0, %1, 16, 16";
++   else
++      return "bfextu\t%0, %1, 0, 16";
++  }
++  [(set_attr "type" "alu")
++   (set_attr "length" "4")
++   (set_attr "cc" "clobber")])
++
++(define_insn "vec_extractv4qi"
++  [(set (match_operand:QI 0 "register_operand" "=r")
++        (vec_select:QI
++         (match_operand:V4QI 1 "register_operand" "r")
++         (parallel [(match_operand:SI 2 "immediate_operand" "i")])))]
++  ""
++  {
++   switch ( INTVAL(operands[2]) ){
++     case 0:
++       return "bfextu\t%0, %1, 24, 8";
++     case 1:
++       return "bfextu\t%0, %1, 16, 8";
++     case 2:
++       return "bfextu\t%0, %1, 8, 8";
++     case 3:
++       return "bfextu\t%0, %1, 0, 8";
++     default:
++       abort();
++   }
++  }
++  [(set_attr "type" "alu")
++   (set_attr "length" "4")
++   (set_attr "cc" "clobber")])
++
++
++(define_insn "concatv2hi"
++  [(set (match_operand:V2HI 0 "register_operand" "=r, r, r")
++        (vec_concat:V2HI
++         (match_operand:HI 1 "register_operand" "r, r, 0")
++         (match_operand:HI 2 "register_operand" "r, 0, r")))]
++  ""
++  "@
++   mov\t%0, %1\;bfins\t%0, %2, 0, 16
++   bfins\t%0, %2, 0, 16
++   bfins\t%0, %1, 16, 16"
++  [(set_attr "length" "6, 4, 4")
++   (set_attr "type" "alu")])
++
++;(define_peephole2
++;  [(set (match_operand:HI 0 "register_operand" "r")
++;        (plus:HI (match_operand:HI 3 "register_operand" "r")
++;                 (match_operand:HI 4 "register_operand" "r")))
++;   (set (match_operand:HI 1 "register_operand" "r")
++;        (minus:HI (match_dup 3)
++;                  (match_dup 4)))]
++;  "REGNO(operands[0]) != REGNO(operands[3])"
++;  [(set (match_dup 2)
++;        (vec_concat:V2HI
++;         (minus:HI (match_dup 3)
++;                  (match_dup 4))
++;         (plus:HI (match_dup 3) (match_dup 4))))
++;   (set (match_dup 1) (vec_select:HI (match_dup 2)
++;                                     (parallel [(const_int 0)])))]
++;
++;  "operands[2] = gen_rtx_REG(V2HImode, REGNO(operands[0]));"
++;  )
++;
++;(define_peephole2
++;  [(set (match_operand:HI 0 "register_operand" "r")
++;        (minus:HI (match_operand:HI 3 "register_operand" "r")
++;                 (match_operand:HI 4 "register_operand" "r")))
++;   (set (match_operand:HI 1 "register_operand" "r")
++;        (plus:HI (match_dup 3)
++;                  (match_dup 4)))]
++;  "REGNO(operands[0]) != REGNO(operands[3])"
++;  [(set (match_dup 2)
++;        (vec_concat:V2HI
++;         (plus:HI (match_dup 3)
++;                  (match_dup 4))
++;         (minus:HI (match_dup 3) (match_dup 4))))
++;   (set (match_dup 1) (vec_select:HI (match_dup 2)
++;                                     (parallel [(const_int 0)])))]
++;
++;  "operands[2] = gen_rtx_REG(V2HImode, REGNO(operands[0]));"
++;  )
++
++
++;(define_peephole2
++;  [(match_scratch:V2HI 5 "r")
++;   (set (mem:HI (plus:SI (match_operand:SI 0 "register_operand" "")
++;                         (match_operand:HI 1 "immediate_operand" "")))
++;        (match_operand:HI 2 "register_operand"  "r"))
++;   (set (mem:HI (plus:SI (match_dup 0)
++;                         (match_operand:HI 3 "immediate_operand" "")))
++;        (match_operand:HI 4 "register_operand"  "r"))]
++;  "(GET_CODE(operands[1]) == CONST_INT) && (GET_CODE(operands[3]) == CONST_INT)
++;   && (INTVAL(operands[3]) == (INTVAL(operands[1]) + 2))"
++;
++;  [(set (match_dup 5)
++;        (vec_concat:V2HI
++;         (match_dup 2)
++;         (match_dup 4)))
++;   (set (mem:V2HI (plus:SI (match_dup 0) (match_dup 1)))
++;        (match_dup 5))]
++;  ""
++;  )
++;
++
++;(define_insn "sthh_w"
++;  [(set (match_operand:V2HI 0 "avr32_sthh_w_memory_operand" "m")
++;        (vec_concat:V2HI
++;         (vec_select:HI (match_operand:V2HI 1 "register_operand" "r")
++;                        (parallel [(match_operand 3 "immediate_operand" "i")]))
++;         (vec_select:HI (match_operand:V2HI 2 "register_operand" "r")
++;                        (parallel [(match_operand 4 "immediate_operand" "i")]))))]
++;  "MEM_ALIGN(operands[0]) >= 32"
++;  "sthh.w\t%0, %1:%h3, %2:%h4"
++;  [(set_attr "length" "4")
++;   (set_attr "type" "store")])
++;
++;(define_peephole2
++;  [(set (mem:HI (plus:SI (match_operand:SI 0 "register_operand" "")
++;                         (match_operand:HI 1 "immediate_operand" "")))
++;        (match_operand:HI 2 "register_operand"  "r"))
++;   (set (mem:HI (plus:SI (match_dup 0)
++;                         (match_operand:HI 3 "avr32_sthh_operand" "")))
++;        (match_operand:HI 4 "register_operand"  "r"))]
++;  "(GET_CODE(operands[1]) == CONST_INT) && (GET_CODE(operands[3]) == CONST_INT)
++;   && (INTVAL(operands[3]) == (INTVAL(operands[1]) - 2))"
++;
++;  [(paralell [(set (mem:HI (plus:SI (match_dup 0)
++;                                    (match_dup 3)))
++;                   (match_dup 4))
++;              (set (mem:HI (plus:SI (match_dup 0)
++;                                    (plus:SI (match_dup 3) (const_int 2))))
++;                   (match_dup 2))])]
++;  ""
++;  )
++
++
++;; Load the SIMD description
++(include "simd.md")
++
++;; Load the FP coprocessor patterns
++(include "fpcp.md")
+diff -Nur gcc-4.1.2/gcc/config/avr32/avr32-modes.def gcc-4.1.2-owrt/gcc/config/avr32/avr32-modes.def
+--- gcc-4.1.2/gcc/config/avr32/avr32-modes.def 1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/avr32-modes.def    2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1 @@
++VECTOR_MODES (INT, 4);        /*            V4QI V2HI */
+diff -Nur gcc-4.1.2/gcc/config/avr32/avr32.opt gcc-4.1.2-owrt/gcc/config/avr32/avr32.opt
+--- gcc-4.1.2/gcc/config/avr32/avr32.opt       1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/avr32.opt  2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,78 @@
++; Options for the ATMEL AVR32 port of the compiler.
++
++; Copyright 2007 Atmel Corporation.
++;
++; This file is part of GCC.
++;
++; GCC 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.
++;
++; GCC 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 GCC; see the file COPYING.  If not, write to the Free
++; Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
++; 02110-1301, USA.
++
++muse-rodata-section
++Target Report Mask(USE_RODATA_SECTION)
++Do not put readonly-data in .text section, but in .rodata.
++
++mhard-float
++Target Report Mask(HARD_FLOAT)
++Use floating point coprocessor instructions.
++
++msoft-float
++Target Report InverseMask(HARD_FLOAT, SOFT_FLOAT)
++Use software floating-point library for floating-point operations.
++
++force-double-align
++Target Report RejectNegative Mask(FORCE_DOUBLE_ALIGN)
++Force double-word alignment for double-word memory accesses.
++
++mno-init-got
++Target Report RejectNegative Mask(NO_INIT_GOT)
++Do not initialize GOT register before using it when compiling PIC code.
++
++mrelax
++Target Report Mask(RELAX)
++Let invoked assembler and linker do relaxing (Enabled by default when optimization level is >1).
++
++mno-reorg-opt
++Target Report RejectNegative Mask(NO_REORG_OPT)
++Do not perform machine dependent optimizations in reorg stage.
++
++mmd-reorg-opt
++Target Report RejectNegative InverseMask(NO_REORG_OPT,MD_REORG_OPTIMIZATION)
++Perform machine dependent optimizations in reorg stage.
++
++masm-addr-pseudos
++Target Report RejectNegative InverseMask(NO_ASM_ADDR_PSEUDOS, HAS_ASM_ADDR_PSEUDOS)
++Use assembler pseudo-instructions lda.w and call for handling direct addresses. (Enabled by default)
++
++mno-asm-addr-pseudos
++Target Report RejectNegative Mask(NO_ASM_ADDR_PSEUDOS)
++Do not use assembler pseudo-instructions lda.w and call for handling direct addresses.
++
++mno-pic
++Target Report RejectNegative Mask(NO_PIC)
++Do not emit position-independent code (will break dynamic linking.)
++
++mpart=
++Target Report RejectNegative Joined Var(avr32_part_name)
++Specify the AVR32 part name
++
++mcpu=
++Target Report RejectNegative Joined Undocumented Var(avr32_part_name)
++Specify the AVR32 part name (deprecated)
++
++march=
++Target Report RejectNegative Joined Var(avr32_arch_name)
++Specify the AVR32 architecture name
++
++
+diff -Nur gcc-4.1.2/gcc/config/avr32/avr32-protos.h gcc-4.1.2-owrt/gcc/config/avr32/avr32-protos.h
+--- gcc-4.1.2/gcc/config/avr32/avr32-protos.h  1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/avr32-protos.h     2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,175 @@
++/*
++   Prototypes for exported functions defined in avr32.c
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++   Initial porting by Anders Ã…dland.
++
++   This file is part of GCC.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
++
++
++#ifndef AVR32_PROTOS_H
++#define AVR32_PROTOS_H
++
++extern const int swap_reg[];
++
++extern int avr32_valid_macmac_bypass (rtx, rtx);
++extern int avr32_valid_mulmac_bypass (rtx, rtx);
++
++extern int avr32_decode_lcomm_symbol_offset (rtx, int *);
++extern void avr32_encode_lcomm_symbol_offset (tree, char *, int);
++
++extern const char *avr32_strip_name_encoding (const char *);
++
++extern rtx avr32_get_note_reg_equiv (rtx insn);
++
++extern int avr32_use_return_insn (int iscond);
++
++extern void avr32_make_reglist16 (int reglist16_vect, char *reglist16_string);
++
++extern void avr32_make_reglist8 (int reglist8_vect, char *reglist8_string);
++extern void avr32_make_fp_reglist_w (int reglist_mask, char *reglist_string);
++extern void avr32_make_fp_reglist_d (int reglist_mask, char *reglist_string);
++
++extern void avr32_output_return_instruction (int single_ret_inst,
++                                           int iscond, rtx cond,
++                                           rtx r12_imm);
++extern void avr32_expand_prologue (void);
++extern void avr32_set_return_address (rtx source);
++
++extern int avr32_hard_regno_mode_ok (int regno, enum machine_mode mode);
++extern int avr32_extra_constraint_s (rtx value, const int strict);
++extern int avr32_eh_return_data_regno (const int n);
++extern int avr32_initial_elimination_offset (const int from, const int to);
++extern rtx avr32_function_arg (CUMULATIVE_ARGS * cum, enum machine_mode mode,
++                             tree type, int named);
++extern void avr32_init_cumulative_args (CUMULATIVE_ARGS * cum, tree fntype,
++                                      rtx libname, tree fndecl);
++extern void avr32_function_arg_advance (CUMULATIVE_ARGS * cum,
++                                      enum machine_mode mode,
++                                      tree type, int named);
++#ifdef ARGS_SIZE_RTX
++/* expr.h defines ARGS_SIZE_RTX and `enum direction'.  */
++extern enum direction avr32_function_arg_padding (enum machine_mode mode,
++                                                tree type);
++#endif /* ARGS_SIZE_RTX */
++extern rtx avr32_function_value (tree valtype, tree func);
++extern rtx avr32_libcall_value (enum machine_mode mode);
++extern int avr32_sched_use_dfa_pipeline_interface (void);
++extern bool avr32_return_in_memory (tree type, tree fntype);
++extern void avr32_regs_to_save (char *operand);
++extern void avr32_target_asm_function_prologue (FILE * file,
++                                              HOST_WIDE_INT size);
++extern void avr32_target_asm_function_epilogue (FILE * file,
++                                              HOST_WIDE_INT size);
++extern void avr32_trampoline_template (FILE * file);
++extern void avr32_initialize_trampoline (rtx addr, rtx fnaddr,
++                                       rtx static_chain);
++extern int avr32_legitimate_address (enum machine_mode mode, rtx x,
++                                   int strict);
++extern int avr32_legitimate_constant_p (rtx x);
++
++extern int avr32_legitimate_pic_operand_p (rtx x);
++
++extern rtx avr32_find_symbol (rtx x);
++extern void avr32_select_section (rtx exp, int reloc, int align);
++extern void avr32_encode_section_info (tree decl, rtx rtl, int first);
++extern void avr32_asm_file_end (FILE * stream);
++extern void avr32_asm_output_ascii (FILE * stream, char *ptr, int len);
++extern void avr32_asm_output_common (FILE * stream, const char *name,
++                                   int size, int rounded);
++extern void avr32_asm_output_label (FILE * stream, const char *name);
++extern void avr32_asm_declare_object_name (FILE * stream, char *name,
++                                         tree decl);
++extern void avr32_asm_globalize_label (FILE * stream, const char *name);
++extern void avr32_asm_weaken_label (FILE * stream, const char *name);
++extern void avr32_asm_output_external (FILE * stream, tree decl,
++                                     const char *name);
++extern void avr32_asm_output_external_libcall (FILE * stream, rtx symref);
++extern void avr32_asm_output_labelref (FILE * stream, const char *name);
++extern void avr32_notice_update_cc (rtx exp, rtx insn);
++extern void avr32_print_operand (FILE * stream, rtx x, int code);
++extern void avr32_print_operand_address (FILE * stream, rtx x);
++
++extern int avr32_symbol (rtx x);
++
++extern void avr32_select_rtx_section (enum machine_mode mode, rtx x,
++                                    unsigned HOST_WIDE_INT align);
++
++extern int avr32_load_multiple_operation (rtx op, enum machine_mode mode);
++extern int avr32_store_multiple_operation (rtx op, enum machine_mode mode);
++
++extern int avr32_const_ok_for_constraint_p (HOST_WIDE_INT value, char c,
++                                          const char *str);
++
++extern bool avr32_cannot_force_const_mem (rtx x);
++
++extern void avr32_init_builtins (void);
++
++extern rtx avr32_expand_builtin (tree exp, rtx target, rtx subtarget,
++                               enum machine_mode mode, int ignore);
++
++extern bool avr32_must_pass_in_stack (enum machine_mode mode, tree type);
++
++extern bool avr32_strict_argument_naming (CUMULATIVE_ARGS * ca);
++
++extern bool avr32_pass_by_reference (CUMULATIVE_ARGS * cum,
++                                   enum machine_mode mode,
++                                   tree type, bool named);
++
++extern rtx avr32_gen_load_multiple (rtx * regs, int count, rtx from,
++                                  int write_back, int in_struct_p,
++                                  int scalar_p);
++extern rtx avr32_gen_store_multiple (rtx * regs, int count, rtx to,
++                                   int in_struct_p, int scalar_p);
++extern int avr32_gen_movmemsi (rtx * operands);
++
++extern int avr32_rnd_operands (rtx add, rtx shift);
++extern int avr32_adjust_insn_length (rtx insn, int length);
++
++extern int symbol_mentioned_p (rtx x);
++extern int label_mentioned_p (rtx x);
++extern rtx legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg);
++extern int avr32_address_register_rtx_p (rtx x, int strict_p);
++extern int avr32_legitimate_index_p (enum machine_mode mode, rtx index,
++                                   int strict_p);
++
++extern int avr32_const_double_immediate (rtx value);
++extern void avr32_init_expanders (void);
++extern rtx avr32_return_addr (int count, rtx frame);
++extern bool avr32_got_mentioned_p (rtx addr);
++
++extern void avr32_final_prescan_insn (rtx insn, rtx * opvec, int noperands);
++
++extern int avr32_expand_movcc (enum machine_mode mode, rtx operands[]);
++extern int avr32_expand_addcc (enum machine_mode mode, rtx operands[]);
++#ifdef RTX_CODE
++extern int avr32_expand_scc (RTX_CODE cond, rtx * operands);
++#endif
++
++extern int avr32_store_bypass (rtx insn_out, rtx insn_in);
++extern int avr32_mul_waw_bypass (rtx insn_out, rtx insn_in);
++extern int avr32_valid_load_double_bypass (rtx insn_out, rtx insn_in);
++extern int avr32_valid_load_quad_bypass (rtx insn_out, rtx insn_in);
++extern rtx avr32_output_cmp (rtx cond, enum machine_mode mode,
++                           rtx op0, rtx op1);
++
++rtx get_next_insn_cond (rtx cur_insn);
++int set_next_insn_cond (rtx cur_insn, rtx cond);
++void avr32_override_options (void);
++
++#endif /* AVR32_PROTOS_H */
+diff -Nur gcc-4.1.2/gcc/config/avr32/crti.asm gcc-4.1.2-owrt/gcc/config/avr32/crti.asm
+--- gcc-4.1.2/gcc/config/avr32/crti.asm        1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/crti.asm   2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,64 @@
++/*
++   Init/fini stuff for AVR32.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++
++   This file is part of GCC.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
++
++      
++/* The code in sections .init and .fini is supposed to be a single
++   regular function.  The function in .init is called directly from
++   start in crt1.asm.  The function in .fini is atexit()ed in crt1.asm
++   too.
++
++   crti.asm contributes the prologue of a function to these sections,
++   and crtn.asm comes up the epilogue.  STARTFILE_SPEC should list
++   crti.o before any other object files that might add code to .init
++   or .fini sections, and ENDFILE_SPEC should list crtn.o after any
++   such object files.  */
++              
++      .file           "crti.asm"
++
++      .section        ".init"
++/* Just load the GOT */
++      .align 2
++      .global _init
++_init:
++      stm     --sp, r6, lr
++      lddpc   r6, 1f          
++0:    
++      rsub    r6, pc
++      rjmp    2f
++      .align  2
++1:    .long   0b - _GLOBAL_OFFSET_TABLE_              
++2:    
++                              
++      .section        ".fini"
++/* Just load the GOT */
++      .align  2
++      .global _fini
++_fini:
++      stm     --sp, r6, lr
++      lddpc   r6, 1f          
++0:    
++      rsub    r6, pc
++      rjmp    2f
++      .align  2
++1:    .long   0b - _GLOBAL_OFFSET_TABLE_              
++2:    
++
+diff -Nur gcc-4.1.2/gcc/config/avr32/crtn.asm gcc-4.1.2-owrt/gcc/config/avr32/crtn.asm
+--- gcc-4.1.2/gcc/config/avr32/crtn.asm        1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/crtn.asm   2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,44 @@
++/*   Copyright (C) 2001 Free Software Foundation, Inc.
++    Written By Nick Clifton
++
++  This file 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.
++
++  In addition to the permissions in the GNU General Public License, the
++  Free Software Foundation gives you unlimited permission to link the
++  compiled version of this file with other programs, and to distribute
++  those programs without any restriction coming from the use of this
++  file.  (The General Public License restrictions do apply in other
++  respects; for example, they cover modification of the file, and
++  distribution when not linked into another program.)
++
++  This file is distributed in the hope that it will be useful, but
++  WITHOUT ANY WARRANTY; without even the implied warranty of
++  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++  General Public License for more details.
++
++  You should have received a copy of the GNU General Public License
++  along with this program; see the file COPYING.  If not, write to
++  the Free Software Foundation, 59 Temple Place - Suite 330,
++  Boston, MA 02111-1307, USA.
++
++     As a special exception, if you link this library with files
++     compiled with GCC to produce an executable, this does not cause
++     the resulting executable to be covered by the GNU General Public License.
++     This exception does not however invalidate any other reasons why
++     the executable file might be covered by the GNU General Public License.
++*/
++
++
++
++      
++      .file           "crtn.asm"
++
++      .section        ".init"
++      ldm     sp++, r6, pc
++                      
++      .section        ".fini"
++      ldm     sp++, r6, pc
++              
+diff -Nur gcc-4.1.2/gcc/config/avr32/fpcp.md gcc-4.1.2-owrt/gcc/config/avr32/fpcp.md
+--- gcc-4.1.2/gcc/config/avr32/fpcp.md 1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/fpcp.md    2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,551 @@
++;;   AVR32 machine description file for Floating-Point instructions.
++;;   Copyright 2003-2006 Atmel Corporation.
++;;
++;;   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++;;
++;;   This file is part of GCC.
++;;
++;;   This program is free software; you can redistribute it and/or modify
++;;   it under the terms of the GNU General Public License as published by
++;;   the Free Software Foundation; either version 2 of the License, or
++;;   (at your option) any later version.
++;;
++;;   This program is distributed in the hope that it will be useful,
++;;   but WITHOUT ANY WARRANTY; without even the implied warranty of
++;;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++;;   GNU General Public License for more details.
++;;
++;;   You should have received a copy of the GNU General Public License
++;;   along with this program; if not, write to the Free Software
++;;   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++
++;; -*- Mode: Scheme -*-
++
++;;******************************************************************************
++;; Automaton pipeline description for floating-point coprocessor insns
++;;******************************************************************************
++(define_cpu_unit "fid,fm1,fm2,fm3,fm4,fwb,fcmp,fcast" "avr32_ap")
++
++(define_insn_reservation "fmv_op" 1
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "fmv"))
++  "is,da,d,fid,fwb")
++
++(define_insn_reservation "fmul_op" 5
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "fmul"))
++  "is,da,d,fid,fm1,fm2,fm3,fm4,fwb")
++
++(define_insn_reservation "fcmps_op" 1
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "fcmps"))
++  "is,da,d,fid,fcmp")
++
++(define_insn_reservation "fcmpd_op" 2
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "fcmpd"))
++  "is,da,d,fid*2,fcmp")
++
++(define_insn_reservation "fcast_op" 3
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "fcast"))
++  "is,da,d,fid,fcmp,fcast,fwb")
++
++(define_insn_reservation "fmvcpu_op" 2
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "fmvcpu"))
++  "is,da,d")
++
++(define_insn_reservation "fldd_op" 1
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "fldd"))
++  "is,da,d,fwb")
++
++(define_insn_reservation "flds_op" 1
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "flds"))
++  "is,da,d,fwb")
++
++(define_insn_reservation "fsts_op" 0
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "fsts"))
++  "is,da*2,d")
++
++(define_insn_reservation "fstd_op" 0
++  (and (eq_attr "pipeline" "ap")
++       (eq_attr "type" "fstd"))
++  "is,da*2,d")
++
++
++(define_insn "*movsf_fpcp"
++  [(set (match_operand:SF 0 "nonimmediate_operand"     "=f,f,r,f,m,r,r,r,m")
++      (match_operand:SF 1 "general_operand"          " f,r,f,m,f,r,G,m,r"))]
++  "TARGET_HARD_FLOAT"
++  "@
++   fmov.s\t%0, %1
++   fmov.s\t%0, %1
++   fmov.s\t%0, %1
++   fld.s\t%0, %1
++   fst.s\t%0, %1
++   mov\t%0, %1
++   mov\t%0, %1
++   ld.w\t%0, %1
++   st.w\t%0, %1"
++  [(set_attr "length" "4,4,4,4,4,2,4,4,4")
++   (set_attr "type" "fmv,flds,fmvcpu,flds,fsts,alu,alu,load,store")])
++
++(define_insn_and_split "*movdf_fpcp"
++  [(set (match_operand:DF 0 "nonimmediate_operand"     "=f,f,r,f,m,r,r,m")
++      (match_operand:DF 1 "general_operand"          " f,r,f,m,f,r,m,r"))]
++  "TARGET_HARD_FLOAT"
++  "@
++   fmov.d\t%0, %1
++   fmov.d\t%0, %1
++   fmov.d\t%0, %1
++   fld.d\t%0, %1
++   fst.d\t%0, %1
++   mov\t%0, %1\;mov\t%m0, %m1
++   ld.d\t%0, %1
++   st.d\t%0, %1"
++
++  "TARGET_HARD_FLOAT
++   && reload_completed
++   && (REG_P(operands[0]) &&  (REGNO_REG_CLASS(REGNO(operands[0])) == GENERAL_REGS))
++   && (REG_P(operands[1]) &&  (REGNO_REG_CLASS(REGNO(operands[1])) == GENERAL_REGS))"
++  [(set (match_dup 0) (match_dup 1))
++   (set (match_dup 2) (match_dup 3))]
++  "
++   {
++    operands[2] = gen_highpart (SImode, operands[0]);
++    operands[0] = gen_lowpart (SImode, operands[0]);
++    operands[3] = gen_highpart(SImode, operands[1]);
++    operands[1] = gen_lowpart(SImode, operands[1]);
++   }
++  "
++
++  [(set_attr "length" "4,4,4,4,4,4,4,4")
++   (set_attr "type" "fmv,fldd,fmvcpu,fldd,fstd,alu2,load2,store2")])
++
++
++(define_insn "mulsf3"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (mult:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")
++               (match_operand:SF 2 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fmul.s\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_insn "nmulsf3"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (neg:SF (mult:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")
++                         (match_operand:SF 2 "avr32_fp_register_operand" "f"))))]
++  "TARGET_HARD_FLOAT"
++  "fnmul.s\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_peephole2
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "")
++      (mult:SF (match_operand:SF 1 "avr32_fp_register_operand" "")
++               (match_operand:SF 2 "avr32_fp_register_operand" "")))
++   (set (match_operand:SF          3 "avr32_fp_register_operand" "")
++      (neg:SF (match_dup 0)))]
++  "TARGET_HARD_FLOAT &&
++   (peep2_reg_dead_p(2, operands[0]) || (REGNO(operands[3]) == REGNO(operands[0])))"
++  [(set (match_dup 3)
++      (neg:SF (mult:SF (match_dup 1)
++                       (match_dup 2))))]
++)
++
++
++(define_insn "macsf3"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (plus:SF (mult:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")
++                          (match_operand:SF 2 "avr32_fp_register_operand" "f"))
++                 (match_operand:SF 3 "avr32_fp_register_operand" "0")))]
++  "TARGET_HARD_FLOAT"
++  "fmac.s\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_insn "nmacsf3"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (plus:SF  (neg:SF (mult:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")
++                                   (match_operand:SF 2 "avr32_fp_register_operand" "f")))
++                  (match_operand:SF 3 "avr32_fp_register_operand" "0")))]
++  "TARGET_HARD_FLOAT"
++  "fnmac.s\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_peephole2
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "")
++      (mult:SF (match_operand:SF 1 "avr32_fp_register_operand" "")
++               (match_operand:SF 2 "avr32_fp_register_operand" "")))
++   (set (match_operand:SF          3 "avr32_fp_register_operand" "")
++      (minus:SF
++       (match_dup 3)
++       (match_dup 0)))]
++  "TARGET_HARD_FLOAT && peep2_reg_dead_p(2, operands[0])"
++  [(set (match_dup 3)
++      (plus:SF  (neg:SF (mult:SF (match_dup 1)
++                                   (match_dup 2)))
++                  (match_dup 3)))]
++)
++
++
++(define_insn "msubacsf3"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (minus:SF (mult:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")
++                           (match_operand:SF 2 "avr32_fp_register_operand" "f"))
++                  (match_operand:SF 3 "avr32_fp_register_operand" "0")))]
++  "TARGET_HARD_FLOAT"
++  "fmsc.s\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_peephole2
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "")
++      (mult:SF (match_operand:SF 1 "avr32_fp_register_operand" "")
++               (match_operand:SF 2 "avr32_fp_register_operand" "")))
++   (set (match_operand:SF          3 "avr32_fp_register_operand" "")
++      (minus:SF
++       (match_dup 0)
++       (match_dup 3)))]
++  "TARGET_HARD_FLOAT && peep2_reg_dead_p(2, operands[0])"
++  [(set (match_dup 3)
++      (minus:SF  (mult:SF (match_dup 1)
++                          (match_dup 2))
++                 (match_dup 3)))]
++)
++
++(define_insn "nmsubacsf3"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (minus:SF  (neg:SF (mult:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")
++                                    (match_operand:SF 2 "avr32_fp_register_operand" "f")))
++                   (match_operand:SF 3 "avr32_fp_register_operand" "0")))]
++  "TARGET_HARD_FLOAT"
++  "fnmsc.s\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++
++
++(define_insn "addsf3"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (plus:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")
++               (match_operand:SF 2 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fadd.s\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_insn "subsf3"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (minus:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")
++                  (match_operand:SF 2 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fsub.s\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++
++(define_insn "negsf2"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (neg:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fneg.s\t%0, %1"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmv")])
++
++(define_insn "abssf2"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (abs:SF (match_operand:SF 1 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fabs.s\t%0, %1"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmv")])
++
++(define_insn "truncdfsf2"
++  [(set (match_operand:SF          0 "avr32_fp_register_operand" "=f")
++      (float_truncate:SF
++         (match_operand:DF 1 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fcastd.s\t%0, %1"
++  [(set_attr "length" "4")
++   (set_attr "type" "fcast")])
++
++(define_insn "extendsfdf2"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (float_extend:DF
++         (match_operand:SF 1 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fcasts.d\t%0, %1"
++  [(set_attr "length" "4")
++   (set_attr "type" "fcast")])
++
++(define_insn "muldf3"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (mult:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")
++               (match_operand:DF 2 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fmul.d\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_insn "nmuldf3"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (neg:DF (mult:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")
++                         (match_operand:DF 2 "avr32_fp_register_operand" "f"))))]
++  "TARGET_HARD_FLOAT"
++  "fnmul.d\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_peephole2
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "")
++      (mult:DF (match_operand:DF 1 "avr32_fp_register_operand" "")
++               (match_operand:DF 2 "avr32_fp_register_operand" "")))
++   (set (match_operand:DF          3 "avr32_fp_register_operand" "")
++      (neg:DF (match_dup 0)))]
++  "TARGET_HARD_FLOAT &&
++   (peep2_reg_dead_p(2, operands[0]) || (REGNO(operands[3]) == REGNO(operands[0])))"
++  [(set (match_dup 3)
++      (neg:DF (mult:DF (match_dup 1)
++                       (match_dup 2))))]
++)
++
++(define_insn "macdf3"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (plus:DF (mult:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")
++                          (match_operand:DF 2 "avr32_fp_register_operand" "f"))
++                 (match_operand:DF 3 "avr32_fp_register_operand" "0")))]
++  "TARGET_HARD_FLOAT"
++  "fmac.d\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_insn "msubacdf3"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (minus:DF (mult:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")
++                           (match_operand:DF 2 "avr32_fp_register_operand" "f"))
++                  (match_operand:DF 3 "avr32_fp_register_operand" "0")))]
++  "TARGET_HARD_FLOAT"
++  "fmsc.d\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_peephole2
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "")
++      (mult:DF (match_operand:DF 1 "avr32_fp_register_operand" "")
++               (match_operand:DF 2 "avr32_fp_register_operand" "")))
++   (set (match_operand:DF          3 "avr32_fp_register_operand" "")
++      (minus:DF
++       (match_dup 0)
++       (match_dup 3)))]
++  "TARGET_HARD_FLOAT && peep2_reg_dead_p(2, operands[0])"
++  [(set (match_dup 3)
++      (minus:DF  (mult:DF (match_dup 1)
++                          (match_dup 2))
++                 (match_dup 3)))]
++  )
++
++(define_insn "nmsubacdf3"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (minus:DF  (neg:DF (mult:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")
++                                    (match_operand:DF 2 "avr32_fp_register_operand" "f")))
++                   (match_operand:DF 3 "avr32_fp_register_operand" "0")))]
++  "TARGET_HARD_FLOAT"
++  "fnmsc.d\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_insn "nmacdf3"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (plus:DF  (neg:DF (mult:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")
++                                   (match_operand:DF 2 "avr32_fp_register_operand" "f")))
++                  (match_operand:DF 3 "avr32_fp_register_operand" "0")))]
++  "TARGET_HARD_FLOAT"
++  "fnmac.d\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_peephole2
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "")
++      (mult:DF (match_operand:DF 1 "avr32_fp_register_operand" "")
++               (match_operand:DF 2 "avr32_fp_register_operand" "")))
++   (set (match_operand:DF          3 "avr32_fp_register_operand" "")
++      (minus:DF
++       (match_dup 3)
++       (match_dup 0)))]
++  "TARGET_HARD_FLOAT && peep2_reg_dead_p(2, operands[0])"
++  [(set (match_dup 3)
++      (plus:DF  (neg:DF (mult:DF (match_dup 1)
++                                   (match_dup 2)))
++                  (match_dup 3)))]
++)
++
++(define_insn "adddf3"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (plus:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")
++               (match_operand:DF 2 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fadd.d\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_insn "subdf3"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (minus:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")
++                  (match_operand:DF 2 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fsub.d\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmul")])
++
++(define_insn "negdf2"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (neg:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fneg.d\t%0, %1"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmv")])
++
++(define_insn "absdf2"
++  [(set (match_operand:DF          0 "avr32_fp_register_operand" "=f")
++      (abs:DF (match_operand:DF 1 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  "fabs.d\t%0, %1"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmv")])
++
++
++(define_expand "cmpdf"
++  [(set (cc0)
++      (compare:DF
++       (match_operand:DF 0 "general_operand" "")
++       (match_operand:DF 1 "general_operand"  "")))]
++  "TARGET_HARD_FLOAT"
++  "{
++   rtx tmpreg;
++   if ( !REG_P(operands[0]) )
++     operands[0] = force_reg(DFmode, operands[0]);
++
++   if ( !REG_P(operands[1]) )
++     operands[1] = force_reg(DFmode, operands[1]);
++
++   avr32_compare_op0 = operands[0];
++   avr32_compare_op1 = operands[1];
++
++   emit_insn(gen_cmpdf_internal(operands[0], operands[1]));
++
++   tmpreg = gen_reg_rtx(SImode);
++   emit_insn(gen_fpcc_to_reg(tmpreg));
++   emit_insn(gen_reg_to_cc(tmpreg));
++
++   DONE;
++  }"
++)
++
++(define_insn "cmpdf_internal"
++  [(set (reg:CC FPCC_REGNUM)
++      (compare:CC
++       (match_operand:DF 0 "avr32_fp_register_operand" "f")
++       (match_operand:DF 1 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  {
++   if (!rtx_equal_p(cc_prev_status.mdep.fpvalue, SET_SRC(PATTERN (insn))) )
++      return "fcmp.d\t%0, %1";
++   return "";
++  }
++  [(set_attr "length" "4")
++   (set_attr "type" "fcmpd")
++   (set_attr "cc" "fpcompare")])
++
++(define_expand "cmpsf"
++  [(set (cc0)
++      (compare:SF
++       (match_operand:SF 0 "general_operand" "")
++       (match_operand:SF 1 "general_operand"  "")))]
++  "TARGET_HARD_FLOAT"
++  "{
++   rtx tmpreg;
++   if ( !REG_P(operands[0]) )
++     operands[0] = force_reg(SFmode, operands[0]);
++
++   if ( !REG_P(operands[1]) )
++     operands[1] = force_reg(SFmode, operands[1]);
++
++   avr32_compare_op0 = operands[0];
++   avr32_compare_op1 = operands[1];
++
++   emit_insn(gen_cmpsf_internal(operands[0], operands[1]));
++
++   tmpreg = gen_reg_rtx(SImode);
++   emit_insn(gen_fpcc_to_reg(tmpreg));
++   emit_insn(gen_reg_to_cc(tmpreg));
++
++   DONE;
++  }"
++)
++
++(define_insn "cmpsf_internal"
++  [(set (reg:CC FPCC_REGNUM)
++      (compare:CC
++       (match_operand:SF 0 "avr32_fp_register_operand" "f")
++       (match_operand:SF 1 "avr32_fp_register_operand" "f")))]
++  "TARGET_HARD_FLOAT"
++  {
++   if (!rtx_equal_p(cc_prev_status.mdep.fpvalue, SET_SRC(PATTERN (insn))) )
++      return "fcmp.s\t%0, %1";
++   return "";
++  }
++  [(set_attr "length" "4")
++   (set_attr "type" "fcmps")
++   (set_attr "cc" "fpcompare")])
++
++(define_insn "fpcc_to_reg"
++  [(set (match_operand:SI 0 "register_operand" "=r")
++      (unspec:SI [(reg:CC FPCC_REGNUM)]
++                 UNSPEC_FPCC_TO_REG))]
++  "TARGET_HARD_FLOAT"
++  "fmov.s\t%0, fsr"
++  [(set_attr "length" "4")
++   (set_attr "type" "fmvcpu")])
++
++(define_insn "reg_to_cc"
++  [(set (cc0)
++      (unspec:SI [(match_operand:SI 0 "register_operand" "r")]
++                 UNSPEC_REG_TO_CC))]
++  "TARGET_HARD_FLOAT"
++  "musfr\t%0"
++  [(set_attr "length" "2")
++   (set_attr "type" "alu")
++   (set_attr "cc" "from_fpcc")])
++
++(define_insn "stm_fp"
++  [(unspec [(match_operand 0 "register_operand" "r")
++            (match_operand 1 "const_int_operand" "")
++            (match_operand 2 "const_int_operand" "")]
++         UNSPEC_STMFP)]
++  "TARGET_HARD_FLOAT"
++  {
++    int cop_reglist = INTVAL(operands[1]);
++
++    if (INTVAL(operands[2]) != 0)
++      return "stcm.w\tcp0, --%0, %C1";
++    else
++      return "stcm.w\tcp0, %0, %C1";
++
++    if ( cop_reglist & ~0xff ){
++      operands[1] = GEN_INT(cop_reglist & ~0xff);
++      if (INTVAL(operands[2]) != 0)
++         return "stcm.d\tcp0, --%0, %D1";
++      else
++         return "stcm.d\tcp0, %0, %D1";
++    }
++  }
++  [(set_attr "type" "fstm")
++   (set_attr "length" "4")
++   (set_attr "cc" "none")])
+diff -Nur gcc-4.1.2/gcc/config/avr32/lib1funcs.S gcc-4.1.2-owrt/gcc/config/avr32/lib1funcs.S
+--- gcc-4.1.2/gcc/config/avr32/lib1funcs.S     1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/lib1funcs.S        2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,1678 @@
++/*#define __IEEE_LARGE_FLOATS__*/
++
++/* Adjust the unpacked double number if it is a subnormal number.
++   The exponent and mantissa pair are stored
++   in [mant_hi,mant_lo] and [exp]. A register with the correct sign bit in
++   the MSB is passed in [sign]. Needs two scratch
++   registers [scratch1] and [scratch2]. An adjusted and packed double float
++   is present in [mant_hi,mant_lo] after macro has executed */
++.macro        adjust_subnormal_df     exp, mant_lo, mant_hi, sign, scratch1, scratch2 
++        /* We have an exponent which is <=0 indicating a subnormal number
++           As it should be stored as if the exponent was 1 (although the
++           exponent field is all zeros to indicate a subnormal number)
++           we have to shift down the mantissa to its correct position. */
++        neg     \exp
++        sub     \exp,-1                   /* amount to shift down */
++        cp.w    \exp,54
++        brlo    50f                   /* if more than 53 shift steps, the
++                                           entire mantissa will disappear
++                                           without any rounding to occur */
++      mov     \mant_hi, 0
++      mov     \mant_lo, 0
++      rjmp    52f
++50:   
++        sub     \exp,-10                /* do the shift to position the
++                                           mantissa at the same time
++                                           note! this does not include the
++                                           final 1 step shift to add the sign */
++
++        /* when shifting, save all shifted out bits in [scratch2]. we may need to
++           look at them to make correct rounding. */
++
++        rsub    \scratch1,\exp,32       /* get inverted shift count */
++        cp.w    \exp,32                 /* handle shifts >= 32 separately */
++        brhs    51f
++
++        /* small (<32) shift amount, both words are part of the shift */
++        lsl     \scratch2,\mant_lo,\scratch1               /* save bits to shift out from lsw*/
++        lsl     \scratch1,\mant_hi,\scratch1               /* get bits from msw destined for lsw*/
++        lsr     \mant_lo,\mant_lo,\exp                           /* shift down lsw */
++        lsr     \mant_hi,\mant_hi,\exp                           /* shift down msw */
++        or      \mant_hi,\scratch1                         /* add bits from msw with prepared lsw */
++        rjmp    50f
++
++        /* large (>=32) shift amount, only lsw will have bits left after shift.
++           note that shift operations will use ((shift count) mod 32) so
++           we do not need to subtract 32 from shift count. */
++51:
++        lsl     \scratch2,\mant_hi,\scratch1               /* save bits to shift out from msw */
++        or      \scratch2,\mant_lo                         /* also save all bits from lsw */
++        mov     \mant_lo,\mant_hi                          /* msw -> lsw (i.e. "shift 32 first") */
++        mov     \mant_hi,0                                 /* clear msw */
++        lsr     \mant_lo,\mant_lo,\exp                     /* make rest of shift inside lsw */
++
++50:
++        /* result is almost ready to return, except that least significant bit
++           and the part we already shifted out may cause the result to be
++           rounded */
++        bld     \mant_lo,0                   /* get bit to be shifted out */
++        brcc    51f                        /* if bit was 0, no rounding */
++
++        /* msb of part to remove is 1, so rounding depends on rest of bits */
++        tst     \scratch2,\scratch2                   /* get shifted out tail */
++        brne    50f     /* if rest > 0, do round */
++        bld     \mant_lo,1                   /* we have to look at lsb in result */
++        brcc    51f   /* if lsb is 0, don't round */
++
++50:
++        /* subnormal result requires rounding
++           rounding may cause subnormal to become smallest normal number
++           luckily, smallest normal number has exactly the representation
++           we got by rippling a one bit up from mantissa into exponent field. */
++        sub     \mant_lo,-1
++        subcc   \mant_hi,-1
++
++51:
++        /* shift and return packed double with correct sign */
++      rol     \sign
++        ror     \mant_hi
++        ror     \mant_lo      
++52:   
++.endm
++
++
++/* Adjust subnormal single float number with exponent [exp]
++   and mantissa [mant] and round.    */
++.macro        adjust_subnormal_sf     sf, exp, mant, sign, scratch
++              /* subnormal number */
++        rsub    \exp,\exp, 1          /* shift amount */
++        cp.w    \exp, 25
++      movhs   \mant, 0                
++        brhs    90f                   /* Return zero */
++      rsub    \scratch, \exp, 32
++      lsl     \scratch, \mant,\scratch/* Check if there are any bits set
++                                         in the bits discarded in the mantissa */
++      srne    \scratch                /* If so set the lsb of the shifted mantissa */ 
++        lsr     \mant,\mant,\exp      /* Shift the mantissa */
++      or      \mant, \scratch         /* Round lsb if any bits were shifted out  */
++      /* Rounding :   For explaination, see round_sf. */
++      mov     \scratch, 0x7f          /* Set rounding constant */
++      bld     \mant, 8                
++      subeq   \scratch, -1            /* For odd numbers use rounding constant 0x80 */
++      add     \mant, \scratch         /* Add rounding constant to mantissa */
++      /* We can't overflow because mantissa is at least shifted one position
++         to the right so the implicit bit is zero. We can however get the implicit
++         bit set after rounding which means that we have the lowest normal number
++         but this is ok since this bit has the same position as the LSB of the
++         exponent */
++      lsr     \sf, \mant, 7
++      /* Rotate in sign */
++      lsl     \sign, 1
++      ror     \sf
++90:   
++.endm
++
++
++/* Round the unpacked df number with exponent [exp] and
++   mantissa [mant_hi, mant_lo]. Uses scratch register
++   [scratch] */
++.macro        round_df        exp, mant_lo, mant_hi, scratch
++        mov     \scratch, 0x3ff               /* Rounding constant */
++        bld     \mant_lo,11           /* Check if lsb in the final result is  
++                                         set */
++      subeq   \scratch, -1            /* Adjust rounding constant to 0x400
++                                         if rounding 0.5 upwards */   
++      add     \mant_lo, \scratch      /* Round */
++        acr   \mant_hi                /* If overflowing we know that
++                                         we have all zeros in the bits not
++                                         scaled out so we can leave them
++                                         but we must increase the exponent with
++                                         two since we had an implicit bit
++                                         which is lost + the extra overflow bit */
++      subcs   \exp, -2                /* Update exponent */
++.endm         
++
++/* Round single float number stored in [mant] and [exp] */
++.macro        round_sf        exp, mant, scratch
++      /* Round:       
++              For 0.5 we round to nearest even integer
++              for all other cases we round to nearest integer.
++              This means that if the digit left of the "point" (.)
++              is 1 we can add 0x80 to the mantissa since the
++              corner case 0x180 will round up to 0x200. If the
++              digit left of the "point" is 0 we will have to
++              add 0x7f since this will give 0xff and hence a
++              truncation/rounding downwards for the corner
++              case when the 9 lowest bits are 0x080 */
++      mov     \scratch, 0x7f  /* Set rounding constant */
++      /* Check if the mantissa is even or odd */
++      bld     \mant, 8
++      subeq   \scratch, -1    /* Rounding constant should be 0x80 */
++      add     \mant, \scratch
++      subcs   \exp, -2        /* Adjust exponent if we overflowed */          
++.endm
++
++/* Scale mantissa [mant_hi, mant_lo] with amount [shift_count].
++   Uses scratch registers [scratch1] and [scratch2] */
++.macro        scale_df        shift_count, mant_lo, mant_hi, scratch1, scratch2       
++        /* Scale [mant_hi, mant_lo] with shift_amount.
++         Must not forget the sticky bits we intend to shift out. */
++
++        rsub    \scratch1,\shift_count,32/* get (32 - shift count)
++                                           (if shift count > 32 we get a
++                                           negative value, but that will
++                                           work as well in the code below.) */
++
++        cp.w    \shift_count,32          /* handle shifts >= 32 separately */
++        brhs    70f
++
++        /* small (<32) shift amount, both words are part of the shift
++           first remember whether part that is lost contains any 1 bits ... */
++        lsl     \scratch2,\mant_lo,\scratch1  /*shift away bits that are part of
++                                              final mantissa. only part that goes
++                                              to scratch2 are bits that will be lost */
++
++        /* ... and now to the actual shift */
++        lsl     \scratch1,\mant_hi,\scratch1  /* get bits from msw destined for lsw*/
++        lsr     \mant_lo,\mant_lo,\shift_count   /* shift down lsw of mantissa */
++        lsr     \mant_hi,\mant_hi,\shift_count   /* shift down msw of mantissa */
++        or      \mant_lo,\scratch1               /* combine these bits with prepared lsw*/
++        rjmp    71f
++
++        /* large (>=32) shift amount, only lsw will have bits left after shift.
++           note that shift operations will use ((shift count) mod 32) so
++           we do not need to subtract 32 from shift count. */
++70:
++        /* first remember whether part that is lost contains any 1 bits ... */
++        lsl     \scratch2,\mant_hi,\scratch1   /* save all lost bits from msw */
++        or      \scratch2,\mant_lo             /* also save lost bits (all) from lsw
++                                                  now scratch2<>0 if we lose any bits */
++
++        /* ... and now to the actual shift */
++        mov     \mant_lo,\mant_hi             /* msw -> lsw (i.e. "shift 32 first")*/
++        mov     \mant_hi,0                    /* clear msw */
++        lsr     \mant_lo,\mant_lo,\shift_count /* make rest of shift inside lsw*/
++
++71:
++        cp.w    \scratch2,0                    /* if any '1' bit in part we lost ...*/
++        breq    70f
++
++        sbr     \mant_lo,0                    /* ... we need to set sticky bit*/
++70:           
++.endm
++              
++/* Unpack exponent and mantissa from the double number
++   stored in [df_hi,df_lo]. The exponent is stored in [exp]
++   while the mantissa is stored in [df_hi,df_lo]. */
++      
++.macro        unpack_df               exp, df_lo, df_hi
++      lsr     \exp, \df_hi,21               /* Extract exponent */
++        lsl     \df_hi,10                     /* Get mantissa */
++        or      \df_hi,\df_hi,\df_lo>>21
++        lsl     \df_lo,11
++
++        neg     \exp                        /* Fix implicit bit */
++        bst     \df_hi,31
++        subeq   \exp,1
++      neg     \exp                          /* negate back exponent */
++      .endm
++      
++/* Unpack exponent and mantissa from the single float number
++   stored in [sf]. The exponent is stored in [exp]
++   while the mantissa is stored in [sf]. */   
++.macro        unpack_sf               exp, sf
++      lsr     \exp, \sf, 24
++      brne    80f
++              /* Fix subnormal number */
++        lsl     \sf,7
++        clz     \exp,\sf
++        lsl     \sf,\sf,\exp
++        rsub  \exp,\exp,1
++      rjmp    81f
++80:   
++        lsl     \sf,7
++      sbr     \sf, 31 /*Implicit bit*/
++81:   
++.endm
++
++
++
++/* Pack a single float number stored in [mant] and [exp]
++   into a single float number in [sf]  */
++.macro        pack_sf sf, exp, mant
++        bld     \mant,31                  /* implicit bit to z */
++        subne   \exp,1                   /* if subnormal (implicit bit 0)
++                                          adjust exponent to storage format */
++      
++      lsr     \sf, \mant, 7
++      bfins   \sf, \exp, 24, 8
++.endm 
++
++/* Pack exponent [exp] and mantissa [mant_hi, mant_lo]
++   into [df_hi, df_lo].  [df_hi] is shifted
++   one bit up so the sign bit can be shifted into it */
++      
++.macro        pack_df         exp, mant_lo, mant_hi, df_lo, df_hi
++        bld     \mant_hi,31                  /* implicit bit to z */
++        subne   \exp,1                   /* if subnormal (implicit bit 0)
++                                          adjust exponent to storage format */
++
++        lsr     \mant_lo,11                  /* shift back lsw */
++        or      \df_lo,\mant_lo,\mant_hi<<21          /* combine with low bits from msw */
++        lsl     \mant_hi,1                   /* get rid of implicit bit */
++        lsr     \mant_hi,11                  /* shift back msw except for one step*/
++        or      \df_hi,\mant_hi,\exp<<21          /* combine msw with exponent */
++.endm
++
++/* Normalize single float number stored in [mant] and [exp]
++   using scratch register [scratch] */
++.macro        normalize_sf    exp, mant, scratch
++      /* Adjust exponent and mantissa */
++      clz     \scratch, \mant
++      sub     \exp, \scratch
++      lsl     \mant, \mant, \scratch
++.endm
++
++/* Normalize the exponent and mantissa pair stored
++   in [mant_hi,mant_lo] and [exp]. Needs two scratch
++   registers [scratch1] and [scratch2]. */
++.macro        normalize_df            exp, mant_lo, mant_hi, scratch1, scratch2
++        clz     \scratch1,\mant_hi     /* Check if we have zeros in high bits */
++        breq    80f                     /* No need for scaling if no zeros in high bits */
++        cp.w    \scratch1,32           /* Check for all zeros */
++        breq    81f           
++
++        /* shift amount is smaller than 32, and involves both msw and lsw*/
++        rsub    \scratch2,\scratch1,32  /* shift mantissa */
++        lsl     \mant_hi,\mant_hi,\scratch1
++        lsr     \scratch2,\mant_lo,\scratch2
++        or      \mant_hi,\scratch2
++        lsl     \mant_lo,\mant_lo,\scratch1
++        sub     \exp,\scratch1          /* adjust exponent */
++      rjmp    80f                     /* Finished */  
++81:
++        /* shift amount is greater than 32 */
++        clz     \scratch1,\mant_lo      /* shift mantissa */
++        sub     \scratch1,-32
++        mov     \mant_hi,\mant_lo
++        lsl     \mant_hi,\mant_hi,\scratch1
++        mov     \mant_lo,0
++        sub     \exp,\scratch1          /* adjust exponent */
++80:   
++.endm
++      
++
++#ifdef L_avr32_f64_mul
++      .align  2
++      .global __avr32_f64_mul
++      .type  __avr32_f64_mul,@function
++
++__avr32_f64_mul:
++      pushm   r0-r3,r4-r7,lr
++      
++        /* Unpack */
++      eor     r12, r11, r9            /* Sign op1 ^ Sign op2 is MSB of r12*/
++        lsl     r11,1                   /* Unpack op1 */
++        lsl     r9,1                    /* Unpack op2 */
++
++        /* Sort operands op1 >= op2 */
++        lddpc   r5, .Linf
++        cp.w    r10,r8
++        cpc     r11,r9
++        brhs    0f
++
++        mov     r7,r11                  /* swap operands if op2 was larger */
++        mov     r6,r10
++        mov     r11,r9
++        mov     r10,r8
++        mov     r9,r7
++        mov     r8,r6
++
++0:
++      /* Check against infinity */
++        cp.w    r11,r5
++        brlo    1f
++      /* infinity or nan */
++        /* we have to check low word as well as nan mantissa may be 0 in msw*/
++        cpc     r10
++        /* we know that op1 is inf or nan. if z != 1 then we have nan.
++            in this case, also return nan. */
++        breq    0f
++      /* Return NaN */
++      mov     r11, -1
++      rjmp    __dfmul_return_op1      
++0:    
++
++        /* op1 is infinity. op2 is smaller or same so it cannot be nan.
++           it can be infinity or a (sub-)normal number.
++           we should return op1 (infinity) except when op2 is zero when
++           result should be nan. */
++        or      r5,r9,r8
++        brne    __dfmul_return_op1       /* op2 is not zero. return op1.*/
++      /* Return NaN */
++      mov     r11, -1
++      rjmp    __dfmul_return_op1      
++      
++1:    
++        /* no operand is inf/nan, and operands have been arranged in order
++           with op1 >= op2, implying that if we have a zero, it is found in
++           op2. in this case, result should be zero (with sign from both ops). */
++
++        or      r5,r9,r8                /* check the smaller value for zero */
++        brne    0f
++      mov     r10, 0
++      mov     r11, 0
++      rjmp    __dfmul_return_op1                      /* Early exit */
++0:            
++
++        /* we have two "normal" (can be subnormal) nonzero numbers in r11:r10
++           and r9:r8. sign of result is already calculated in r12.
++           perform a normal multiplication. */
++
++        /* Unpack and normalize*/
++      unpack_df       r7 /*exp*/, r10, r11 /* mantissa */
++      normalize_df    r7 /*exp*/, r10, r11 /* mantissa */, r4, r5 /* scratch */
++      
++
++        /* Unpack and normalize*/
++      unpack_df       r6 /*exp*/, r8, r9 /* mantissa */
++      normalize_df    r6 /*exp*/, r8, r9 /* mantissa */, r4, r5 /* scratch */
++
++        /* Multiply */
++
++        mulu.d  r0,r10,r8
++        add     lr,r7,r6                   /* calculate new exponent after mul */
++        mulu.d  r2,r11,r8
++        sub     lr,(1023-1)             /* remove exponent bias as we have
++                                           included bias from both op1 and op2
++                                           sub one less, or in other words
++                                           add one to exponent. see below why. */
++        mulu.d  r6,r11,r9
++        add     r2,r1
++        mulu.d  r4,r10,r9
++
++
++        adc     r6,r6,r3
++        acr     r7
++
++        add     r4,r2
++        adc     r6,r6,r5
++        acr     r7
++
++        // r7:r6 is now in range [0x4000...0000 - 0xffff...fffe]
++        // remaining bits in r0 and r4 are of no interest, except that we have
++        // to add a sticky bit to r10 in case we had a 1 bit in r4 or r0.
++
++        or      r4,r0
++      movne   r0, 1                   /* If we have bits in r4 or r0 */
++        or      r6,r0                   /*   set lsb of result to 1 */
++
++
++        // if msb is set, it was because multiplication gave an "overflow"
++        // of one bit so exponent should be incremented.
++        // we already did that above so we are done.
++        // if msb is *not* set it will be normalized and exponent will be
++        // decremented (which will compensate the one we added above).
++
++      normalize_df    lr /*exp*/, r6, r7 /* mantissa */, r8, r9 /* scratch */
++
++      /* Check if a subnormal result was created */
++      cp.w    lr, 0
++      brgt    0f
++      
++      adjust_subnormal_df     lr, r6, r7, r12, r8, r9                 
++      mov     r10, r6
++      mov     r11, r7
++      popm    r0-r3,r4-r7, pc
++0:
++      
++        /* Round result */
++        round_df      lr /*exp*/, r6, r7 /* Mantissa */, r4 /*scratch*/
++        cp.w    lr,0x7ff
++        brlt    0f
++      /*Return infinity */
++      lddpc   r11, .Linf
++      mov     r10, 0
++      rjmp    __dfmul_return_op1
++      
++0:
++
++      /* Pack */
++      pack_df lr /*exp*/, r6, r7 /* mantissa */, r10, r11 /* Output df number*/
++__dfmul_return_op1:   
++        lsl     r12,1                /* shift in sign bit */
++        ror     r11
++      
++      popm    r0-r3,r4-r7, pc
++      
++#endif
++              
++
++#ifdef        L_avr32_f64_addsub      
++      .align  2
++      .global __avr32_f64_sub
++      .type  __avr32_f64_sub,@function
++
++__avr32_f64_sub:
++      pushm   r4-r7,lr        
++
++        eor     r12,r11,r9               // compare signs of operands
++        bld     r12,31
++        brcc    __dfsub                 // same sign => subtract
++
++        eorh    r9,0x8000
++        rjmp    __dfadd               // different signs => op1 + (-op2)
++__dfsub:
++
++        lsl     r11,1                   // unpack op1 msw and get sign in c
++        or      r4,r11,r10              // check if all bits zero
++        brne    1f
++
++        // op1 is zero, negate op2 and handle as add
++        eorh    r9,0x8000
++        // op1 is +/-0, and is unpacked with sign in c. add to op2.
++        // also used by sub, but op2 has been negated in this case
++        ror     r12                     // save sign of op1 in msb of r12
++        lsl     r9,1                    // unpack msw and get sign of op2
++        or      r4,r9,r8                // check all bits in op2
++        breq    0f
++
++        // if op2 != 0, then return op2 unchanged.
++        ror     r9                      // pack op2 msw again with sign from c
++        mov     r11,r9
++        mov     r10,r8
++        popm    r4-r7,pc
++
++0:
++        // both op1 and op2 zero, but sign unknown. result should and signs.
++        ror     r9                      // pack op2 msw again with sign from c
++        lsl     r12,1                   // get back sign of op1 into c ...
++        ror     r11                     // and back in original op1
++        and     r11,r9                  // and sign bits. as op1 is zero, the
++                                        // only bit which can be 1 is sign bit
++      popm    r4-r7,pc
++
++1:
++        ror     r12                     // save op1 sign in msb of r12
++
++        lsl     r9,1                    // unpack op2 msw
++        or      r4,r8,r9
++        brne    0f
++                                         // op2 is zero, return op1
++                                        // whatever it is. the only case
++                                        // requiring special handling is if
++                                        // op1 is zero, but that was handled
++                                        // above.
++      lsl     r12, 1
++      ror     r11
++      popm    r4-r7,pc
++      
++0:    
++        // make sure that op1 >= op2, flip sign if we swap ops
++        cp.w    r10,r8
++        cpc     r11,r9
++        brhs    0f
++
++        com     r12                     // sign of op1 and result in lsb(r12)
++        mov     r7,r11                  // swap operands if op2 was larger
++        mov     r6,r10
++        mov     r11,r9
++        mov     r10,r8
++        mov     r9,r7
++        mov     r8,r6
++
++0:
++        // check if op1 is nan or inf.
++        lddpc   r5,.Linf
++        cp.w    r11,r5
++        brlo    1f
++      /* Op 1 is nan or inf */
++        // we have to check low word as well as nan mantissa may be 0 in msw
++        cpc     r10
++        // we know that op1 is inf or nan. if z != 1 then we have nan.
++        // if we have nan, return nan.
++        breq  0f
++      mov     r11, -1
++      rjmp    __dfsub_return_op1                      
++0:
++
++        // op1 is infinity. check if op2 is nan, infinty or a normal number.
++        cp.w    r9,r5
++      movhs   r11, -1     // op2 is a normal number. return op1.
++
++        // op2 can be infinity (of the same sign as op1) or nan.
++        // in both cases we should return nan.
++        rjmp    __dfsub_return_op1
++1:    
++        // if op1 is not inf or nan, then op2 cannot be since op1 >= op2
++
++        // now prepare the operands by expanding them and shifting op2
++        // to the correct position for the subtract. note! if op2 is
++        // insignificant compared to op1, the function will take care of
++        // this and return op1 directly to the application.
++      
++      /* Unpack operands */
++      unpack_df       r7 /* exp op1*/, r10, r11 /* Mantissa op1 */    
++      unpack_df       r6 /* exp op2*/, r8, r9 /* Mantissa op2 */      
++
++      /* Get shift amount required for aligning op1 and op2 */
++      rsub    r6, r7
++      breq    __perform_dfsub /* No shift needed */
++
++      cp.w    r6, 63
++      brhs    __dfsub_pack_result     /* Op 2 insignificant compared to op1 */
++
++      /* Shift mantissa of op2 so that op1 and op2 are aligned */
++      scale_df        r6 /* shift_count*/, r8, r9 /* Mantissa */, r4, r5 /*Scratch*/
++      
++__perform_dfsub:                      
++        sub     r10,r8                  /* subtract mantissa of op2 from op1 */
++        sbc     r11,r11,r9
++        or      r4,r11,r10              /* check if result is all zeroes */
++      brne    0f
++      popm    r4-r7,pc                /* Early return */
++0:    
++      
++      normalize_df    r7 /*exp*/, r10, r11 /* mantissa */, r8, r9 /* scratch */
++
++      /* Check if a subnormal result was created */
++      cp.w    r7, 0
++      brgt    0f
++      
++      adjust_subnormal_df     r7 /*exp*/, r10, r11 /* Mantissa */, r12 /*sign*/, r8, r9 /*scratch*/                   
++      popm    r4-r7,pc
++0:
++      
++        /* Round result */
++        round_df      r7 /*exp*/, r10, r11 /* Mantissa */, r9 /*scratch*/
++        cp.w    r7,0x7ff
++        brlt    __dfsub_pack_result
++      /*Return infinity */
++      lddpc   r11, .Linf
++      mov     r10, 0
++      rjmp    __dfsub_return_op1
++      
++__dfsub_pack_result:
++      /* Pack */
++      pack_df r7 /*exp*/, r10, r11 /* mantissa */, r10, r11 /* Output df number*/
++
++__dfsub_return_op1:
++      lsl     r12,1
++      ror     r11
++      popm    r4-r7,pc
++      
++      .align  2
++      .global __avr32_f64_add
++      .type  __avr32_f64_add,@function
++__avr32_f64_add:      
++      pushm   r4-r7,lr
++        eor     r12,r11,r9               // compare signs of operands
++        lsl     r12,1
++        brcc    __dfadd                 // same sign => add
++
++        eorh    r9,0x8000
++        rjmp    __dfsub               // different signs => op1 - (-op2)
++__dfadd:
++
++        lsl     r11,1                   // unpack op1 msw and get sign in c
++        or      r4,r11,r10              // check if all bits zero
++        brne    1f
++
++        // op1 is +/-0, and is unpacked with sign in c. add to op2.
++        // also used by sub, but op2 has been negated in this case
++        ror     r12                     // save sign of op1 in msb of r12
++        lsl     r9,1                    // unpack msw and get sign of op2
++        or      r4,r9,r8                // check all bits in op2
++        breq    0f
++
++        // if op2 != 0, then return op2 unchanged.
++        ror     r9                      // pack op2 msw again with sign from c
++        mov     r11,r9
++        mov     r10,r8
++        popm    r4-r7,pc
++
++0:
++        // both op1 and op2 zero, but sign unknown. result should and signs.
++        ror     r9                      // pack op2 msw again with sign from c
++        lsl     r12,1                   // get back sign of op1 into c ...
++        ror     r11                     // and back in original op1
++        and     r11,r9                  // and sign bits. as op1 is zero, the
++                                        // only bit which can be 1 is sign bit
++      popm    r4-r7,pc
++1:    
++        ror     r12                     // save op1 sign in msb of r12
++
++        lsl     r9,1                    // unpack op2 msw
++        or      r4,r8,r9
++        brne    0f
++                                         // op2 is zero, return op1
++                                        // whatever it is. the only case
++                                        // requiring special handling is if
++                                        // op1 is zero, but that was handled
++                                        // above.
++      lsl     r12, 1
++      ror     r11
++      popm    r4-r7,pc
++0:    
++        // make sure that exp[op1] >= exp[op2]
++        cp.w    r11,r9
++        brhs    0f
++
++        mov     r7,r11                  // swap operands if op2 was larger
++        mov     r6,r10
++        mov     r11,r9
++        mov     r10,r8
++        mov     r9,r7
++        mov     r8,r6
++
++0:
++        // check if op1 is nan or inf.
++        lddpc   r5,.Linf
++        cp.w    r11,r5
++        brlo    1f
++      /* Op 1 is nan or inf */
++        // we have to check low word as well as nan mantissa may be 0 in msw
++        cpc     r10
++        // we know that op1 is inf or nan. if z != 1 then we have nan.
++        // if we have nan, return nan.
++        breq  0f
++      mov     r11, -1
++      rjmp    __dfadd_return_op1                      
++0:
++
++        // op1 is infinity. check if op2 is nan, infinty or a normal number.
++        cp.w    r9,r5
++        // Op2 is NaN of Inf. Return op2 but with sign of result.
++        // If Op2 is NaN, sign doesn't matter but no need to separate NaN
++      movhs   r11, r9
++      movhs   r10, r8
++
++        // op2 can be infinity (of the same sign as op1) or nan.
++        // in both cases we should return nan.
++        rjmp    __dfadd_return_op1
++1:    
++        // if op1 is not inf or nan, then op2 cannot be since exp[op1] >=
++        // exp[op2]
++
++        // now prepare the operands by expanding them and shifting op2
++        // to the correct position for the add. note! if op2 is
++        // insignificant compared to op1, the function will take care of
++        // this and return op1 directly to the application.
++
++      /* Unpack operands */
++      unpack_df       r7 /* exp op1*/, r10, r11 /* Mantissa op1 */    
++      unpack_df       r6 /* exp op2*/, r8, r9 /* Mantissa op2 */      
++
++      /* Get shift amount required for aligning op1 and op2 */
++      rsub    r6, r7
++      breq    __perform_dfadd /* No shift needed */
++
++      cp.w    r6, 63
++      brhs    __dfadd_pack_result     /* Op 2 insignificant compared to op1 */
++
++      /* Shift mantissa of op2 so that op1 and op2 are aligned */
++      scale_df        r6 /* shift_count*/, r8, r9 /* Mantissa */, r4, r5 /*Scratch*/
++
++__perform_dfadd:      
++        add     r10,r8                  // add mantissas
++        adc     r11,r11,r9
++      brcc    0f              
++        ror     r11                     // overflow => shift down mantissa
++        ror     r10
++        brcc    1f                 // sticky bit shifted out?
++        sbr     r10,0                   // if so, merge it into result again
++1:
++        sub     r7,-1                   // increase exponent with 1
++0:
++      normalize_df    r7 /*exp*/, r10, r11 /* mantissa */, r8, r9 /* scratch */
++
++      /* Check if a subnormal result was created */
++      cp.w    r7, 0
++      brgt    0f
++      
++      adjust_subnormal_df     r7 /*exp*/, r10, r11 /* Mantissa */, r12 /*sign*/, r8, r9 /*scratch*/                   
++      popm    r4-r7,pc
++0:
++      
++        /* Round result */
++        round_df      r7 /*exp*/, r10, r11 /* Mantissa */, r9 /*scratch*/
++        cp.w    r7,0x7ff
++        brlt    __dfadd_pack_result
++      /*Return infinity */
++      lddpc   r11, .Linf
++      mov     r10, 0
++      rjmp    __dfadd_return_op1
++      
++__dfadd_pack_result:
++      /* Pack */
++      pack_df r7 /*exp*/, r10, r11 /* mantissa */, r10, r11 /* Output df number*/
++
++__dfadd_return_op1:
++      lsl     r12,1
++      ror     r11
++      popm    r4-r7,pc
++#endif
++
++#ifdef L_avr32_f64_to_u32
++      /* This goes into L_fixdfsi */
++#endif
++      
++
++#ifdef L_avr32_f64_to_s32
++      .global __avr32_f64_to_u32
++      .type  __avr32_f64_to_u32,@function
++__avr32_f64_to_u32:
++      cp.w    r11, 0
++      retmi   0       /* Negative returns 0 */
++#ifdef __LARGE_FLOATS__
++        lsl     r12,r11,1
++        lsr     r12,21                  /* extract exponent*/
++        sub     r12,1023                /* convert to unbiased exponent.*/
++        retlo   0                       /* too small exponent implies zero. */
++        cp.w    r12,32
++        brcc    0f    
++      rjmp    1f
++#endif
++
++      /* Fallthrough to df to signed si conversion */ 
++      .global __avr32_f64_to_s32
++      .type  __avr32_f64_to_s32,@function
++__avr32_f64_to_s32:
++        lsl     r12,r11,1
++        lsr     r12,21                  /* extract exponent*/
++        sub     r12,1023                /* convert to unbiased exponent.*/
++        retlo   0                       /* too small exponent implies zero. */
++
++#ifdef __LARGE_FLOATS__
++        cp.w    r12,31
++        brcc    0f
++#endif
++1:    
++        rsub    r12,r12,31              /* shift count = 31 - exponent */
++        mov     r9,r11                  /* save sign for later...*/
++        lsl     r11,11                  /* remove exponent and sign*/
++        sbr     r11,31                  /* add implicit bit*/
++        or      r11,r11,r10>>21         /* get rest of bits from lsw of double */
++        lsr     r11,r11,r12             /* shift down mantissa to final place */
++        lsl     r9,1                    /* sign -> carry */
++        retcc   r11                     /* if positive, we are done */
++        neg     r11                     /* if negative float, negate result */
++        ret     r11
++
++#ifdef __LARGE_FLOATS__
++0:    
++        mov     r12,-1                  /* r11 = 0xffffffff */
++        lsr     r12,1                   /* r11 = 0x7fffffff */
++        lsl     r11,1                   /* sign -> carry */
++        acr     r12                     /* r11 = signed ? 0x80000000
++                                                        : 0x7fffffff */
++        ret     r12
++#endif
++#endif        /* L_fixdfsi*/
++
++#ifdef L_avr32_f64_to_u64
++      /* Actual function is in L_fixdfdi */
++#endif
++      
++#ifdef L_avr32_f64_to_s64
++      .global __avr32_f64_to_u64
++      .type  __avr32_f64_to_u64,@function
++__avr32_f64_to_u64:
++      cp.w    r11,0
++      /* Negative numbers return zero */
++      movmi   r10, 0
++      movmi   r11, 0
++      retmi   r11
++#ifdef __LARGE_FLOATS__
++        lsl     r9,r11,1
++        lsr     r9,21                   /* get exponent*/
++        sub     r9,1023                 /* convert to correct range*/
++      /* Return zero if exponent to small */
++      movlo   r10, 0
++      movlo   r11, 0
++      retlo   r11
++        cp.w    r9,64
++        mov     r8,r11                  /* save sign for later...*/
++        brcs    1f
++      rjmp    2f                      /* Number to large */
++
++#endif
++
++      
++
++      /* Fallthrough */
++      .global __avr32_f64_to_s64
++      .type  __avr32_f64_to_s64,@function
++__avr32_f64_to_s64:
++        lsl     r9,r11,1
++        lsr     r9,21                   /* get exponent*/
++        sub     r9,1023                 /* convert to correct range*/
++      /* Return zero if exponent to small */
++      movlo   r10, 0
++      movlo   r11, 0
++      retlo   r11
++
++#ifdef __LARGE_FLOATS__
++        cp.w    r9,63
++        mov     r8,r11                  /* save sign for later...*/
++        brcc    2f
++#else
++        mov     r8,r11                  /* save sign for later...*/
++#endif
++1:    
++        lsl     r11,11                  /* remove exponent */
++        sbr     r11,31                  /* add implicit bit*/
++        or      r11,r11,r10>>21         /* get rest of bits from lsw of double*/
++        lsl     r10,11                  /* align lsw correctly as well */
++        rsub    r9,r9,63                /* shift count = 63 - exponent */
++        breq    1f
++
++        cp.w    r9,32                   /* is shift count more than one reg? */
++        brhs    0f
++
++        mov     r12,r11                 /* save msw */
++        lsr     r10,r10,r9              /* small shift count, shift down lsw */
++        lsr     r11,r11,r9              /* small shift count, shift down msw */
++        rsub    r9,r9,32                /* get 32-size of shifted out tail */
++        lsl     r12,r12,r9              /* align part to move from msw to lsw */
++        or      r10,r12                 /* combine to get new lsw */
++        rjmp    1f
++
++0:
++        lsr     r10,r11,r9              /* large shift count,only lsw get bits
++                                           note that shift count is modulo 32*/
++        mov     r11,0                   /* msw will be 0 */
++
++1:
++        lsl     r8,1                    /* sign -> carry */
++        retcc   r11                     /* if positive, we are done */
++
++        neg     r11                     /* if negative float, negate result */
++        neg     r10
++        scr     r11
++        ret     r11
++
++
++#ifdef __LARGE_FLOATS__
++2:
++        mov     r11,-1                  /* r11 = 0xffffffff */
++        lsr     r11,1                   /* r11 = 0x7fffffff */
++        lsl     r8,1                    /* sign -> carry */
++        acr     r11                     /* r11 = signed ? 0x80000000 */
++                                        /*              : 0x7fffffff */
++        lsl     r10,r11,31              /* extend last bit of msw*/
++        asr     r10,31
++        ret     r11
++#endif
++#endif
++
++#ifdef L_avr32_u32_to_f64
++      /* Code located in L_floatsidf */
++#endif
++      
++#ifdef L_avr32_s32_to_f64
++      .global __avr32_u32_to_f64
++      .type  __avr32_u32_to_f64,@function
++__avr32_u32_to_f64:
++      sub     r11, r12, 0 /* Move to r11 and force Z flag to be updated */
++      mov     r12, 0      /* always positive */
++      rjmp    0f          /* Jump to common code for floatsidf */
++      
++      .global __avr32_s32_to_f64
++      .type  __avr32_s32_to_f64,@function
++__avr32_s32_to_f64:
++      mov     r11, r12        /* Keep original value in r12 for sign */
++      abs     r11             /* Absolute value if r12 */
++0:    
++        mov     r10,0           /* let remaining bits be zero */
++        reteq   r11           /* zero long will return zero float */
++
++      pushm   lr
++        mov     r9,31+1023              /* set exponent */
++              
++      normalize_df    r9 /*exp*/, r10, r11 /* mantissa */, r8, lr /* scratch */
++
++      /* Check if a subnormal result was created */
++      cp.w    r9, 0
++      brgt    0f
++      
++      adjust_subnormal_df     r9 /* exp */, r10, r11 /* Mantissa */, r12 /*sign*/, r8, lr /* scratch */
++      popm    pc
++0:
++      
++        /* Round result */
++        round_df      r9 /*exp*/, r10, r11 /* Mantissa */, r8 /*scratch*/
++        cp.w    r9,0x7ff
++        brlt    0f
++      /*Return infinity */
++      lddpc   r11, .Linf
++      mov     r10, 0
++      rjmp    __floatsidf_return_op1
++      
++0:
++
++      /* Pack */
++      pack_df r9 /*exp*/, r10, r11 /* mantissa */, r10, r11 /* Output df number*/
++__floatsidf_return_op1:       
++        lsl     r12,1                /* shift in sign bit */
++        ror     r11
++
++      popm    pc
++#endif
++
++
++#ifdef L_avr32_f32_cmp_eq
++      .global __avr32_f32_cmp_eq
++      .type  __avr32_f32_cmp_eq,@function
++__avr32_f32_cmp_eq:   
++      cp.w    r12, r11
++      brne    0f      /* If not equal check for +/-0 */
++      
++      /* Check for NaN or Inf */
++        lddpc   r11,.Linf_sf
++      lsl     r12, 1
++      cp.w    r12, r11
++      srls    r12     /* 0 if NaN, 1 otherwise */
++      ret     r12     
++0:    
++      /* Or together the two values and shift out the sign bit.
++         If the result is zero, then the two values are both zero. */
++      or      r12, r11
++      lsl     r12, 1
++      sreq    r12
++      ret     r12
++#endif
++      
++#if defined(L_avr32_f32_cmp_ge) || defined(L_avr32_f32_cmp_lt)
++#ifdef L_avr32_f32_cmp_ge
++      .global __avr32_f32_cmp_ge
++      .type  __avr32_f32_cmp_ge,@function
++__avr32_f32_cmp_ge:
++#endif        
++#ifdef L_avr32_f32_cmp_lt
++      .global __avr32_f32_cmp_lt
++      .type  __avr32_f32_cmp_lt,@function
++__avr32_f32_cmp_lt:
++#endif        
++      lsl     r10, r12, 1     /* Remove sign bits */
++      lsl     r9, r11, 1
++      lddpc   r8, .Linf_sf
++      cp.w    r10, r8
++      rethi   0               /* Op0 is NaN */                
++      cp.w    r9, r8
++      rethi   0               /* Op1 is Nan */
++
++      eor     r8, r11, r12
++      bld     r12, 31
++#ifdef L_avr32_f32_cmp_ge
++      srcc    r8      /* Set result to true if op0 is positive*/
++#endif
++#ifdef L_avr32_f32_cmp_lt
++      srcs    r8      /* Set result to true if op0 is negative*/
++#endif
++      retmi   r8      /* Return if signs are different */
++      brcs    0f      /* Both signs negative? */
++
++      /* Both signs positive */
++      cp.w    r12, r11
++#ifdef L_avr32_f32_cmp_ge
++      srhs    r12
++#endif
++#ifdef L_avr32_f32_cmp_lt
++      srlo    r12
++#endif
++      retal   r12
++0:
++      /* Both signs negative */
++      cp.w    r11, r12
++#ifdef L_avr32_f32_cmp_ge
++      srhs    r12
++#endif
++#ifdef L_avr32_f32_cmp_lt
++      srlo    r12
++#endif
++      retal   r12
++#endif
++      
++
++#ifdef L_avr32_f64_cmp_eq
++      .global __avr32_f64_cmp_eq
++      .type  __avr32_f64_cmp_eq,@function
++__avr32_f64_cmp_eq:   
++        cp.w    r10,r8
++        cpc     r11,r9
++        brne    0f    /* Both args could be zero with different sign bits */
++
++        /* check for NaN */
++        lsl     r11,1
++        lddpc   r12,.Linf
++        cp.w    r10,0
++        cpc     r11,r12                 /* check if nan or inf */
++      srls    r12                     /* If Arg is NaN return 0 else 1*/
++      ret     r12                     /* Return  */
++
++0:
++        lsl     r11,1                   /* get rid of sign bits */
++        lsl     r9,1
++        or      r11,r10                 /* Check if all bits are zero */
++        or      r11,r9
++        or      r11,r8
++      sreq    r12                     /* If all zeros the arguments are equal
++                                         so return 1 else return 0 */
++      ret     r12
++#endif
++
++
++#if   defined(L_avr32_f64_cmp_ge) || defined(L_avr32_f64_cmp_lt)
++
++#ifdef L_avr32_f64_cmp_ge
++      .global __avr32_f64_cmp_ge
++      .type  __avr32_f64_cmp_ge,@function
++__avr32_f64_cmp_ge:
++#endif        
++#ifdef L_avr32_f64_cmp_lt
++      .global __avr32_f64_cmp_lt
++      .type  __avr32_f64_cmp_lt,@function
++__avr32_f64_cmp_lt:
++#endif        
++
++        /* compare magnitude of op1 and op2 */
++      pushm   lr
++      
++        lsl     r11,1                   /* Remove sign bit of op1 */
++      srcs    lr                      /* Sign op1 to lsb of lr*/
++        lsl     r9,1                    /* Remove sign bit of op2 */
++      rol     lr                      /* Sign op2 to lsb of lr, sign bit op1 bit 1 of lr*/
++
++      /* Check for Nan */
++        lddpc   r12,.Linf
++        cp.w    r10,0
++        cpc     r11,r12
++      movhi   r12, 0  /* Return false for NaN */
++        brhi    0f    /* We have NaN */
++        cp.w    r8,0
++        cpc     r9,r12
++      movhi   r12, 0  /* Return false for NaN */
++        brhi    0f    /* We have NaN */
++
++        cp.w    lr,3                   /* both operands negative ?*/  
++        breq    1f
++
++        cp.w    lr,1                   /* both operands positive? */
++        brlo    2f
++
++        /* Different signs. If sign of op1 is negative the difference
++         between op1 and op2 will always be negative, and if op1 is
++         positive the difference will always be positive */           
++#ifdef L_avr32_f64_cmp_ge
++      sreq    r12
++#endif
++#ifdef L_avr32_f64_cmp_lt
++      srne    r12
++#endif
++      popm    pc
++
++
++2:
++        /* Both operands positive. Just compute the difference */
++        cp.w    r10,r8
++        cpc     r11,r9
++#ifdef L_avr32_f64_cmp_ge
++      srhs    r12
++#endif
++#ifdef L_avr32_f64_cmp_lt
++      srlo    r12
++#endif
++      popm    pc
++              
++1:
++        /* Both operands negative. Compute the difference with operands switched */
++        cp     r8,r10
++        cpc    r9,r11
++#ifdef L_avr32_f64_cmp_ge
++      srhs    r12
++#endif
++#ifdef L_avr32_f64_cmp_lt
++      srlo    r12
++#endif
++0:    
++      popm    pc
++#endif
++
++      
++
++#ifdef L_avr32_f64_div
++      .global __avr32_f64_div
++      .type  __avr32_f64_div,@function
++__avr32_f64_div:
++      stm     --sp, r2-r7,lr
++      eor     r12, r11, r9            /* Sign(op1) ^ Sign(op2) to msb of r12*/
++        lsl     r11,1                   /* unpack op1*/
++        lddpc   lr,.Linf
++        lsl     r9,1                    /* unpack op2*/
++
++      cp.w    r11,lr
++        brhs  0f                      /* op1 is NaN or infinity */
++        cp.w    r9,lr
++        brhs    1f                    /* op2 is NaN or infinity */
++        or      r5,r9,r8
++        breq    2f                    /* op2 is zero */
++        or      r5,r11,r10
++        breq    __dfdiv_return_op1    /* op1 is zero return zero*/
++
++      /* Unpack and normalize */
++      /* op1 */
++      unpack_df       r7 /*exp*/, r10, r11 /*df number*/
++      normalize_df    r7 /*exp*/, r10, r11 /*Mantissa*/, r4, r5 /*scratch*/
++
++      /* op1 */
++      unpack_df       r6 /*exp*/, r8, r9 /*df number*/
++      normalize_df    r6 /*exp*/, r8, r9 /*Mantissa*/, r4, r5 /*scratch*/
++
++      /* Compute new exponent */
++        sub     r7,r6
++        sub     r7,-1023
++
++      /* Do fixed point division of mantissas*/
++        mov     r6,55
++        lsr     r11,1
++        ror     r10
++        lsr     r9,1
++        ror     r8
++
++3:
++      /* Check if dividend is higher or same than divisor */
++        sub     r2,r10,r8
++        sbc     r3,r11,r9
++      /* If so move the difference back into the dividend */
++      movhs   r10, r2
++      movhs   r11, r3
++      /* Update the Quotient */
++        rol     r4
++        rol     r5
++        eorl    r4,1
++
++      /* Shift the dividend */
++        lsl     r10,1
++        rol     r11
++
++        sub     r6,1
++      brne    3b
++
++      /* Check if we have a remainder which will the propagate into
++         the last bit */
++
++        or      r11,r11,r10
++        neg     r11
++        rol     r4
++        rol     r5
++
++      /* Adjust mantissa into correct alignment */
++        lsl     r11, r5,(64-56)
++        or      r11,r11,r4>>(32-64+56)
++        lsl     r10,r4, (64-56)
++
++      /* Normalize result */
++      normalize_df    r7 /*exp*/, r10, r11 /* mantissa */, r8, r9 /* scratch */
++
++      /* Check if a subnormal result was created */
++      cp.w    r7, 0
++      brgt    3f
++      
++      adjust_subnormal_df     r7 /*exp*/, r10, r11 /* Mantissa */, r12 /*sign*/, r8, r9 /*scratch*/                   
++      ldm     sp++, r2-r7,pc
++3:
++      
++        /* Round result */
++        round_df      r7 /*exp*/, r10, r11 /* Mantissa */, r9 /*scratch*/
++        cp.w    r7,0x7ff
++        brlt    __dfdiv_pack_result
++      /*Return infinity */
++      lddpc   r11, .Linf
++      mov     r10, 0
++      rjmp    __dfdiv_return_op1
++      
++__dfdiv_pack_result:
++      /* Pack */
++      pack_df r7 /*exp*/, r10, r11 /* mantissa */, r10, r11 /* Output df number*/
++
++__dfdiv_return_op1:
++      lsl     r12,1
++      ror     r11
++      ldm     sp++, r2-r7,pc
++
++0:
++      /* Op1 is NaN or Inf */
++        cpc     r10
++      /* If op1 is a NaN the we should return a NaN */
++        brne    __dfdiv_return_op1
++
++      /* Op1 is infinity, check op2*/
++        cp.w    r9,lr
++        brlo    __dfdiv_return_op1    /* Op2 is a normal number return inf */
++      /* Other combinations:   return NaN */
++      mov     r11, -1
++      ldm     sp++, r2-r7,pc
++
++1:    
++      /* Op2 is NaN or Inf */
++        cpc     r8
++      /* If inf return zero else return NaN*/
++      mov     r10, 0
++      moveq   r11, 0
++      movne   r11, -1
++      ldm     sp++, r2-r7,pc
++
++2:
++      /* Op2 is zero */
++        or      r6,r11,r10              /* 0.0/0.0 yields NaN */
++      mov     r10, 0
++      moveq   r11, -1                 /* Return NaN */
++      movne   r11, lr                 /* Return inf */
++        rjmp    __dfdiv_return_op1
++
++#endif        
++              
++
++#ifdef L_avr32_f32_div
++      .global __avr32_f32_div
++      .type  __avr32_f32_div,@function
++__avr32_f32_div:
++      eor     r8, r11, r12            /* MSB(r8) = Sign(op1) ^ Sign(op2) */
++      /* Unpack */
++        lsl     r12,1
++      reteq   0                       /* Return zero if op1 is zero */
++        lddpc   r9, .Linf_sf
++        lsl     r11,1
++
++      /* Check op1 for NaN or Inf */
++        cp      r12,r9        
++        brhs    2f
++
++      /* Check op2 for NaN or Inf */
++        cp      r11,r9
++        brhs    3f
++      /* Check op2 for zero */
++        tst     r11,r11
++        breq    4f
++
++      /* If op1 is zero return zero */
++      tst     r12, r12
++      reteq   0
++      
++      /* Unpack op1*/ 
++      unpack_sf       r9 /*exp*/, r12 /*sf*/
++
++      /* Unpack op2*/ 
++      unpack_sf       r10 /*exp*/, r11 /*sf*/
++
++      /* Calculate new exponent */
++      stm     --sp,r7,lr
++      sub     r9, r10
++        sub     r9,-127
++
++      /* Divide */
++        mov     r7,26
++
++        lsr     r12,1                   /* Make room for one more bit in mantissas */
++        lsr     r11,1
++
++0:
++        sub     r10,r12,r11
++      movcc   r12, r10                /* update dividend if divisor smaller */
++        rol     lr                      /* shift result into lr */
++        eorl    lr,1                    /* flip bit. */
++        lsl     r12,1                 /* Shift dividend */
++        sub     r7,1
++        brne    0b
++
++        /* round and scale*/
++        neg   r12                     /* c = 1 iff r12 != 0 */
++        rol     lr
++        lsl     r10,lr,(32-27)                /* Adjust mantissa */
++      ldm     sp++, r7, lr
++      
++                              
++      normalize_sf    r9 /*exp*/, r10 /*mant*/, r11 /*scratch*/       
++
++      /* Check for subnormal result */
++      cp.w    r9, 0
++      brgt    0f
++
++      /* Adjust a subnormal result */
++      adjust_subnormal_sf     r12 /*sf*/, r9 /*exp*/, r10 /*mant*/, r8 /*sign*/,r11 /*scratch*/
++      ret     r12
++0:
++      round_sf        r9 /*exp*/, r10 /*mant*/, r11 /*scratch*/       
++      pack_sf         r12 /*sf*/, r9 /*exp*/, r10 /*mant*/
++__divsf_return_op1:   
++      lsl     r8, 1
++      ror     r12
++      ret     r12
++
++2:
++      /* Op1 is NaN or inf */
++      retne   -1      /* Return NaN if op1 is NaN */
++      /* Op1 is inf check op2 */
++      cp      r11, r9
++      brlo    __divsf_return_op1 /* inf/number gives inf */
++      ret     -1      /* The rest gives NaN*/
++3:    
++      /* Op1 is NaN or inf */
++      reteq   0       /* Return zero if number/inf*/
++      ret     -1      /* Return NaN*/
++4:
++      /* Op2 is zero ? */
++      tst     r12,r12
++      reteq   -1      /* 0.0/0.0 is NaN */
++      lddpc   r12, .Linf_sf
++      rjmp    __divsf_return_op1
++                              
++#endif
++
++#ifdef L_avr32_f32_mul
++      .global __avr32_f32_mul
++      .type  __avr32_f32_mul,@function
++__avr32_f32_mul:
++      eor     r8, r11, r12            /* MSB(r8) = Sign(op1) ^ Sign(op2) */
++        lsl     r12,1                   /* unpack op1 */
++        lsl     r11,1                   /* unpack op2 */
++
++        /* arrange operands so that that op1 >= op2 */
++        sub     r9,r12,r11
++        brcc    0f
++
++        sub     r12,r9                  /* swap operands if op2 was larger */
++        add     r11,r9
++
++0:
++        lddpc   r9,.Linf_sf
++        cp      r12,r9
++        brhs    2f
++
++      /* Check op2 for zero */
++        tst     r11,r11
++      reteq   0       /* Return zero */
++
++      /* Unpack op1 */        
++      unpack_sf       r9 /*exp*/, r12 /*sf*/
++      /* Unpack op2 */        
++      unpack_sf       r10 /*exp*/, r11 /*sf*/
++
++      /* Calculate new exponent */
++        add     r9,r10
++
++      /* Do the multiplication */
++        mulu.d  r10,r12,r11
++
++        sub     r9,(127-1)              /* remove extra exponent bias */
++
++      /* Check if we have any bits in r10 which
++         means a rounding bit should be inserted in LSB of result */
++        tst     r10,r10
++        srne    r10
++        or      r12,r11,r10
++
++      /* Normalize */
++      normalize_sf    r9 /*exp*/, r12 /*mant*/, r11 /*scratch*/       
++
++      /* Check for subnormal result */
++      cp.w    r9, 0
++      brgt    0f
++
++      /* Adjust a subnormal result */
++      adjust_subnormal_sf     r12/*sf*/, r9 /*exp*/, r12 /*mant*/, r8 /*sign*/, r11 /*scratch */
++      ret     r12
++0:
++      round_sf        r9 /*exp*/, r12 /*mant*/, r11 /*scratch*/       
++      cp.w            r9, 0xff
++      brlo            1f
++        lddpc         r12,.Linf_sf    
++      rjmp            __mulsf_return_op1
++1:                    
++      pack_sf         r12 /*sf*/, r9 /*exp*/, r12 /*mant*/
++__mulsf_return_op1:   
++      lsl     r8, 1
++      ror     r12
++      ret     r12
++
++2:
++      /* Op1 is inf or NaN */
++        retne   -1             /* Op1 is NaN return NaN */
++
++      /* Op1 is inf and op2 is smaller so it is either infinity
++         or a subnormal number */
++        cp      r11,0
++        brne    __mulsf_return_op1  /* op2 is not zero. return op1.*/
++        ret     -1                /* inf * 0  return NaN */           
++#endif        
++
++      
++#ifdef L_avr32_s32_to_f32
++      .global __avr32_s32_to_f32
++      .type  __avr32_s32_to_f32,@function
++__avr32_s32_to_f32:
++      cp      r12, 0
++      reteq   r12     /* If zero then return zero float */
++      mov     r11, r12 /* Keep the sign */
++      abs     r12     /* Compute the absolute value */
++      mov     r10, 31 + 127   /* Set the correct exponent */
++      
++      /* Normalize */
++      normalize_sf    r10 /*exp*/, r12 /*mant*/, r9 /*scratch*/       
++
++      /* Check for subnormal result */
++      cp.w    r10, 0
++      brgt    0f
++
++      /* Adjust a subnormal result */
++      adjust_subnormal_sf     r12/*sf*/, r10 /*exp*/, r12 /*mant*/, r11/*sign*/, r9 /*scratch*/
++      ret     r12
++0:
++      round_sf        r10 /*exp*/, r12 /*mant*/, r9 /*scratch*/       
++      pack_sf         r12 /*sf*/, r10 /*exp*/, r12 /*mant*/
++__floatsisf_return_op1:       
++      lsl     r11, 1
++      ror     r12
++      ret     r12             
++#endif
++
++#ifdef L_avr32_u32_to_f32
++      .global __avr32_u32_to_f32
++      .type  __avr32_u32_to_f32,@function
++__avr32_u32_to_f32:
++      cp      r12, 0
++      reteq   r12     /* If zero then return zero float */
++      mov     r10, 31 + 127   /* Set the correct exponent */
++      
++      /* Normalize */
++      normalize_sf    r10 /*exp*/, r12 /*mant*/, r9 /*scratch*/       
++
++      /* Check for subnormal result */
++      cp.w    r10, 0
++      brgt    0f
++
++      /* Adjust a subnormal result */
++      mov     r8, 0
++      adjust_subnormal_sf     r12/*sf*/,r10 /*exp*/, r12 /*mant*/,r8/*sign*/, r9 /*scratch*/
++      ret     r12
++0:
++      round_sf        r10 /*exp*/, r12 /*mant*/, r9 /*scratch*/       
++      pack_sf         r12 /*sf*/, r10 /*exp*/, r12 /*mant*/
++__floatunsisf_return_op1:     
++      lsr     r12,1   /* Sign bit is 0 for unsigned int */
++      ret     r12             
++#endif
++      
++
++#ifdef L_avr32_f32_to_s32
++      .global __avr32_f32_to_s32
++      .type  __avr32_f32_to_s32,@function
++__avr32_f32_to_s32:
++        lsr     r11,r12,23              /* Extract exponent */
++        castu.b r11
++        sub     r11,127                 /* Fix bias */
++        retlo   0                     /* Negative exponent yields zero integer */
++
++#ifdef __IEEE_LARGE_FLOATS__
++        cp      r11,31
++        brcc    0f
++#endif
++      /* Shift mantissa into correct position */
++        rsub    r11,r11,31    /* Shift amount */
++        lsl     r10,r12,8       /* Get mantissa */
++        sbr     r10,31          /* Add implicit bit */
++        lsr     r10,r10,r11     /* Perform shift */
++        lsl     r12,1           /* Check sign */
++        retcc   r10             /* if positive, we are done */
++        neg     r10             /* if negative float, negate result */
++        ret     r10
++
++#ifdef __IEEE_LARGE_FLOATS__
++0:    
++        mov     r11,-1
++        lsr     r11,1
++        lsl     r12,1
++        acr     r11
++
++        ret     r11
++#endif
++#endif        
++      
++#ifdef L_avr32_f32_to_u32
++      .global __avr32_f32_to_u32
++      .type  __avr32_f32_to_u32,@function
++__avr32_f32_to_u32:
++      cp      r12,0
++      retmi   0                       /* Negative numbers gives 0 */
++        bfextu  r11, r12, 23, 8               /* Extract exponent */
++        sub     r11,127                 /* Fix bias */
++        retlo   0                     /* Negative exponent yields zero integer */
++
++#ifdef __IEEE_LARGE_FLOATS__
++        cp      r11,32
++        brcc    0f
++#endif
++      /* Shift mantissa into correct position */
++        rsub    r11,r11,31    /* Shift amount */
++        lsl     r12,8           /* Get mantissa */
++        sbr     r12,31          /* Add implicit bit */
++        lsr     r12,r12,r11     /* Perform shift */
++        ret   r12
++
++#ifdef __IEEE_LARGE_FLOATS__
++0:    
++        mov     r11,-1
++        lsr     r11,1
++        lsl     r12,1
++        acr     r11
++
++        ret     r11
++#endif
++#endif        
++
++#ifdef L_avr32_f32_to_f64
++      .global __avr32_f32_to_f64
++      .type  __avr32_f32_to_f64,@function
++
++__avr32_f32_to_f64:
++        lsl     r11,r12,1               /* Remove sign bit, keep original value in r12*/
++      moveq   r10, 0
++      reteq   r11                     /* Return zero if input is zero */
++
++      bfextu  r9,r11,24,8              /* Get exponent */
++        cp.w    r9,0xff                 /* check for NaN or inf */
++        breq    0f
++
++        lsl     r11,7                   /* Convert sf mantissa to df format */
++        mov     r10,0
++
++      /* Check if implicit bit should be set */
++        cp.w    r9, 0
++        subeq   r9,-1                    /* Adjust exponent if it was 0 */
++      srne    r8
++      or      r11, r11, r8 << 31      /* Set implicit bit if needed */
++        sub     r9,(127-0x3ff)          /* Convert exponent to df format exponent */
++
++      pushm   lr
++      normalize_df    r9 /*exp*/, r10, r11 /*mantissa*/, r8, lr /*scratch*/
++      popm    lr
++      pack_df         r9 /*exp*/, r10, r11 /*mantissa*/, r10, r11 /*df*/
++
++__extendsfdf_return_op1:      
++      /* Rotate in sign bit */
++      lsl     r12, 1
++      ror     r11
++      ret     r11
++                      
++0:
++      /* Inf or NaN*/
++      lddpc   r10, .Linf
++        lsl     r11,8                   /* check mantissa */
++      movne   r11, -1                 /* Return NaN */
++      moveq   r11, r10                /* Return inf */
++      rjmp    __extendsfdf_return_op1
++#endif                        
++
++
++#ifdef L_avr32_f64_to_f32
++      .global __avr32_f64_to_f32
++      .type  __avr32_f64_to_f32,@function
++
++__avr32_f64_to_f32:
++      /* Unpack */
++        lsl     r9,r11,1                /* Unpack exponent */
++        lsr     r9,21
++
++      reteq   0                       /* If exponent is 0 the number is so small
++                                         that the conversion to single float gives
++                                         zero */
++
++        lsl     r8,r11,10                  /* Adjust mantissa */
++        or      r12,r8,r10>>22
++
++        lsl     r10,10                  /* Check if there are any remaining bits
++                                         in the low part of the mantissa.*/
++        neg     r10
++        rol     r12                     /* If there were remaining bits then set lsb
++                                         of mantissa to 1 */
++
++        cp      r9,0x7ff
++        breq    2f                    /* Check for NaN or inf */
++
++        sub     r9,(0x3ff-127)          /* Adjust bias of exponent */
++        sbr     r12,31                  /* set the implicit bit.*/
++
++      cp.w    r9, 0                   /* Check for subnormal number */
++      brgt    0f
++
++      /* Adjust a subnormal result */
++      adjust_subnormal_sf     r12/*sf*/,r9 /*exp*/, r12 /*mant*/, r11/*sign*/, r10 /*scratch*/
++      ret     r12
++0:
++      round_sf        r9 /*exp*/, r12 /*mant*/, r10 /*scratch*/       
++      pack_sf         r12 /*sf*/, r9 /*exp*/, r12 /*mant*/
++__truncdfsf_return_op1:       
++      /* Rotate in sign bit */
++      lsl     r11, 1
++      ror     r12
++      ret     r12             
++      
++      
++2:
++      /* NaN or inf */
++        cbr     r12,31                  /* clear implicit bit */
++        retne   -1                      /* Return NaN if mantissa not zero */
++      lddpc   r12,.Linf_sf
++      ret     r12                     /* Return inf */
++#endif
++
++      
++      .align 2
++.Linf:        
++      .long   0xffe00000
++
++      .align 2
++.Linf_sf:     
++      .long   0xff000000
++
+diff -Nur gcc-4.1.2/gcc/config/avr32/lib2funcs.S gcc-4.1.2-owrt/gcc/config/avr32/lib2funcs.S
+--- gcc-4.1.2/gcc/config/avr32/lib2funcs.S     1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/lib2funcs.S        2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,21 @@
++      .align  4
++      .global __nonlocal_goto
++      .type  __nonlocal_goto,@function
++
++/* __nonlocal_goto:   This function handles nonlocal_goto's in gcc.
++
++      parameter 0 (r12) = New Frame Pointer
++      parameter 1 (r11) = Address to goto
++      parameter 2 (r10) = New Stack Pointer
++
++      This function invalidates the return stack, since it returns from a
++      function without using a return instruction.
++*/
++__nonlocal_goto:
++      mov     r7, r12
++      mov     sp, r10
++      frs                     # Flush return stack
++      mov     pc, r11
++
++
++              
+diff -Nur gcc-4.1.2/gcc/config/avr32/linux-elf.h gcc-4.1.2-owrt/gcc/config/avr32/linux-elf.h
+--- gcc-4.1.2/gcc/config/avr32/linux-elf.h     1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/linux-elf.h        2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,154 @@
++/*
++   Linux/Elf specific definitions.
++   Copyright 2003-2006 Atmel Corporation.
++
++   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++   and HÃ¥vard Skinnemoen, Atmel Norway, <hskinnemoen@atmel.com>
++
++   This file is part of GCC.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
++
++
++
++/* elfos.h should have already been included.  Now just override
++   any conflicting definitions and add any extras.  */
++
++/* Run-time Target Specification.  */
++#undef  TARGET_VERSION
++#define TARGET_VERSION  fputs (" (AVR32 GNU/Linux with ELF)", stderr);
++
++/* Do not assume anything about header files.  */
++#define NO_IMPLICIT_EXTERN_C
++
++/* The GNU C++ standard library requires that these macros be defined.  */
++#undef CPLUSPLUS_CPP_SPEC
++#define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)"
++
++/* Now we define the strings used to build the spec file.  */
++#undef  LIB_SPEC
++#define LIB_SPEC \
++  "%{pthread:-lpthread} \
++   %{shared:-lc} \
++   %{!shared:%{profile:-lc_p}%{!profile:-lc}}"
++
++/* Provide a STARTFILE_SPEC appropriate for GNU/Linux.  Here we add
++   the GNU/Linux magical crtbegin.o file (see crtstuff.c) which
++   provides part of the support for getting C++ file-scope static
++   object constructed before entering `main'.  */
++
++#undef  STARTFILE_SPEC
++#define STARTFILE_SPEC \
++  "%{!shared: \
++     %{pg:gcrt1.o%s} %{!pg:%{p:gcrt1.o%s} \
++                     %{!p:%{profile:gcrt1.o%s} \
++                       %{!profile:crt1.o%s}}}} \
++   crti.o%s %{!shared:crtbegin.o%s} %{shared:crtbeginS.o%s}"
++
++/* Provide a ENDFILE_SPEC appropriate for GNU/Linux.  Here we tack on
++   the GNU/Linux magical crtend.o file (see crtstuff.c) which
++   provides part of the support for getting C++ file-scope static
++   object constructed before entering `main', followed by a normal
++   GNU/Linux "finalizer" file, `crtn.o'.  */
++
++#undef  ENDFILE_SPEC
++#define ENDFILE_SPEC \
++  "%{!shared:crtend.o%s} %{shared:crtendS.o%s} crtn.o%s"
++
++#undef ASM_SPEC
++#define ASM_SPEC "%{!mno-pic:--pic} %{mrelax|O*:%{mno-relax|O0|O1: ;:--linkrelax}} %{mcpu=*:-mcpu=%*}"
++
++#undef  LINK_SPEC
++#define LINK_SPEC "%{version:-v} \
++   %{static:-Bstatic} \
++   %{shared:-shared} \
++   %{symbolic:-Bsymbolic} \
++   %{rdynamic:-export-dynamic} \
++   %{!dynamic-linker:-dynamic-linker /lib/ld-uClibc.so.0} \
++   %{mrelax|O*:%{mno-relax|O0|O1: ;:--relax}}"
++
++#define TARGET_OS_CPP_BUILTINS() LINUX_TARGET_OS_CPP_BUILTINS()
++
++/* This is how we tell the assembler that two symbols have the same value.  */
++#define ASM_OUTPUT_DEF(FILE, NAME1, NAME2) \
++  do                                     \
++    {                                    \
++      assemble_name (FILE, NAME1);       \
++      fputs (" = ", FILE);               \
++      assemble_name (FILE, NAME2);       \
++      fputc ('\n', FILE);                \
++    }                                    \
++  while (0)
++
++
++
++#undef  CC1_SPEC
++#define CC1_SPEC "%{profile:-p}"
++
++/* Target CPU builtins.  */
++#define TARGET_CPU_CPP_BUILTINS()                             \
++  do                                                          \
++    {                                                         \
++      builtin_define ("__avr32__");                           \
++      builtin_define ("__AVR32__");                           \
++      builtin_define ("__AVR32_LINUX__");                     \
++      builtin_define (avr32_part->macro);                     \
++      builtin_define (avr32_arch->macro);                     \
++      if (avr32_arch->uarch_type == UARCH_TYPE_AVR32A)                \
++      builtin_define ("__AVR32_AVR32A__");                    \
++      else                                                    \
++      builtin_define ("__AVR32_AVR32B__");                    \
++      if (TARGET_UNALIGNED_WORD)                              \
++      builtin_define ("__AVR32_HAS_UNALIGNED_WORD__");        \
++      if (TARGET_SIMD)                                                \
++      builtin_define ("__AVR32_HAS_SIMD__");                  \
++      if (TARGET_DSP)                                         \
++      builtin_define ("__AVR32_HAS_DSP__");                   \
++      if (TARGET_RMW)                                         \
++      builtin_define ("__AVR32_HAS_RMW__");                   \
++      if (TARGET_BRANCH_PRED)                                 \
++      builtin_define ("__AVR32_HAS_BRANCH_PRED__");           \
++      if (flag_pic)                                           \
++      {                                                       \
++        builtin_define ("__PIC__");                           \
++        builtin_define ("__pic__");                           \
++      }                                                       \
++    }                                                         \
++  while (0)
++
++
++
++/* Call the function profiler with a given profile label.  */
++#undef  FUNCTION_PROFILER
++#define FUNCTION_PROFILER(STREAM, LABELNO)                            \
++  do                                                                  \
++    {                                                                 \
++      fprintf (STREAM, "\tmov\tlr, lo(mcount)\n\torh\tlr, hi(mcount)\n"); \
++      fprintf (STREAM, "\ticall lr\n");                                       \
++    }                                                                 \
++  while (0)
++
++#define NO_PROFILE_COUNTERS 1
++
++/* For dynamic libraries to work */
++/* #define PLT_REG_CALL_CLOBBERED 1 */
++#define AVR32_ALWAYS_PIC 1
++
++/* uclibc does not implement sinf, cosf etc. */
++#undef TARGET_C99_FUNCTIONS
++#define TARGET_C99_FUNCTIONS 0
++
++#define LINK_GCC_C_SEQUENCE_SPEC \
++  "%{static:--start-group} %G %L %{static:--end-group}%{!static:%G}"
+diff -Nur gcc-4.1.2/gcc/config/avr32/predicates.md gcc-4.1.2-owrt/gcc/config/avr32/predicates.md
+--- gcc-4.1.2/gcc/config/avr32/predicates.md   1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/predicates.md      2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,303 @@
++;;   AVR32 predicates file.
++;;   Copyright 2003-2006 Atmel Corporation.
++;;
++;;   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++;;
++;;   This file is part of GCC.
++;;
++;;   This program is free software; you can redistribute it and/or modify
++;;   it under the terms of the GNU General Public License as published by
++;;   the Free Software Foundation; either version 2 of the License, or
++;;   (at your option) any later version.
++;;
++;;   This program is distributed in the hope that it will be useful,
++;;   but WITHOUT ANY WARRANTY; without even the implied warranty of
++;;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++;;   GNU General Public License for more details.
++;;
++;;   You should have received a copy of the GNU General Public License
++;;   along with this program; if not, write to the Free Software
++;;   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++
++
++;; True if the operand is a memory reference which contains an
++;; Address consisting of a single pointer register
++(define_predicate "avr32_indirect_register_operand"
++  (and (match_code "mem")
++       (match_test "register_operand(XEXP(op, 0), SImode)")))
++
++
++
++;; Address expression with a base pointer offset with
++;; a register displacement
++(define_predicate "avr32_indexed_memory_operand"
++  (and (match_code "mem")
++       (match_test "GET_CODE(XEXP(op, 0)) == PLUS"))
++  {
++
++   rtx op0 = XEXP(XEXP(op, 0), 0);
++   rtx op1 = XEXP(XEXP(op, 0), 1);
++
++   return ((avr32_address_register_rtx_p (op0, 0)
++            && avr32_legitimate_index_p (GET_MODE(op), op1, 0))
++         || (avr32_address_register_rtx_p (op1, 0)
++            && avr32_legitimate_index_p (GET_MODE(op), op0, 0)));
++
++ })
++
++;; Operand suitable for the ld.sb instruction
++(define_predicate "load_sb_memory_operand"
++  (ior (match_operand 0 "avr32_indirect_register_operand")
++       (match_operand 0 "avr32_indexed_memory_operand")))
++
++
++;; Operand suitable as operand to insns sign extending QI values
++(define_predicate "extendqi_operand"
++  (ior (match_operand 0 "load_sb_memory_operand")
++       (match_operand 0 "register_operand")))
++
++(define_predicate "post_inc_memory_operand"
++  (and (match_code "mem")
++       (match_test "(GET_CODE(XEXP(op, 0)) == POST_INC)
++                     && REG_P(XEXP(XEXP(op, 0), 0))")))
++
++;; Operand suitable for loading TImode values
++(define_predicate "loadti_operand"
++  (ior (ior (match_operand 0 "register_operand")
++            (match_operand 0 "avr32_indirect_register_operand"))
++       (match_operand 0 "post_inc_memory_operand")))
++
++;; Operand suitable for add instructions
++(define_predicate "avr32_add_operand"
++  (ior (match_operand 0 "register_operand")
++       (and (match_operand 0 "immediate_operand")
++            (match_test "CONST_OK_FOR_CONSTRAINT_P(INTVAL(op), 'I', \"Is21\")"))))
++
++;; Operand is a power of two immediate
++(define_predicate "power_of_two_operand"
++  (match_code "const_int")
++{
++  HOST_WIDE_INT value = INTVAL (op);
++
++  return value != 0 && (value & (value - 1)) == 0;
++})
++
++;; Operand is a multiple of 8 immediate
++(define_predicate "multiple_of_8_operand"
++  (match_code "const_int")
++{
++  HOST_WIDE_INT value = INTVAL (op);
++
++  return (value & 0x7) == 0 ;
++})
++
++;; Operand is a multiple of 16 immediate
++(define_predicate "multiple_of_16_operand"
++  (match_code "const_int")
++{
++  HOST_WIDE_INT value = INTVAL (op);
++
++  return (value & 0xf) == 0 ;
++})
++
++;; Operand is a mask used for masking away upper bits of a reg
++(define_predicate "avr32_mask_upper_bits_operand"
++  (match_code "const_int")
++{
++  HOST_WIDE_INT value = INTVAL (op) + 1;
++
++  return value != 1 && value != 0 && (value & (value - 1)) == 0;
++})
++
++
++;; Operand suitable for mul instructions
++(define_predicate "avr32_mul_operand"
++  (ior (match_operand 0 "register_operand")
++       (and (match_operand 0 "immediate_operand")
++            (match_test "CONST_OK_FOR_CONSTRAINT_P(INTVAL(op), 'K', \"Ks08\")"))))
++
++;; True for logical binary operators.
++(define_predicate "logical_binary_operator"
++  (match_code "ior,xor,and"))
++
++;; True for logical shift operators
++(define_predicate "logical_shift_operator"
++  (match_code "ashift,lshiftrt"))
++
++;; True for shift operand for logical and, or and eor insns
++(define_predicate "avr32_logical_shift_operand"
++  (and (match_code "ashift,lshiftrt")
++       (ior (and (match_test "GET_CODE(XEXP(op, 1)) == CONST_INT")
++                 (match_test "register_operand(XEXP(op, 0), GET_MODE(XEXP(op, 0)))"))
++            (and (match_test "GET_CODE(XEXP(op, 0)) == CONST_INT")
++                 (match_test "register_operand(XEXP(op, 1), GET_MODE(XEXP(op, 1)))"))))
++  {
++   return 1;
++  }
++  )
++
++
++;; Predicate for second operand to and, ior and xor insn patterns
++(define_predicate "avr32_logical_insn_operand"
++  (ior (match_operand 0 "register_operand")
++       (match_operand 0 "avr32_logical_shift_operand"))
++  {
++   return 1;
++  }
++)
++
++
++;; True for avr32 comparison operators
++(define_predicate "avr32_comparison_operator"
++  (ior (match_code "eq, ne, gt, ge, lt, le, gtu, geu, ltu, leu")
++       (and (match_code "unspec")
++            (match_test "(XINT(op, 1) == UNSPEC_COND_MI)
++                         || (XINT(op, 1) == UNSPEC_COND_PL)"))))
++
++;; True if this is a const_int with one bit set
++(define_predicate "one_bit_set_operand"
++  (match_code "const_int")
++  {
++   int i;
++   int value;
++   int ones = 0;
++
++   value = INTVAL(op);
++   for ( i = 0 ; i < 32; i++ ){
++     if ( value & ( 1 << i ) ){
++        ones++;
++      }
++   }
++
++   return ( ones == 1 );
++  })
++
++
++;; True if this is a const_int with one bit cleared
++(define_predicate "one_bit_cleared_operand"
++  (match_code "const_int")
++  {
++   int i;
++   int value;
++   int zeroes = 0;
++
++   value = INTVAL(op);
++   for ( i = 0 ; i < 32; i++ ){
++     if ( !(value & ( 1 << i )) ){
++        zeroes++;
++      }
++   }
++
++   return ( zeroes == 1 );
++  })
++
++
++;; True if this is a register or immediate operand
++(define_predicate "register_immediate_operand"
++  (ior (match_operand 0 "register_operand")
++       (match_operand 0 "immediate_operand")))
++
++
++;; True is this is an operand containing a label_ref
++(define_predicate "avr32_label_ref_operand"
++  (and (match_code "mem")
++       (match_test "avr32_find_symbol(op)
++                    && (GET_CODE(avr32_find_symbol(op)) == LABEL_REF)")))
++
++;; True is this is a valid symbol pointing to the constant pool
++(define_predicate "avr32_const_pool_operand"
++  (and (match_code "symbol_ref")
++       (match_test "CONSTANT_POOL_ADDRESS_P(op)"))
++  {
++        return (flag_pic ? (!(symbol_mentioned_p (get_pool_constant (op))
++                        || label_mentioned_p (get_pool_constant (op)))
++                       || avr32_got_mentioned_p(get_pool_constant (op)))
++                    : true);
++  }
++)
++
++;; True is this is a memory reference to the constant or mini pool
++(define_predicate "avr32_const_pool_ref_operand"
++  (ior (match_operand 0 "avr32_label_ref_operand")
++       (and (match_code "mem")
++            (match_test "avr32_const_pool_operand(XEXP(op,0), GET_MODE(XEXP(op,0)))"))))
++
++
++
++;; True is this is a k12 offseted memory operand
++(define_predicate "avr32_k12_memory_operand"
++  (and (match_code "mem")
++       (ior (match_test "REG_P(XEXP(op, 0))")
++            (match_test "GET_CODE(XEXP(op, 0)) == PLUS
++                         && REG_P(XEXP(XEXP(op, 0), 0))
++                         && (GET_CODE(XEXP(XEXP(op, 0), 1)) == CONST_INT)
++                         && (CONST_OK_FOR_CONSTRAINT_P(INTVAL(XEXP(XEXP(op, 0), 0)),
++                                'K', (mode == SImode) ? \"Ks14\" : ((mode == HImode) ? \"Ks13\" : \"Ks12\")))"))))
++
++;; True is this is a memory operand with an immediate displacement
++(define_predicate "avr32_imm_disp_memory_operand"
++  (and (match_code "mem")
++       (match_test "GET_CODE(XEXP(op, 0)) == PLUS
++                    && REG_P(XEXP(XEXP(op, 0), 0))
++                    && (GET_CODE(XEXP(XEXP(op, 0), 1)) == CONST_INT)")))
++
++;; True is this is a bswap operand
++(define_predicate "avr32_bswap_operand"
++  (ior (match_operand 0 "avr32_k12_memory_operand")
++       (match_operand 0 "register_operand")))
++
++;; True is this is a valid coprocessor insn memory operand
++(define_predicate "avr32_cop_memory_operand"
++  (and (match_operand 0 "memory_operand")
++       (not (match_test "GET_CODE(XEXP(op, 0)) == PLUS
++                         && REG_P(XEXP(XEXP(op, 0), 0))
++                         && (GET_CODE(XEXP(XEXP(op, 0), 1)) == CONST_INT)
++                         && !(CONST_OK_FOR_CONSTRAINT_P(INTVAL(XEXP(XEXP(op, 0), 0)), 'K', \"Ku10\"))"))))
++
++;; True is this is a valid source/destination operand
++;; for moving values to/from a coprocessor
++(define_predicate "avr32_cop_move_operand"
++  (ior (match_operand 0 "register_operand")
++       (match_operand 0 "avr32_cop_memory_operand")))
++
++
++;; True is this is a valid extract byte offset for use in
++;; load extracted index insns
++(define_predicate "avr32_extract_shift_operand"
++  (and (match_operand 0 "const_int_operand")
++       (match_test "(INTVAL(op) == 0) || (INTVAL(op) == 8)
++                    || (INTVAL(op) == 16) || (INTVAL(op) == 24)")))
++
++;; True is this is a floating-point register
++(define_predicate "avr32_fp_register_operand"
++  (and (match_operand 0 "register_operand")
++       (match_test "REGNO_REG_CLASS(REGNO(op)) == FP_REGS")))
++
++;; True is this is valid avr32 symbol operand
++(define_predicate "avr32_symbol_operand"
++  (ior (match_code "label_ref, symbol_ref")
++       (and (match_code "const")
++            (match_test "avr32_find_symbol(op)"))))
++
++;; True is this is valid operand for the lda.w and call pseudo insns
++(define_predicate "avr32_address_operand"
++  (and (match_code "label_ref, symbol_ref")
++       (ior (match_test "TARGET_HAS_ASM_ADDR_PSEUDOS")
++            (match_test "flag_pic")) ))
++
++;; True if this is a avr32 call operand
++(define_predicate "avr32_call_operand"
++  (ior (ior (match_operand 0 "register_operand")
++            (ior (match_operand 0 "avr32_const_pool_ref_operand")
++                 (match_operand 0 "avr32_address_operand")))
++       (match_test "SYMBOL_REF_RCALL_FUNCTION_P(op)")))
++
++;; Return true for operators performing ALU operations
++
++(define_predicate "alu_operator"
++  (match_code "ior, xor, and, plus, minus, ashift, lshiftrt, ashiftrt"))
++
++(define_predicate "avr32_add_shift_immediate_operand"
++  (and (match_operand 0 "immediate_operand")
++       (match_test "CONST_OK_FOR_CONSTRAINT_P(INTVAL(op), 'K', \"Ku02\")")))
++
+diff -Nur gcc-4.1.2/gcc/config/avr32/simd.md gcc-4.1.2-owrt/gcc/config/avr32/simd.md
+--- gcc-4.1.2/gcc/config/avr32/simd.md 1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/simd.md    2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,145 @@
++;;   AVR32 machine description file for SIMD instructions.
++;;   Copyright 2003-2006 Atmel Corporation.
++;;
++;;   Written by Ronny Pedersen, Atmel Norway, <rpedersen@atmel.com>
++;;
++;;   This file is part of GCC.
++;;
++;;   This program is free software; you can redistribute it and/or modify
++;;   it under the terms of the GNU General Public License as published by
++;;   the Free Software Foundation; either version 2 of the License, or
++;;   (at your option) any later version.
++;;
++;;   This program is distributed in the hope that it will be useful,
++;;   but WITHOUT ANY WARRANTY; without even the implied warranty of
++;;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++;;   GNU General Public License for more details.
++;;
++;;   You should have received a copy of the GNU General Public License
++;;   along with this program; if not, write to the Free Software
++;;   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++
++;; -*- Mode: Scheme -*-
++
++
++;; Vector modes
++(define_mode_macro VECM [V2HI V4QI])
++(define_mode_attr  size [(V2HI "h") (V4QI "b")])
++
++(define_insn "add<mode>3"
++  [(set (match_operand:VECM 0 "register_operand" "=r")
++      (plus:VECM (match_operand:VECM 1 "register_operand" "r")
++                   (match_operand:VECM 2 "register_operand" "r")))]
++  "TARGET_SIMD"
++  "padd.<size>\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++
++(define_insn "sub<mode>3"
++  [(set (match_operand:VECM 0 "register_operand" "=r")
++      (minus:VECM (match_operand:VECM 1 "register_operand" "r")
++                    (match_operand:VECM 2 "register_operand" "r")))]
++  "TARGET_SIMD"
++  "psub.<size>\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++
++(define_insn "abs<mode>2"
++  [(set (match_operand:VECM 0 "register_operand" "=r")
++      (abs:VECM (match_operand:VECM 1 "register_operand" "r")))]
++  "TARGET_SIMD"
++  "pabs.s<size>\t%0, %1"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++(define_insn "ashl<mode>3"
++  [(set (match_operand:VECM 0 "register_operand"           "=r")
++      (ashift:VECM (match_operand:VECM 1 "register_operand" "r")
++                     (match_operand:SI 2 "immediate_operand" "Ku04")))]
++  "TARGET_SIMD"
++  "plsl.<size>\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++(define_insn "ashr<mode>3"
++  [(set (match_operand:VECM 0 "register_operand"           "=r")
++      (ashiftrt:VECM (match_operand:VECM 1 "register_operand" "r")
++                       (match_operand:SI 2 "immediate_operand" "Ku04")))]
++  "TARGET_SIMD"
++  "pasr.<size>\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++(define_insn "lshr<mode>3"
++  [(set (match_operand:VECM 0 "register_operand"           "=r")
++      (lshiftrt:VECM (match_operand:VECM 1 "register_operand" "r")
++                       (match_operand:SI 2 "immediate_operand" "Ku04")))]
++  "TARGET_SIMD"
++  "plsr.<size>\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++(define_insn "smaxv2hi3"
++  [(set (match_operand:V2HI 0 "register_operand" "=r")
++      (smax:V2HI (match_operand:V2HI 1 "register_operand" "r")
++                        (match_operand:V2HI 2 "register_operand" "r")))]
++
++  "TARGET_SIMD"
++  "pmax.sh\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++(define_insn "sminv2hi3"
++  [(set (match_operand:V2HI 0 "register_operand" "=r")
++      (smin:V2HI (match_operand:V2HI 1 "register_operand" "r")
++                        (match_operand:V2HI 2 "register_operand" "r")))]
++
++  "TARGET_SIMD"
++  "pmin.sh\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++(define_insn "umaxv4qi3"
++  [(set (match_operand:V4QI 0 "register_operand" "=r")
++      (umax:V4QI (match_operand:V4QI 1 "register_operand" "r")
++                   (match_operand:V4QI 2 "register_operand" "r")))]
++
++  "TARGET_SIMD"
++  "pmax.ub\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++(define_insn "uminv4qi3"
++  [(set (match_operand:V4QI 0 "register_operand" "=r")
++      (umin:V4QI (match_operand:V4QI 1 "register_operand" "r")
++                   (match_operand:V4QI 2 "register_operand" "r")))]
++
++  "TARGET_SIMD"
++  "pmin.ub\t%0, %1, %2"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++
++(define_insn "addsubv2hi"
++  [(set (match_operand:V2HI 0 "register_operand" "=r")
++        (vec_concat:V2HI
++         (plus:HI (match_operand:HI 1 "register_operand" "r")
++                  (match_operand:HI 2 "register_operand" "r"))
++         (minus:HI (match_dup 1) (match_dup 2))))]
++  "TARGET_SIMD"
++  "paddsub.h\t%0, %1:b, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
++
++(define_insn "subaddv2hi"
++  [(set (match_operand:V2HI 0 "register_operand" "=r")
++        (vec_concat:V2HI
++         (minus:HI (match_operand:HI 1 "register_operand" "r")
++                  (match_operand:HI 2 "register_operand" "r"))
++         (plus:HI (match_dup 1) (match_dup 2))))]
++  "TARGET_SIMD"
++  "psubadd.h\t%0, %1:b, %2:b"
++  [(set_attr "length" "4")
++   (set_attr "type" "alu")])
+diff -Nur gcc-4.1.2/gcc/config/avr32/t-avr32 gcc-4.1.2-owrt/gcc/config/avr32/t-avr32
+--- gcc-4.1.2/gcc/config/avr32/t-avr32 1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/t-avr32    2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,63 @@
++
++MD_INCLUDES=  $(srcdir)/config/avr32/avr32.md \
++              $(srcdir)/config/avr32/fpcp.md \
++              $(srcdir)/config/avr32/simd.md \
++                $(srcdir)/config/avr32/predicates.md
++
++s-config s-conditions s-flags s-codes s-constants s-emit s-recog s-preds \
++      s-opinit s-extract s-peep s-attr s-attrtab s-output: $(MD_INCLUDES)
++
++# We want fine grained libraries, so use the new code
++# to build the floating point emulation libraries.
++FPBIT = fp-bit.c
++DPBIT = dp-bit.c
++
++LIB1ASMSRC = avr32/lib1funcs.S
++LIB1ASMFUNCS =  _avr32_f64_mul _avr32_f64_addsub  _avr32_f64_to_u32 _avr32_f64_to_s32 \
++                _avr32_f64_to_u64 _avr32_f64_to_s64 _avr32_u32_to_f64 _avr32_s32_to_f64 \
++                _avr32_f64_cmp_eq _avr32_f64_cmp_ge _avr32_f64_cmp_lt \
++                _avr32_f32_cmp_eq _avr32_f32_cmp_ge _avr32_f32_cmp_lt \
++                _avr32_f64_div _avr32_f32_div\
++                _avr32_f32_mul _avr32_s32_to_f32 _avr32_u32_to_f32 _avr32_f32_to_s32 \
++                _avr32_f32_to_u32 _avr32_f32_to_f64 _avr32_f64_to_f32
++
++LIB2FUNCS_EXTRA += $(srcdir)/config/avr32/lib2funcs.S
++
++MULTILIB_OPTIONS     = march=ap/march=uc
++MULTILIB_DIRNAMES    = ap uc
++MULTILIB_EXCEPTIONS  =
++MULTILIB_MATCHES     = march?ap=mcpu?ap7000
++MULTILIB_MATCHES     += march?ap=mcpu?ap7010
++MULTILIB_MATCHES     += march?ap=mcpu?ap7020
++MULTILIB_MATCHES     += march?uc=mcpu?uc3a0256
++MULTILIB_MATCHES     += march?uc=mcpu?uc3a0512
++MULTILIB_MATCHES     += march?uc=mcpu?uc3a1128
++MULTILIB_MATCHES     += march?uc=mcpu?uc3a1256
++MULTILIB_MATCHES     += march?uc=mcpu?uc3a1512
++MULTILIB_MATCHES     += march?ap=mpart?ap7000
++MULTILIB_MATCHES     += march?ap=mpart?ap7010
++MULTILIB_MATCHES     += march?ap=mpart?ap7020
++MULTILIB_MATCHES     += march?uc=mpart?uc3a0256
++MULTILIB_MATCHES     += march?uc=mpart?uc3a0512
++MULTILIB_MATCHES     += march?uc=mpart?uc3a1128
++MULTILIB_MATCHES     += march?uc=mpart?uc3a1256
++MULTILIB_MATCHES     += march?uc=mpart?uc3a1512
++
++EXTRA_MULTILIB_PARTS = crtbegin.o crtbeginS.o crtend.o crtendS.o crti.o crtn.o
++
++CRTSTUFF_T_CFLAGS = -mrelax
++CRTSTUFF_T_CFLAGS_S = -mrelax -fPIC
++TARGET_LIBGCC2_CFLAGS += -mrelax
++
++LIBGCC = stmp-multilib
++INSTALL_LIBGCC = install-multilib
++
++fp-bit.c: $(srcdir)/config/fp-bit.c
++      echo '#define FLOAT' > fp-bit.c
++      cat $(srcdir)/config/fp-bit.c >> fp-bit.c
++
++dp-bit.c: $(srcdir)/config/fp-bit.c
++      cat $(srcdir)/config/fp-bit.c > dp-bit.c
++
++
++
+diff -Nur gcc-4.1.2/gcc/config/avr32/t-elf gcc-4.1.2-owrt/gcc/config/avr32/t-elf
+--- gcc-4.1.2/gcc/config/avr32/t-elf   1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/t-elf      2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,16 @@
++
++# Assemble startup files.
++$(T)crti.o: $(srcdir)/config/avr32/crti.asm $(GCC_PASSES)
++      $(GCC_FOR_TARGET) $(CRTSTUFF_CFLAGS) $(CRTSTUFF_T_CFLAGS) $(INCLUDES) \
++      -c -o $(T)crti.o -x assembler-with-cpp $(srcdir)/config/avr32/crti.asm
++
++$(T)crtn.o: $(srcdir)/config/avr32/crtn.asm $(GCC_PASSES)
++      $(GCC_FOR_TARGET) $(CRTSTUFF_CFLAGS) $(CRTSTUFF_T_CFLAGS) $(INCLUDES) \
++      -c -o $(T)crtn.o -x assembler-with-cpp $(srcdir)/config/avr32/crtn.asm
++
++
++# Build the libraries for both hard and soft floating point
++EXTRA_MULTILIB_PARTS = crtbegin.o crtbeginS.o crtend.o crtendS.o crti.o crtn.o
++
++LIBGCC = stmp-multilib
++INSTALL_LIBGCC = install-multilib
+diff -Nur gcc-4.1.2/gcc/config/avr32/uclinux-elf.h gcc-4.1.2-owrt/gcc/config/avr32/uclinux-elf.h
+--- gcc-4.1.2/gcc/config/avr32/uclinux-elf.h   1970-01-01 01:00:00.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/config/avr32/uclinux-elf.h      2007-05-24 12:03:28.000000000 +0200
+@@ -0,0 +1,20 @@
++
++/* Run-time Target Specification.  */
++#undef  TARGET_VERSION
++#define TARGET_VERSION  fputs (" (AVR32 uClinux with ELF)", stderr)
++
++/* We don't want a .jcr section on uClinux. As if this makes a difference... */
++#define TARGET_USE_JCR_SECTION 0
++
++/* Here we go. Drop the crtbegin/crtend stuff completely. */
++#undef STARTFILE_SPEC
++#define STARTFILE_SPEC                                                        \
++  "%{!shared: %{pg:gcrt1.o%s} %{!pg:%{p:gcrt1.o%s}"                   \
++  " %{!p:%{profile:gcrt1.o%s}"                                                \
++  " %{!profile:crt1.o%s}}}} crti.o%s"
++
++#undef ENDFILE_SPEC
++#define ENDFILE_SPEC "crtn.o%s"
++
++#undef TARGET_DEFAULT
++#define TARGET_DEFAULT (AVR32_FLAG_NO_INIT_GOT)
+diff -Nur gcc-4.1.2/gcc/config/host-linux.c gcc-4.1.2-owrt/gcc/config/host-linux.c
+--- gcc-4.1.2/gcc/config/host-linux.c  2005-08-01 19:43:33.000000000 +0200
++++ gcc-4.1.2-owrt/gcc/config/host-linux.c     2007-05-24 12:03:28.000000000 +0200
+@@ -26,6 +26,9 @@
+ #include "hosthooks.h"
+ #include "hosthooks-def.h"
++#ifndef SSIZE_MAX
++#define SSIZE_MAX LONG_MAX
++#endif
+ /* Linux has a feature called exec-shield-randomize that perturbs the
+    address of non-fixed mapped segments by a (relatively) small amount.
+diff -Nur gcc-4.1.2/gcc/config.gcc gcc-4.1.2-owrt/gcc/config.gcc
+--- gcc-4.1.2/gcc/config.gcc   2006-10-16 01:12:23.000000000 +0200
++++ gcc-4.1.2-owrt/gcc/config.gcc      2007-05-24 12:03:28.000000000 +0200
+@@ -751,6 +751,24 @@
+       tm_file="avr/avr.h dbxelf.h"
+       use_fixproto=yes
+       ;;
++avr32*-*-linux*)
++    tm_file="dbxelf.h elfos.h linux.h avr32/linux-elf.h avr32/avr32.h "
++    tmake_file="t-linux avr32/t-avr32 avr32/t-elf"
++      extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
++      extra_modes=avr32/avr32-modes.def
++      gnu_ld=yes
++      ;;
++avr32*-*-uclinux*)
++      tm_file="dbxelf.h elfos.h linux.h avr32/linux-elf.h avr32/uclinux-elf.h avr32/avr32.h"
++      tmake_file="t-linux avr32/t-avr32 avr32/t-elf"
++      extra_modes=avr32/avr32-modes.def
++      gnu_ld=yes
++      ;;
++avr32-*-*)
++    tm_file="dbxelf.h elfos.h avr32/avr32.h avr32/avr32-elf.h"
++    tmake_file="avr32/t-avr32 avr32/t-elf"
++      extra_modes=avr32/avr32-modes.def
++      ;;
+ bfin*-elf*)
+       tm_file="${tm_file} dbxelf.h elfos.h bfin/elf.h"
+         tmake_file=bfin/t-bfin-elf
+@@ -1614,6 +1632,9 @@
+ pdp11-*-*)
+       use_fixproto=yes
+       ;;
++avr-*-*)
++      use_fixproto=yes
++      ;;
+ # port not yet contributed
+ #powerpc-*-openbsd*)
+ #     tmake_file="${tmake_file} rs6000/t-fprules "
+@@ -2575,6 +2596,21 @@
+               fi
+               ;;
++      avr32*-*-*)
++              supported_defaults="cpu"
++
++              case "$with_cpu" in
++              "" \
++              | morgan | ap7000 )
++                      # OK
++                      ;;
++              *)
++                      echo "Unknown arch used in --with-arch=$with_arch" 1>&2
++                      exit 1
++                      ;;
++              esac
++                ;;
++
+       fr*-*-*linux*)
+               supported_defaults=cpu
+               case "$with_cpu" in
+diff -Nur gcc-4.1.2/gcc/doc/extend.texi gcc-4.1.2-owrt/gcc/doc/extend.texi
+--- gcc-4.1.2/gcc/doc/extend.texi      2007-01-28 20:26:29.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/doc/extend.texi 2007-05-24 12:03:28.000000000 +0200
+@@ -1887,7 +1887,7 @@
+ @item interrupt
+ @cindex interrupt handler functions
+-Use this attribute on the ARM, AVR, C4x, CRX, M32C, M32R/D, MS1, and Xstormy16
++Use this attribute on the ARM, AVR, AVR32, C4x, CRX, M32C, M32R/D, MS1, and Xstormy16
+ ports to indicate that the specified function is an interrupt handler.
+ The compiler will generate function entry and exit sequences suitable
+ for use in an interrupt handler when this attribute is present.
+@@ -1906,6 +1906,15 @@
+ Permissible values for this parameter are: IRQ, FIQ, SWI, ABORT and UNDEF@.
++Note, for the AVR32, you can specify which banking scheme is used for
++the interrupt mode this interrupt handler is used in like this:
++
++@smallexample
++void f () __attribute__ ((interrupt ("FULL")));
++@end smallexample
++
++Permissible values for this parameter are: FULL, HALF, NONE and UNDEF.
++
+ @item interrupt_handler
+ @cindex interrupt handler functions on the Blackfin, m68k, H8/300 and SH processors
+ Use this attribute on the Blackfin, m68k, H8/300, H8/300H, H8S, and SH to
+@@ -5807,6 +5816,7 @@
+ @menu
+ * Alpha Built-in Functions::
+ * ARM Built-in Functions::
++* AVR32 Built-in Functions::
+ * Blackfin Built-in Functions::
+ * FR-V Built-in Functions::
+ * X86 Built-in Functions::
+@@ -6045,6 +6055,54 @@
+ long long __builtin_arm_wzero ()
+ @end smallexample
++@node AVR32 Built-in Functions
++@subsection AVR32 Built-in Functions
++
++
++@smallexample
++
++int __builtin_sats (int /*Rd*/,int /*sa*/, int /*bn*/)
++int __builtin_satu (int /*Rd*/,int /*sa*/, int /*bn*/)
++int __builtin_satrnds (int /*Rd*/,int /*sa*/, int /*bn*/)
++int __builtin_satrndu (int /*Rd*/,int /*sa*/, int /*bn*/)
++short __builtin_mulsathh_h (short, short)
++int __builtin_mulsathh_w (short, short)
++short __builtin_mulsatrndhh_h (short, short)
++int __builtin_mulsatrndwh_w (int, short)
++int __builtin_mulsatwh_w (int, short)
++int __builtin_macsathh_w (int, short, short)
++short __builtin_satadd_h (short, short)
++short __builtin_satsub_h (short, short)
++int __builtin_satadd_w (int, int)
++int __builtin_satsub_w (int, int)
++long long __builtin_mulwh_d(int, short)
++long long __builtin_mulnwh_d(int, short)
++long long __builtin_macwh_d(long long, int, short)
++long long __builtin_machh_d(long long, short, short)
++
++void __builtin_musfr(int);
++int __builtin_mustr(void);
++int __builtin_mfsr(int /*Status Register Address*/)
++void __builtin_mtsr(int /*Status Register Address*/, int /*Value*/)
++int __builtin_mfdr(int /*Debug Register Address*/)
++void __builtin_mtdr(int /*Debug Register Address*/, int /*Value*/)
++void __builtin_cache(void * /*Address*/, int /*Cache Operation*/)
++void __builtin_sync(int /*Sync Operation*/)
++void __builtin_tlbr(void)
++void __builtin_tlbs(void)
++void __builtin_tlbw(void)
++void __builtin_breakpoint(void)
++int __builtin_xchg(void * /*Address*/, int /*Value*/ )
++short __builtin_bswap_16(short)
++int __builtin_bswap_32(int)
++void __builtin_cop(int/*cpnr*/, int/*crd*/, int/*crx*/, int/*cry*/, int/*op*/)
++int __builtin_mvcr_w(int/*cpnr*/, int/*crs*/)
++void __builtin_mvrc_w(int/*cpnr*/, int/*crd*/, int/*value*/)
++long long __builtin_mvcr_d(int/*cpnr*/, int/*crs*/)
++void __builtin_mvrc_d(int/*cpnr*/, int/*crd*/, long long/*value*/)
++
++@end smallexample
++
+ @node Blackfin Built-in Functions
+ @subsection Blackfin Built-in Functions
+diff -Nur gcc-4.1.2/gcc/doc/invoke.texi gcc-4.1.2-owrt/gcc/doc/invoke.texi
+--- gcc-4.1.2/gcc/doc/invoke.texi      2006-09-25 23:21:58.000000000 +0200
++++ gcc-4.1.2-owrt/gcc/doc/invoke.texi 2007-05-24 12:03:28.000000000 +0200
+@@ -185,7 +185,7 @@
+ -fno-default-inline  -fvisibility-inlines-hidden @gol
+ -Wabi  -Wctor-dtor-privacy @gol
+ -Wnon-virtual-dtor  -Wreorder @gol
+--Weffc++  -Wno-deprecated  -Wstrict-null-sentinel @gol
++-Weffc++  -Wno-deprecated @gol
+ -Wno-non-template-friend  -Wold-style-cast @gol
+ -Woverloaded-virtual  -Wno-pmf-conversions @gol
+ -Wsign-promo}
+@@ -569,6 +569,10 @@
+ -mauto-incdec  -minmax  -mlong-calls  -mshort @gol
+ -msoft-reg-count=@var{count}}
++@emph{AVR32 Options}
++@gccoptlist{-muse-rodata-section -mhard-float -msoft-float -mrelax @gol
++-muse-oscall -mforce-double-align -mno-init-got -mcpu=@var{cpu}}
++
+ @emph{MCore Options}
+ @gccoptlist{-mhardlit  -mno-hardlit  -mdiv  -mno-div  -mrelax-immediates @gol
+ -mno-relax-immediates  -mwide-bitfields  -mno-wide-bitfields @gol
+@@ -1797,14 +1801,6 @@
+ @opindex Wno-deprecated
+ Do not warn about usage of deprecated features.  @xref{Deprecated Features}.
+-@item -Wstrict-null-sentinel @r{(C++ only)}
+-@opindex Wstrict-null-sentinel
+-Warn also about the use of an uncasted @code{NULL} as sentinel.  When
+-compiling only with GCC this is a valid sentinel, as @code{NULL} is defined
+-to @code{__null}.  Although it is a null pointer constant not a null pointer,
+-it is guaranteed to of the same size as a pointer.  But this use is
+-not portable across different compilers.
+-
+ @item -Wno-non-template-friend @r{(C++ only)}
+ @opindex Wno-non-template-friend
+ Disable warnings when non-templatized friend functions are declared
+@@ -2662,13 +2658,11 @@
+ If you want to warn about code which uses the uninitialized value of the
+ variable in its own initializer, use the @option{-Winit-self} option.
+-These warnings occur for individual uninitialized or clobbered
+-elements of structure, union or array variables as well as for
+-variables which are uninitialized or clobbered as a whole.  They do
+-not occur for variables or elements declared @code{volatile}.  Because
+-these warnings depend on optimization, the exact variables or elements
+-for which there are warnings will depend on the precise optimization
+-options and version of GCC used.
++These warnings occur only for variables that are candidates for
++register allocation.  Therefore, they do not occur for a variable that
++is declared @code{volatile}, or whose address is taken, or whose size
++is other than 1, 2, 4 or 8 bytes.  Also, they do not occur for
++structures, unions or arrays, even when they are in registers.
+ Note that there may be no warning about a variable that is used only
+ to compute a value that itself is never used, because such
+@@ -5935,10 +5929,6 @@
+ we always try to remove unnecessary ivs from the set during its
+ optimization when a new iv is added to the set.
+-@item scev-max-expr-size
+-Bound on size of expressions used in the scalar evolutions analyzer.
+-Large expressions slow the analyzer.
+-
+ @item vect-max-version-checks
+ The maximum number of runtime checks that can be performed when doing
+ loop versioning in the vectorizer.  See option ftree-vect-loop-version
+@@ -7115,7 +7105,7 @@
+ * ARC Options::
+ * ARM Options::
+ * AVR Options::
+-* Blackfin Options::
++* AVR32 Options::
+ * CRIS Options::
+ * CRX Options::
+ * Darwin Options::
+@@ -7578,81 +7568,55 @@
+ size.
+ @end table
+-@node Blackfin Options
+-@subsection Blackfin Options
+-@cindex Blackfin Options
++@node AVR32 Options
++@subsection AVR32 Options
++@cindex AVR32 Options
+-@table @gcctabopt
+-@item -momit-leaf-frame-pointer
+-@opindex momit-leaf-frame-pointer
+-Don't keep the frame pointer in a register for leaf functions.  This
+-avoids the instructions to save, set up and restore frame pointers and
+-makes an extra register available in leaf functions.  The option
+-@option{-fomit-frame-pointer} removes the frame pointer for all functions
+-which might make debugging harder.
++These options are defined for AVR32 implementations:
+-@item -mspecld-anomaly
+-@opindex mspecld-anomaly
+-When enabled, the compiler will ensure that the generated code does not
+-contain speculative loads after jump instructions.  This option is enabled
+-by default.
+-
+-@item -mno-specld-anomaly
+-@opindex mno-specld-anomaly
+-Don't generate extra code to prevent speculative loads from occurring.
+-
+-@item -mcsync-anomaly
+-@opindex mcsync-anomaly
+-When enabled, the compiler will ensure that the generated code does not
+-contain CSYNC or SSYNC instructions too soon after conditional branches.
+-This option is enabled by default.
+-
+-@item -mno-csync-anomaly
+-@opindex mno-csync-anomaly
+-Don't generate extra code to prevent CSYNC or SSYNC instructions from
+-occurring too soon after a conditional branch.
+-
+-@item -mlow-64k
+-@opindex mlow-64k
+-When enabled, the compiler is free to take advantage of the knowledge that
+-the entire program fits into the low 64k of memory.
+-
+-@item -mno-low-64k
+-@opindex mno-low-64k
+-Assume that the program is arbitrarily large.  This is the default.
++@table @gcctabopt
++@item -muse-rodata-section
++@opindex muse-rodata-section
++Use section @samp{.rodata} for read-only data instead of @samp{.text}.
+-@item -mid-shared-library
+-@opindex mid-shared-library
+-Generate code that supports shared libraries via the library ID method.
+-This allows for execute in place and shared libraries in an environment
+-without virtual memory management.  This option implies @option{-fPIC}.
++@item -mhard-float
++@opindex mhard-float
++Use floating-point coprocessor instructions. 
+-@item -mno-id-shared-library
+-@opindex mno-id-shared-library
+-Generate code that doesn't assume ID based shared libraries are being used.
+-This is the default.
++@item -msoft-float
++@opindex msoft-float
++Use software floating-point library. 
+-@item -mshared-library-id=n
+-@opindex mshared-library-id
+-Specified the identification number of the ID based shared library being
+-compiled.  Specifying a value of 0 will generate more compact code, specifying
+-other values will force the allocation of that number to the current
+-library but is no more space or time efficient than omitting this option.
++@item -mrelax
++@opindex mrelax
++Enable relaxing in linker. This means that when the address of symbols
++are known at link time, the linker can optimize @samp{icall} and @samp{mcall}
++instructions into a @samp{rcall} instruction if possible. Loading the address
++of a symbol can also be optimized.  
++
++@item -muse-oscall
++@opindex muse-oscall
++When using gcc as a frontend for linking this switch forces the use of
++@samp{fake} system calls in the newlib c-library. These fake system
++calls are handled by some AVR32 simulators which redirects these calls
++to the OS in which the simulator is running. This is practical for
++being able to perform file I/O when running programs in a simulator. 
++
++@item -mforce-double-align
++@opindex mforce-double-align
++Force double-word alignment for double-word memory accesses.
++
++@item -mno-init-got
++@opindex mno-init-got
++Do not initialize the GOT register before using it when compiling PIC
++code.
+-@item -mlong-calls
+-@itemx -mno-long-calls
+-@opindex mlong-calls
+-@opindex mno-long-calls
+-Tells the compiler to perform function calls by first loading the
+-address of the function into a register and then performing a subroutine
+-call on this register.  This switch is needed if the target function
+-will lie outside of the 24 bit addressing range of the offset based
+-version of subroutine call instruction.
++@item -mcpu=@var{cpu-type}
++@opindex mcpu
++Generate code for the specified cpu. Permissible names are: @samp{morgan},
++@samp{ap7000} and @samp{default}. @samp{default} is a dummy cpu which
++allows all avr32 instructions. 
+-This feature is not enabled by default.  Specifying
+-@option{-mno-long-calls} will restore the default behavior.  Note these
+-switches have no effect on how the compiler generates code to handle
+-function calls via function pointers.
+ @end table
+ @node CRIS Options
+@@ -11341,6 +11305,7 @@
+ Application Binary Interface, PowerPC processor supplement.  This is the
+ default unless you configured GCC using @samp{powerpc-*-eabiaix}.
++
+ @item -mcall-sysv-eabi
+ @opindex mcall-sysv-eabi
+ Specify both @option{-mcall-sysv} and @option{-meabi} options.
+diff -Nur gcc-4.1.2/gcc/doc/md.texi gcc-4.1.2-owrt/gcc/doc/md.texi
+--- gcc-4.1.2/gcc/doc/md.texi  2005-12-16 14:11:58.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/doc/md.texi     2007-05-24 12:03:28.000000000 +0200
+@@ -1686,6 +1686,59 @@
+ A memory reference suitable for the ARMv4 ldrsb instruction.
+ @end table
++@item AVR32 family---@file{avr32.h}
++@table @code
++@item f
++Floating-point registers (f0 to f15)
++
++@item Ku@var{bits}
++Unsigned constant representable with @var{bits} number of bits (Must be
++two digits). I.e: An unsigned 8-bit constant is written as @samp{Ku08}  
++ 
++@item Ks@var{bits}
++Signed constant representable with @var{bits} number of bits (Must be
++two digits). I.e: A signed 12-bit constant is written as @samp{Ks12}  
++
++@item Is@var{bits}
++The negated range of a signed constant representable with  @var{bits} 
++number of bits. The same as @samp{Ks@var{bits}} with a negated range. 
++This means that the constant must be in the range @math{-2^{bits-1}-1} to @math{2^{bits-1}}
++
++@item G
++A single/double precision floating-point immediate or 64-bit integer 
++immediate where the least and most significant words both can be
++loaded with a move instruction. That is the the integer form of the 
++values in the least and most significant words both are in the range 
++@math{-2^{20}} to @math{2^{20}-1}.
++         
++@item RKs@var{bits}
++A memory reference where the address consists of a base register
++plus a signed immediate displacement with range given by @samp{Ks@var{bits}}
++which has the same format as for the signed immediate integer constraint
++given above.  
++
++@item RKu@var{bits}
++A memory reference where the address consists of a base register
++plus an unsigned immediate displacement with range given by @samp{Ku@var{bits}}
++which has the same format as for the unsigned immediate integer constraint
++given above.  
++
++@item S
++A memory reference with an immediate or register offset
++
++@item T
++A memory reference to a constant pool entry
++
++@item W
++A valid operand for use in the @samp{lda.w} instruction macro when
++relaxing is enabled
++
++@item Z
++A memory reference valid for coprocessor memory instructions
++
++@end table
++
++
+ @item AVR family---@file{avr.h}
+ @table @code
+ @item l
+@@ -2132,102 +2185,6 @@
+ @end table
+-@item Blackfin family---@file{bfin.h}
+-@table @code
+-@item a
+-P register
+-
+-@item d
+-D register
+-
+-@item z
+-A call clobbered P register.
+-
+-@item D
+-Even-numbered D register
+-
+-@item W
+-Odd-numbered D register
+-
+-@item e
+-Accumulator register.
+-
+-@item A
+-Even-numbered accumulator register.
+-
+-@item B
+-Odd-numbered accumulator register.
+-
+-@item b
+-I register
+-
+-@item B
+-B register
+-
+-@item f
+-M register
+-
+-@item c
+-Registers used for circular buffering, i.e. I, B, or L registers.
+-
+-@item C
+-The CC register.
+-
+-@item x
+-Any D, P, B, M, I or L register.
+-
+-@item y
+-Additional registers typically used only in prologues and epilogues: RETS,
+-RETN, RETI, RETX, RETE, ASTAT, SEQSTAT and USP.
+-
+-@item w
+-Any register except accumulators or CC.
+-
+-@item Ksh
+-Signed 16 bit integer (in the range -32768 to 32767)
+-
+-@item Kuh
+-Unsigned 16 bit integer (in the range 0 to 65535)
+-
+-@item Ks7
+-Signed 7 bit integer (in the range -64 to 63)
+-
+-@item Ku7
+-Unsigned 7 bit integer (in the range 0 to 127)
+-
+-@item Ku5
+-Unsigned 5 bit integer (in the range 0 to 31)
+-
+-@item Ks4
+-Signed 4 bit integer (in the range -8 to 7)
+-
+-@item Ks3
+-Signed 3 bit integer (in the range -3 to 4)
+-
+-@item Ku3
+-Unsigned 3 bit integer (in the range 0 to 7)
+-
+-@item P@var{n}
+-Constant @var{n}, where @var{n} is a single-digit constant in the range 0 to 4.
+-
+-@item M1
+-Constant 255.
+-
+-@item M2
+-Constant 65535.
+-
+-@item J
+-An integer constant with exactly a single bit set.
+-
+-@item L
+-An integer constant with all bits set except exactly one.
+-
+-@item H
+-
+-@item Q
+-Any SYMBOL_REF.
+-@end table
+-
+ @item M32C---@file{m32c.c}
+ @item Rsp
+diff -Nur gcc-4.1.2/gcc/expr.c gcc-4.1.2-owrt/gcc/expr.c
+--- gcc-4.1.2/gcc/expr.c       2006-11-02 18:18:52.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/expr.c  2007-05-24 12:03:28.000000000 +0200
+@@ -3401,18 +3401,19 @@
+     }
+   else
+     {
++      emit_move_insn (stack_pointer_rtx,
++                    expand_binop (Pmode,
+ #ifdef STACK_GROWS_DOWNWARD
+-      /* ??? This seems wrong if STACK_PUSH_CODE == POST_DEC.  */
+-      dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
+-                              GEN_INT (-(HOST_WIDE_INT) rounded_size));
++                                  sub_optab,
+ #else
+-      /* ??? This seems wrong if STACK_PUSH_CODE == POST_INC.  */
+-      dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
+-                              GEN_INT (rounded_size));
++                                  add_optab,
+ #endif
+-      dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
++                                  stack_pointer_rtx,
++                                  GEN_INT (rounded_size),
++                                  NULL_RTX, 0, OPTAB_LIB_WIDEN));
++      dest_addr = stack_pointer_rtx;
+     }
+-
++  
+   dest = gen_rtx_MEM (mode, dest_addr);
+   if (type != 0)
+diff -Nur gcc-4.1.2/gcc/genemit.c gcc-4.1.2-owrt/gcc/genemit.c
+--- gcc-4.1.2/gcc/genemit.c    2005-06-25 04:02:01.000000000 +0200
++++ gcc-4.1.2-owrt/gcc/genemit.c       2007-05-24 12:03:28.000000000 +0200
+@@ -122,6 +122,24 @@
+ }
\f
+ static void
++gen_vararg_prologue(int operands)
++{
++  int i;
++
++  if (operands > 1)
++    {
++      for (i = 1; i < operands; i++)
++      printf("  rtx operand%d ATTRIBUTE_UNUSED;\n", i);
++
++      printf("  va_list args;\n\n");
++      printf("  va_start(args, operand0);\n");
++      for (i = 1; i < operands; i++)
++      printf("  operand%d = va_arg(args, rtx);\n", i);
++      printf("  va_end(args);\n\n");
++    }
++}
++
++static void
+ print_code (RTX_CODE code)
+ {
+   const char *p1;
+@@ -406,18 +424,16 @@
+     fatal ("match_dup operand number has no match_operand");
+   /* Output the function name and argument declarations.  */
+-  printf ("rtx\ngen_%s (", XSTR (insn, 0));
++  printf ("rtx\ngen_%s ", XSTR (insn, 0));
++
+   if (operands)
+-    for (i = 0; i < operands; i++)
+-      if (i)
+-      printf (",\n\trtx operand%d ATTRIBUTE_UNUSED", i);
+-      else
+-      printf ("rtx operand%d ATTRIBUTE_UNUSED", i);
++    printf("(rtx operand0 ATTRIBUTE_UNUSED, ...)\n");
+   else
+-    printf ("void");
+-  printf (")\n");
++    printf("(void)\n");
+   printf ("{\n");
++  gen_vararg_prologue(operands);
++
+   /* Output code to construct and return the rtl for the instruction body.  */
+   if (XVECLEN (insn, 1) == 1)
+@@ -457,16 +473,12 @@
+   operands = max_operand_vec (expand, 1);
+   /* Output the function name and argument declarations.  */
+-  printf ("rtx\ngen_%s (", XSTR (expand, 0));
++  printf ("rtx\ngen_%s ", XSTR (expand, 0));
+   if (operands)
+-    for (i = 0; i < operands; i++)
+-      if (i)
+-      printf (",\n\trtx operand%d", i);
+-      else
+-      printf ("rtx operand%d", i);
++    printf("(rtx operand0 ATTRIBUTE_UNUSED, ...)\n");
+   else
+-    printf ("void");
+-  printf (")\n");
++    printf("(void)\n");
++
+   printf ("{\n");
+   /* If we don't have any C code to write, only one insn is being written,
+@@ -476,6 +488,8 @@
+       && operands > max_dup_opno
+       && XVECLEN (expand, 1) == 1)
+     {
++      gen_vararg_prologue(operands);
++
+       printf ("  return ");
+       gen_exp (XVECEXP (expand, 1, 0), DEFINE_EXPAND, NULL);
+       printf (";\n}\n\n");
+@@ -489,6 +503,7 @@
+   for (; i <= max_scratch_opno; i++)
+     printf ("  rtx operand%d ATTRIBUTE_UNUSED;\n", i);
+   printf ("  rtx _val = 0;\n");
++  gen_vararg_prologue(operands);
+   printf ("  start_sequence ();\n");
+   /* The fourth operand of DEFINE_EXPAND is some code to be executed
+diff -Nur gcc-4.1.2/gcc/genflags.c gcc-4.1.2-owrt/gcc/genflags.c
+--- gcc-4.1.2/gcc/genflags.c   2005-06-25 04:02:01.000000000 +0200
++++ gcc-4.1.2-owrt/gcc/genflags.c      2007-05-24 12:03:28.000000000 +0200
+@@ -128,7 +128,6 @@
+ gen_proto (rtx insn)
+ {
+   int num = num_operands (insn);
+-  int i;
+   const char *name = XSTR (insn, 0);
+   int truth = maybe_eval_c_test (XSTR (insn, 2));
+@@ -159,12 +158,7 @@
+   if (num == 0)
+     fputs ("void", stdout);
+   else
+-    {
+-      for (i = 1; i < num; i++)
+-      fputs ("rtx, ", stdout);
+-
+-      fputs ("rtx", stdout);
+-    }
++    fputs("rtx, ...", stdout);
+   puts (");");
+@@ -174,12 +168,7 @@
+     {
+       printf ("static inline rtx\ngen_%s", name);
+       if (num > 0)
+-      {
+-        putchar ('(');
+-        for (i = 0; i < num-1; i++)
+-          printf ("rtx ARG_UNUSED (%c), ", 'a' + i);
+-        printf ("rtx ARG_UNUSED (%c))\n", 'a' + i);
+-      }
++      puts("(rtx ARG_UNUSED(a), ...)");
+       else
+       puts ("(void)");
+       puts ("{\n  return 0;\n}");
+diff -Nur gcc-4.1.2/gcc/genoutput.c gcc-4.1.2-owrt/gcc/genoutput.c
+--- gcc-4.1.2/gcc/genoutput.c  2005-06-25 04:02:01.000000000 +0200
++++ gcc-4.1.2-owrt/gcc/genoutput.c     2007-05-24 12:03:28.000000000 +0200
+@@ -383,7 +383,7 @@
+       }
+       if (d->name && d->name[0] != '*')
+-      printf ("    (insn_gen_fn) gen_%s,\n", d->name);
++      printf ("    gen_%s,\n", d->name);
+       else
+       printf ("    0,\n");
+diff -Nur gcc-4.1.2/gcc/longlong.h gcc-4.1.2-owrt/gcc/longlong.h
+--- gcc-4.1.2/gcc/longlong.h   2005-12-06 11:02:57.000000000 +0100
++++ gcc-4.1.2-owrt/gcc/longlong.h      2007-05-24 12:03:28.000000000 +0200
+@@ -227,6 +227,39 @@
+ #define UDIV_TIME 100
+ #endif /* __arm__ */
++#if defined (__avr32__) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("add\t%1, %4, %5\n\tadc\t%0, %2, %3"               \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "r" ((USItype) (ah)),                                      \
++           "r" ((USItype) (bh)),                                      \
++           "r" ((USItype) (al)),                                      \
++           "r" ((USItype) (bl)) __CLOBBER_CC)
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("sub\t%1, %4, %5\n\tsbc\t%0, %2, %3"               \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "r" ((USItype) (ah)),                                      \
++           "r" ((USItype) (bh)),                                      \
++           "r" ((USItype) (al)),                                      \
++           "r" ((USItype) (bl)) __CLOBBER_CC)
++
++#define __umulsidi3(a,b) ((UDItype)(a) * (UDItype)(b))
++
++#define umul_ppmm(w1, w0, u, v) \
++{                                                                     \
++  DWunion __w;                                                                \
++  __w.ll = __umulsidi3 (u, v);                                                \
++  w1 = __w.s.high;                                                    \
++  w0 = __w.s.low;                                                     \
++}
++
++#define count_leading_zeros(COUNT,X)  ((COUNT) = __builtin_clz (X))
++#define count_trailing_zeros(COUNT,X) ((COUNT) = __builtin_ctz (X))
++#define COUNT_LEADING_ZEROS_0 32
++#endif
++
+ #if defined (__hppa) && W_TYPE_SIZE == 32
+ #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
+   __asm__ ("add %4,%5,%1\n\taddc %2,%3,%0"                            \
+diff -Nur gcc-4.1.2/gcc/optabs.h gcc-4.1.2-owrt/gcc/optabs.h
+--- gcc-4.1.2/gcc/optabs.h     2005-08-19 23:20:02.000000000 +0200
++++ gcc-4.1.2-owrt/gcc/optabs.h        2007-05-24 12:03:28.000000000 +0200
+@@ -415,7 +415,7 @@
+ extern GTY(()) optab code_to_optab[NUM_RTX_CODE + 1];
\f
+-typedef rtx (*rtxfun) (rtx);
++typedef rtx (*rtxfun) (rtx, ...);
+ /* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...)
+    gives the gen_function to make a branch to test that condition.  */
+diff -Nur gcc-4.1.2/libstdc++-v3/acinclude.m4 gcc-4.1.2-owrt/libstdc++-v3/acinclude.m4
+--- gcc-4.1.2/libstdc++-v3/acinclude.m4        2007-01-29 11:51:01.000000000 +0100
++++ gcc-4.1.2-owrt/libstdc++-v3/acinclude.m4   2007-05-24 12:03:28.000000000 +0200
+@@ -125,6 +125,15 @@
+   ## other macros from doing the same.  This should be automated.)  -pme
+   need_libmath=no
++  # Check for uClibc since Linux platforms use different configuration
++  # directories depending on the C library in use.
++  AC_EGREP_CPP([_using_uclibc], [
++  #include <stdio.h>
++  #if __UCLIBC__
++    _using_uclibc
++  #endif
++  ], uclibc=yes, uclibc=no)
++
+   # Find platform-specific directories containing configuration info.
+   # Also possibly modify flags used elsewhere, as needed by the platform.
+   GLIBCXX_CHECK_HOST
+@@ -1040,8 +1049,8 @@
+           #endif
+           int main()
+           {
+-              const char __one[] = "Äuglein Augmen";
+-              const char __two[] = "Äuglein";
++              const char __one[] = "�uglein Augmen";
++              const char __two[] = "�uglein";
+               int i;
+               int j;
+               __locale_t        loc;
+@@ -1916,6 +1925,14 @@
+   ])
+ ])
++# Macros that should have automatically be included, but...
++m4_include([../config/enable.m4])
++m4_include([../config/lead-dot.m4])
++m4_include([../config/no-executables.m4])
++m4_include([../libtool.m4])
++m4_include([crossconfig.m4])
++m4_include([linkage.m4])
++
+ # Macros from the top-level gcc directory.
+ m4_include([../config/tls.m4])
+diff -Nur gcc-4.1.2/libstdc++-v3/config/os/gnu-linux/ctype_base.h gcc-4.1.2-owrt/libstdc++-v3/config/os/gnu-linux/ctype_base.h
+--- gcc-4.1.2/libstdc++-v3/config/os/gnu-linux/ctype_base.h    2005-08-17 04:28:44.000000000 +0200
++++ gcc-4.1.2-owrt/libstdc++-v3/config/os/gnu-linux/ctype_base.h       2007-05-24 12:03:28.000000000 +0200
+@@ -43,8 +43,8 @@
+   struct ctype_base
+   {
+     // Non-standard typedefs.
+-    typedef const int*                __to_type;
+-
++    typedef const int*      __to_type;
++    
+     // NB: Offsets into ctype<char>::_M_table force a particular size
+     // on the mask type. Because of this, we don't use an enum.
+     typedef unsigned short    mask;   
+diff -Nur gcc-4.1.2/libstdc++-v3/configure.host gcc-4.1.2-owrt/libstdc++-v3/configure.host
+--- gcc-4.1.2/libstdc++-v3/configure.host      2007-01-28 21:12:40.000000000 +0100
++++ gcc-4.1.2-owrt/libstdc++-v3/configure.host 2007-05-24 12:03:28.000000000 +0200
+@@ -214,8 +214,15 @@
+   freebsd*)
+     os_include_dir="os/bsd/freebsd"
+     ;;
++  linux-uclibc*)
++    os_include_dir="os/uclibc-linux"
++    ;;
+   gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
+-    os_include_dir="os/gnu-linux"
++    if [ "$uclibc" = "yes" ]; then
++     os_include_dir="os/uclibc"
++    else
++      os_include_dir="os/gnu-linux"
++    fi
+     ;;
+   hpux*)
+     os_include_dir="os/hpux"
+diff -Nur gcc-4.1.2/libstdc++-v3/include/Makefile.in gcc-4.1.2-owrt/libstdc++-v3/include/Makefile.in
+--- gcc-4.1.2/libstdc++-v3/include/Makefile.in 2006-01-10 18:14:00.000000000 +0100
++++ gcc-4.1.2-owrt/libstdc++-v3/include/Makefile.in    2007-05-24 12:03:28.000000000 +0200
+@@ -36,6 +36,7 @@
+ build_triplet = @build@
+ host_triplet = @host@
+ target_triplet = @target@
++LIBOBJDIR =
+ DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \
+       $(top_srcdir)/fragment.am
+ subdir = include
+diff -Nur gcc-4.1.2/libstdc++-v3/libmath/Makefile.in gcc-4.1.2-owrt/libstdc++-v3/libmath/Makefile.in
+--- gcc-4.1.2/libstdc++-v3/libmath/Makefile.in 2006-01-10 18:14:00.000000000 +0100
++++ gcc-4.1.2-owrt/libstdc++-v3/libmath/Makefile.in    2007-05-24 12:03:28.000000000 +0200
+@@ -37,6 +37,7 @@
+ build_triplet = @build@
+ host_triplet = @host@
+ target_triplet = @target@
++LIBOBJDIR =
+ subdir = libmath
+ DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
+ ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+diff -Nur gcc-4.1.2/libstdc++-v3/libsupc++/Makefile.in gcc-4.1.2-owrt/libstdc++-v3/libsupc++/Makefile.in
+--- gcc-4.1.2/libstdc++-v3/libsupc++/Makefile.in       2006-01-10 18:14:00.000000000 +0100
++++ gcc-4.1.2-owrt/libstdc++-v3/libsupc++/Makefile.in  2007-05-24 12:03:28.000000000 +0200
+@@ -38,6 +38,7 @@
+ build_triplet = @build@
+ host_triplet = @host@
+ target_triplet = @target@
++LIBOBJDIR =
+ DIST_COMMON = $(glibcxxinstall_HEADERS) $(srcdir)/Makefile.am \
+       $(srcdir)/Makefile.in $(top_srcdir)/fragment.am
+ subdir = libsupc++
+diff -Nur gcc-4.1.2/libstdc++-v3/Makefile.in gcc-4.1.2-owrt/libstdc++-v3/Makefile.in
+--- gcc-4.1.2/libstdc++-v3/Makefile.in 2006-01-10 18:14:00.000000000 +0100
++++ gcc-4.1.2-owrt/libstdc++-v3/Makefile.in    2007-05-24 12:03:28.000000000 +0200
+@@ -36,6 +36,7 @@
+ build_triplet = @build@
+ host_triplet = @host@
+ target_triplet = @target@
++LIBOBJDIR =
+ DIST_COMMON = README $(am__configure_deps) $(srcdir)/../config.guess \
+       $(srcdir)/../config.sub $(srcdir)/../install-sh \
+       $(srcdir)/../ltmain.sh $(srcdir)/../missing \
+diff -Nur gcc-4.1.2/libstdc++-v3/po/Makefile.in gcc-4.1.2-owrt/libstdc++-v3/po/Makefile.in
+--- gcc-4.1.2/libstdc++-v3/po/Makefile.in      2006-01-10 18:14:00.000000000 +0100
++++ gcc-4.1.2-owrt/libstdc++-v3/po/Makefile.in 2007-05-24 12:03:28.000000000 +0200
+@@ -36,6 +36,7 @@
+ build_triplet = @build@
+ host_triplet = @host@
+ target_triplet = @target@
++LIBOBJDIR =
+ DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \
+       $(top_srcdir)/fragment.am
+ subdir = po
+diff -Nur gcc-4.1.2/libstdc++-v3/src/Makefile.in gcc-4.1.2-owrt/libstdc++-v3/src/Makefile.in
+--- gcc-4.1.2/libstdc++-v3/src/Makefile.in     2006-01-10 18:14:00.000000000 +0100
++++ gcc-4.1.2-owrt/libstdc++-v3/src/Makefile.in        2007-05-24 12:03:28.000000000 +0200
+@@ -36,6 +36,7 @@
+ build_triplet = @build@
+ host_triplet = @host@
+ target_triplet = @target@
++LIBOBJDIR =
+ DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \
+       $(top_srcdir)/fragment.am
+ subdir = src
index 74936e97f1fc6bcd8014470b1f66c167ad8160ea..7fce989542d265c612e90859035ce6af0352ba65 100644 (file)
@@ -24,6 +24,7 @@ UCLIBC_TARGET_ARCH:=$(shell echo $(ARCH) | sed -e s'/-.*//' \
                -e 's/i.86/i386/' \
                -e 's/sparc.*/sparc/' \
                -e 's/arm.*/arm/g' \
+               -e 's/avr32.*/avr32/g' \
                -e 's/m68k.*/m68k/' \
                -e 's/ppc/powerpc/g' \
                -e 's/v850.*/v850/g' \
index 3dd1ea3522498f035550c167a541175d8a123080..70d907b5a74e935b25cbee98f0b50f8b64684566 100644 (file)
@@ -3,6 +3,7 @@
 #
 # TARGET_alpha is not set
 TARGET_arm=y
+# TARGET_avr32 is not set
 # TARGET_bfin is not set
 # TARGET_cris is not set
 # TARGET_e1 is not set
index fa796953f2118bb79e4d4da2f4f7e907896df913..49b9e9e556f2cc4b81b4df106cd5eafcbcac97f8 100644 (file)
@@ -3,6 +3,7 @@
 #
 # TARGET_alpha is not set
 TARGET_arm=y
+# TARGET_avr32 is not set
 # TARGET_bfin is not set
 # TARGET_cris is not set
 # TARGET_e1 is not set
diff --git a/toolchain/uClibc/config/avr32 b/toolchain/uClibc/config/avr32
new file mode 100644 (file)
index 0000000..092a41b
--- /dev/null
@@ -0,0 +1,160 @@
+#
+# Automatically generated make config: don't edit
+#
+# TARGET_alpha is not set
+# TARGET_arm is not set
+TARGET_avr32=y
+# TARGET_bfin is not set
+# TARGET_cris is not set
+# TARGET_e1 is not set
+# TARGET_frv is not set
+# TARGET_h8300 is not set
+# TARGET_i386 is not set
+# TARGET_i960 is not set
+# TARGET_m68k is not set
+# TARGET_microblaze is not set
+# TARGET_mips is not set
+# TARGET_nios is not set
+# TARGET_nios2 is not set
+# TARGET_powerpc is not set
+# TARGET_sh is not set
+# TARGET_sh64 is not set
+# TARGET_sparc is not set
+# TARGET_v850 is not set
+# TARGET_x86_64 is not set
+
+#
+# Target Architecture Features and Options
+#
+HAVE_ELF=y
+TARGET_ARCH="avr32"
+ARCH_SUPPORTS_BIG_ENDIAN=y
+UCLIBC_COMPLETELY_PIC=y
+CONFIG_AP7000=y
+LINKRELAX=y
+# ARCH_LITTLE_ENDIAN is not set
+ARCH_BIG_ENDIAN=y
+# ARCH_HAS_NO_MMU is not set
+ARCH_HAS_MMU=y
+UCLIBC_HAS_FLOATS=y
+# HAS_FPU is not set
+UCLIBC_HAS_SOFT_FLOAT=y
+# DO_C99_MATH is not set
+KERNEL_SOURCE="./toolchain_build_avr32/linux"
+C_SYMBOL_PREFIX=""
+HAVE_DOT_CONFIG=y
+
+#
+# General Library Settings
+#
+# HAVE_NO_PIC is not set
+DOPIC=y
+# HAVE_NO_SHARED is not set
+HAVE_SHARED=y
+# ARCH_HAS_NO_LDSO is not set
+BUILD_UCLIBC_LDSO=y
+FORCE_SHAREABLE_TEXT_SEGMENTS=y
+LDSO_LDD_SUPPORT=y
+LDSO_CACHE_SUPPORT=y
+# LDSO_PRELOAD_FILE_SUPPORT is not set
+LDSO_BASE_FILENAME="ld.so"
+# LDSO_RUNPATH is not set
+# DL_FINI_CRT_COMPAT is not set
+UCLIBC_CTOR_DTOR=y
+# HAS_NO_THREADS is not set
+UCLIBC_HAS_THREADS=y
+# PTHREADS_DEBUG_SUPPORT is not set
+UCLIBC_HAS_LFS=y
+# UCLIBC_STATIC_LDCONFIG is not set
+# MALLOC is not set
+# MALLOC_SIMPLE is not set
+MALLOC_STANDARD=y
+MALLOC_GLIBC_COMPAT=y
+UCLIBC_DYNAMIC_ATEXIT=y
+HAS_SHADOW=y
+UNIX98PTY_ONLY=y
+ASSUME_DEVPTS=y
+UCLIBC_HAS_TM_EXTENSIONS=y
+UCLIBC_HAS_TZ_CACHING=y
+UCLIBC_HAS_TZ_FILE=y
+UCLIBC_HAS_TZ_FILE_READ_MANY=y
+UCLIBC_TZ_FILE_PATH="/etc/TZ"
+
+#
+# Networking Support
+#
+UCLIBC_HAS_IPV6=y
+UCLIBC_HAS_RPC=y
+UCLIBC_HAS_FULL_RPC=y
+
+#
+# String and Stdio Support
+#
+UCLIBC_HAS_STRING_GENERIC_OPT=y
+# UCLIBC_HAS_STRING_ARCH_OPT is not set
+UCLIBC_HAS_CTYPE_TABLES=y
+UCLIBC_HAS_CTYPE_SIGNED=y
+# UCLIBC_HAS_CTYPE_UNSAFE is not set
+UCLIBC_HAS_CTYPE_CHECKED=y
+# UCLIBC_HAS_CTYPE_ENFORCED is not set
+UCLIBC_HAS_WCHAR=y
+# UCLIBC_HAS_LOCALE is not set
+UCLIBC_HAS_HEXADECIMAL_FLOATS=y
+UCLIBC_HAS_GLIBC_CUSTOM_PRINTF=y
+UCLIBC_PRINTF_SCANF_POSITIONAL_ARGS=9
+# UCLIBC_HAS_SCANF_GLIBC_A_FLAG is not set
+# UCLIBC_HAS_STDIO_BUFSIZ_NONE is not set
+# UCLIBC_HAS_STDIO_BUFSIZ_256 is not set
+# UCLIBC_HAS_STDIO_BUFSIZ_512 is not set
+# UCLIBC_HAS_STDIO_BUFSIZ_1024 is not set
+# UCLIBC_HAS_STDIO_BUFSIZ_2048 is not set
+UCLIBC_HAS_STDIO_BUFSIZ_4096=y
+# UCLIBC_HAS_STDIO_BUFSIZ_8192 is not set
+UCLIBC_HAS_STDIO_BUILTIN_BUFFER_NONE=y
+# UCLIBC_HAS_STDIO_BUILTIN_BUFFER_4 is not set
+# UCLIBC_HAS_STDIO_BUILTIN_BUFFER_8 is not set
+# UCLIBC_HAS_STDIO_SHUTDOWN_ON_ABORT is not set
+UCLIBC_HAS_STDIO_GETC_MACRO=y
+UCLIBC_HAS_STDIO_PUTC_MACRO=y
+UCLIBC_HAS_STDIO_AUTO_RW_TRANSITION=y
+# UCLIBC_HAS_FOPEN_LARGEFILE_MODE is not set
+UCLIBC_HAS_FOPEN_EXCLUSIVE_MODE=y
+UCLIBC_HAS_GLIBC_CUSTOM_STREAMS=y
+UCLIBC_HAS_PRINTF_M_SPEC=y
+UCLIBC_HAS_ERRNO_MESSAGES=y
+# UCLIBC_HAS_SYS_ERRLIST is not set
+UCLIBC_HAS_SIGNUM_MESSAGES=y
+# UCLIBC_HAS_SYS_SIGLIST is not set
+UCLIBC_HAS_GNU_GETOPT=y
+
+#
+# Big and Tall
+#
+UCLIBC_HAS_REGEX=y
+UCLIBC_HAS_WORDEXP=y
+UCLIBC_HAS_FTW=y
+UCLIBC_HAS_GLOB=y
+
+#
+# Library Installation Options
+#
+SHARED_LIB_LOADER_PREFIX="/lib"
+RUNTIME_PREFIX="/"
+DEVEL_PREFIX="/usr/"
+
+#
+# uClibc security related options
+#
+# UCLIBC_SECURITY is not set
+
+#
+# uClibc development/debugging options
+#
+CROSS_COMPILER_PREFIX=""
+# DODEBUG is not set
+# DODEBUG_PT is not set
+# DOASSERTS is not set
+# SUPPORT_LD_DEBUG is not set
+# SUPPORT_LD_DEBUG_EARLY is not set
+WARNINGS="-Wall"
+# UCLIBC_MJN3_ONLY is not set
index 32e2610203fc53d084bb4db1588219a27176ec33..2351c332afa658de34fabedf298862322f701b43 100644 (file)
@@ -3,6 +3,7 @@
 #
 # TARGET_alpha is not set
 # TARGET_arm is not set
+# TARGET_avr32 is not set
 # TARGET_bfin is not set
 TARGET_cris=y
 # TARGET_e1 is not set
index e258ffe93598d2aa0212a1c2a378885ca82e8367..bd1da58556868a821806a2b86ad2c0671b211fcb 100644 (file)
@@ -10,6 +10,7 @@
 #
 # TARGET_alpha is not set
 # TARGET_arm is not set
+# TARGET_avr32 is not set
 # TARGET_bfin is not set
 # TARGET_cris is not set
 # TARGET_e1 is not set
index ac30b596485ad2eb1ac393bc8b6bc12935ea21b8..0e64b98627b42591a4926ccb00ac9348c1750142 100644 (file)
@@ -10,6 +10,7 @@
 #
 # TARGET_alpha is not set
 # TARGET_arm is not set
+# TARGET_avr32 is not set
 # TARGET_bfin is not set
 # TARGET_cris is not set
 # TARGET_e1 is not set
index 7a959e2ec4ab4aee2d04642346347d75d066bf76..31ab50afc8ac866f9c4732fb9d7348aadfb40e0a 100644 (file)
@@ -10,6 +10,7 @@
 #
 # TARGET_alpha is not set
 # TARGET_arm is not set
+# TARGET_avr32 is not set
 # TARGET_bfin is not set
 # TARGET_cris is not set
 # TARGET_e1 is not set
index d54443a92bde75d9bf0bbcb0fe4390a5814cd97a..00256e9669eda4dc3eb73026f85080150397b91c 100644 (file)
@@ -10,6 +10,7 @@
 #
 # TARGET_alpha is not set
 # TARGET_arm is not set
+# TARGET_avr32 is not set
 # TARGET_bfin is not set
 # TARGET_cris is not set
 # TARGET_e1 is not set
index fc112ef2e39032a831e4da10ada5c2d9605b34a2..75785048b191f86fdcc190d674af7076b4156fc5 100644 (file)
@@ -3,6 +3,7 @@
 #
 # TARGET_alpha is not set
 # TARGET_arm is not set
+# TARGET_avr32 is not set
 # TARGET_bfin is not set
 # TARGET_cris is not set
 # TARGET_e1 is not set
diff --git a/toolchain/uClibc/patches/300-let-optimized-stringops-override-default-ones.patch b/toolchain/uClibc/patches/300-let-optimized-stringops-override-default-ones.patch
new file mode 100644 (file)
index 0000000..a383a6e
--- /dev/null
@@ -0,0 +1,28 @@
+From 7b2f125425cf777e7937b533217588e27952b87d Mon Sep 17 00:00:00 2001
+From: Haavard Skinnemoen <hskinnemoen@atmel.com>
+Date: Mon, 7 Aug 2006 11:12:50 +0200
+Subject: [PATCH] Let optimized stringops override default ones
+
+The default, slow stringops must be archived _before_ the optimized
+stringops if there is to be any point doing the optimizations in the
+first place.
+---
+ libc/Makefile |    2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+diff --git a/libc/Makefile b/libc/Makefile
+index 31e4bab..687eac5 100644
+--- a/libc/Makefile
++++ b/libc/Makefile
+@@ -59,7 +59,7 @@ # will evaluate to no files :(.
+       $(AR) dN 2 $(LIBNAME) $$objs && \
+       $(AR) dN 2 $(LIBNAME) $$objs
+       @for objfile in obj.signal \
+-                      obj.string.generic obj.string.$(TARGET_ARCH) obj.string \
++                      obj.string obj.string.generic obj.string.$(TARGET_ARCH) \
+                       obj.sysdeps.common obj.sysdeps.$(TARGET_ARCH) ; do \
+               if [ -e $$objfile ] ; then \
+                       if [ "$(MAKE_IS_SILENT)" = "n" ] ; then \
+-- 
+1.4.1.1
+
diff --git a/toolchain/uClibc/patches/301-fix-getrusage-argument-type.patch b/toolchain/uClibc/patches/301-fix-getrusage-argument-type.patch
new file mode 100644 (file)
index 0000000..d68576b
--- /dev/null
@@ -0,0 +1,19 @@
+Subject: [PATCH] Fix getrusage argument type
+
+The first argument to getrusage is of type __rusage_who_t, not int.
+This patch fixes that.
+---
+
+ libc/sysdeps/linux/common/getrusage.c |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+Index: uClibc-0.9.28/libc/sysdeps/linux/common/getrusage.c
+===================================================================
+--- uClibc-0.9.28.orig/libc/sysdeps/linux/common/getrusage.c   2006-02-07 17:18:22.000000000 +0100
++++ uClibc-0.9.28/libc/sysdeps/linux/common/getrusage.c        2006-02-07 17:18:31.000000000 +0100
+@@ -10,4 +10,4 @@
+ #include "syscalls.h"
+ #include <unistd.h>
+ #include <wait.h>
+-_syscall2(int, getrusage, int, who, struct rusage *, usage);
++_syscall2(int, getrusage, __rusage_who_t, who, struct rusage *, usage);
diff --git a/toolchain/uClibc/patches/302-fix-__libc_fcntl64-varargs-prototype.patch b/toolchain/uClibc/patches/302-fix-__libc_fcntl64-varargs-prototype.patch
new file mode 100644 (file)
index 0000000..3319f98
--- /dev/null
@@ -0,0 +1,24 @@
+Subject: [PATCH] Fix __libc_fcntl64 prototype in __syscall_fcntl.c
+
+__libc_fcntl64 is a varargs function and should be declared as such.
+Otherwise, the gcc compiler for AVR32, and perhaps other architectures,
+will use the wrong calling convention.
+
+---
+
+ libc/sysdeps/linux/common/__syscall_fcntl.c |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+Index: uClibc-0.9.28/libc/sysdeps/linux/common/__syscall_fcntl.c
+===================================================================
+--- uClibc-0.9.28.orig/libc/sysdeps/linux/common/__syscall_fcntl.c     2006-02-07 16:48:32.000000000 +0100
++++ uClibc-0.9.28/libc/sysdeps/linux/common/__syscall_fcntl.c  2006-02-07 17:19:09.000000000 +0100
+@@ -12,7 +12,7 @@
+ #include <fcntl.h>
+ #if defined __UCLIBC_HAS_LFS__ && defined __NR_fcntl64
+-extern int __libc_fcntl64(int fd, int cmd, long arg);
++extern int __libc_fcntl64(int fd, int cmd, ...);
+ #endif
+ #define __NR___syscall_fcntl __NR_fcntl
diff --git a/toolchain/uClibc/patches/303-fix-broken-__libc_open-declaration.patch b/toolchain/uClibc/patches/303-fix-broken-__libc_open-declaration.patch
new file mode 100644 (file)
index 0000000..aafdc8c
--- /dev/null
@@ -0,0 +1,30 @@
+From nobody Mon Sep 17 00:00:00 2001
+From: HÃ¥vard Skinnemoen <hskinnemoen@atmel.com>
+Date: Fri Apr 7 17:10:32 2006 +0200
+Subject: [PATCH] Fix broken __libc_open declaration in open64.c
+
+__libc_open is a vararg function and should therefore be declared as
+such. Fixes bug #4190.
+
+---
+
+ libc/sysdeps/linux/common/open64.c |    2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+70f2c81903327a8a346e370830932b80045ab04e
+diff --git a/libc/sysdeps/linux/common/open64.c b/libc/sysdeps/linux/common/open64.c
+index 543aa13..d9a27a7 100644
+--- a/libc/sysdeps/linux/common/open64.c
++++ b/libc/sysdeps/linux/common/open64.c
+@@ -26,7 +26,7 @@
+ #endif
+ #ifdef __UCLIBC_HAS_LFS__
+-extern int __libc_open (__const char *file, int oflag, mode_t mode);
++extern int __libc_open (__const char *file, int oflag, ...);
+ /* Open FILE with access OFLAG.  If OFLAG includes O_CREAT,
+    a third argument is the file protection.  */
+-- 
+1.2.4
+
diff --git a/toolchain/uClibc/patches/400-avr32-arch-2.patch b/toolchain/uClibc/patches/400-avr32-arch-2.patch
new file mode 100644 (file)
index 0000000..0e8c2a1
--- /dev/null
@@ -0,0 +1,2135 @@
+Subject: [PATCH] AVR32 Architecture support
+
+Add support for the AVR32 architecture in the core libc and build system.
+This also adds AVR32-ELF definitions to elf.h
+
+---
+
+ Rules.mak                                      |    4 
+ extra/Configs/Config.avr32                     |   38 +++++
+ extra/Configs/Config.in                        |    7 +
+ include/elf.h                                  |   51 +++++++
+ libc/sysdeps/linux/avr32/Makefile              |   93 +++++++++++++
+ libc/sysdeps/linux/avr32/__longjmp.S           |   17 ++
+ libc/sysdeps/linux/avr32/_mmap.c               |   33 ++++
+ libc/sysdeps/linux/avr32/bits/atomicity.h      |   86 ++++++++++++
+ libc/sysdeps/linux/avr32/bits/byteswap.h       |   80 +++++++++++
+ libc/sysdeps/linux/avr32/bits/endian.h         |    7 +
+ libc/sysdeps/linux/avr32/bits/fcntl.h          |  167 +++++++++++++++++++++++++
+ libc/sysdeps/linux/avr32/bits/kernel_stat.h    |   63 +++++++++
+ libc/sysdeps/linux/avr32/bits/kernel_types.h   |   56 ++++++++
+ libc/sysdeps/linux/avr32/bits/machine-gmon.h   |   69 ++++++++++
+ libc/sysdeps/linux/avr32/bits/mman.h           |   95 ++++++++++++++
+ libc/sysdeps/linux/avr32/bits/profil-counter.h |   26 +++
+ libc/sysdeps/linux/avr32/bits/setjmp.h         |   21 +++
+ libc/sysdeps/linux/avr32/bits/syscalls.h       |  143 +++++++++++++++++++++
+ libc/sysdeps/linux/avr32/bits/wordsize.h       |    1 
+ libc/sysdeps/linux/avr32/brk.c                 |   23 +++
+ libc/sysdeps/linux/avr32/bsd-_setjmp.S         |   12 +
+ libc/sysdeps/linux/avr32/bsd-setjmp.S          |   12 +
+ libc/sysdeps/linux/avr32/clone.c               |   37 +++++
+ libc/sysdeps/linux/avr32/crt1.S                |   93 +++++++++++++
+ libc/sysdeps/linux/avr32/crti.S                |   17 ++
+ libc/sysdeps/linux/avr32/crtn.S                |   14 ++
+ libc/sysdeps/linux/avr32/mmap.c                |   31 ++++
+ libc/sysdeps/linux/avr32/setjmp.S              |   43 ++++++
+ libc/sysdeps/linux/avr32/sigaction.c           |   49 +++++++
+ libc/sysdeps/linux/avr32/sigrestorer.S         |   11 +
+ libc/sysdeps/linux/avr32/sys/elf.h             |   26 +++
+ libc/sysdeps/linux/avr32/sys/io.h              |   48 +++++++
+ libc/sysdeps/linux/avr32/sys/procfs.h          |  123 ++++++++++++++++++
+ libc/sysdeps/linux/avr32/sys/ucontext.h        |   94 ++++++++++++++
+ libc/sysdeps/linux/avr32/sys/user.h            |   46 ++++++
+ libc/sysdeps/linux/avr32/syscall.S             |   81 ++++++++++++
+ libc/sysdeps/linux/avr32/vfork.S               |   55 ++++++++
+ 37 files changed, 1872 insertions(+)
+
+Index: uClibc-0.9.28/extra/Configs/Config.avr32
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/extra/Configs/Config.avr32   2006-05-05 09:27:17.000000000 +0200
+@@ -0,0 +1,38 @@
++#
++# For a description of the syntax of this configuration file,
++# see extra/config/Kconfig-language.txt
++#
++
++config HAVE_ELF
++      bool
++      default y
++
++config TARGET_ARCH
++      default "avr32"
++
++config ARCH_CFLAGS
++      string
++
++config ARCH_LDFLAGS
++      string
++
++config LIBGCC_CFLAGS
++      string
++
++config ARCH_SUPPORTS_BIG_ENDIAN
++      bool
++      default y
++
++config UCLIBC_COMPLETELY_PIC
++      select FORCE_SHAREABLE_TEXT_SEGMENTS
++      bool
++      default y
++
++choice
++      prompt "Target CPU Type"
++      default CONFIG_AP7000
++
++config CONFIG_AP7000
++      bool "AP7000"
++
++endchoice
+Index: uClibc-0.9.28/extra/Configs/Config.in
+===================================================================
+--- uClibc-0.9.28.orig/extra/Configs/Config.in 2006-04-19 12:47:48.000000000 +0200
++++ uClibc-0.9.28/extra/Configs/Config.in      2006-04-19 12:48:33.000000000 +0200
+@@ -16,6 +16,9 @@ config TARGET_alpha
+ config TARGET_arm
+       bool "arm"
++config TARGET_avr32
++      bool "avr32"
++
+ config TARGET_bfin
+       bool "bfin"
+@@ -83,6 +86,10 @@ if TARGET_arm
+ source "extra/Configs/Config.arm"
+ endif
++if TARGET_avr32
++source "extra/Configs/Config.avr32"
++endif
++
+ if TARGET_bfin
+ source "extra/Configs/Config.bfin"
+ endif
+Index: uClibc-0.9.28/include/elf.h
+===================================================================
+--- uClibc-0.9.28.orig/include/elf.h   2006-04-19 12:47:48.000000000 +0200
++++ uClibc-0.9.28/include/elf.h        2006-05-05 09:28:38.000000000 +0200
+@@ -261,6 +261,8 @@ typedef struct
+ #define EM_NIOS32     0xfebb          /* Altera Nios 32 */
+ #define EM_ALTERA_NIOS2  0x9ee5       /* Altera Nios II */
++#define EM_AVR32      0x18ad
++
+ /* V850 backend magic number.  Written in the absense of an ABI.  */
+ #define EM_CYGNUS_V850 0x9080
+@@ -2687,6 +2689,55 @@ typedef Elf32_Addr Elf32_Conflict;
+ /* Keep this the last entry.  */
+ #define R_V850_NUM            25
++/* Atmel AVR32 relocations.  */
++#define R_AVR32_NONE          0
++#define R_AVR32_32            1
++#define R_AVR32_16            2
++#define R_AVR32_8             3
++#define R_AVR32_32_PCREL      4
++#define R_AVR32_16_PCREL      5
++#define R_AVR32_8_PCREL               6
++#define R_AVR32_DIFF32                7
++#define R_AVR32_DIFF16                8
++#define R_AVR32_DIFF8         9
++#define R_AVR32_GOT32         10
++#define R_AVR32_GOT16         11
++#define R_AVR32_GOT8          12
++#define R_AVR32_21S           13
++#define R_AVR32_16U           14
++#define R_AVR32_16S           15
++#define R_AVR32_8S            16
++#define R_AVR32_8S_EXT                17
++#define R_AVR32_22H_PCREL     18
++#define R_AVR32_18W_PCREL     19
++#define R_AVR32_16B_PCREL     20
++#define R_AVR32_16N_PCREL     21
++#define R_AVR32_14UW_PCREL    22
++#define R_AVR32_11H_PCREL     23
++#define R_AVR32_10UW_PCREL    24
++#define R_AVR32_9H_PCREL      25
++#define R_AVR32_9UW_PCREL     26
++#define R_AVR32_HI16          27
++#define R_AVR32_LO16          28
++#define R_AVR32_GOTPC         29
++#define R_AVR32_GOTCALL               30
++#define R_AVR32_LDA_GOT               31
++#define R_AVR32_GOT21S                32
++#define R_AVR32_GOT18SW               33
++#define R_AVR32_GOT16S                34
++#define R_AVR32_GOT7UW                35
++#define R_AVR32_32_CPENT      36
++#define R_AVR32_CPCALL                37
++#define R_AVR32_16_CP         38
++#define R_AVR32_9W_CP         39
++#define R_AVR32_RELATIVE      40
++#define R_AVR32_GLOB_DAT      41
++#define R_AVR32_JMP_SLOT      42
++#define R_AVR32_ALIGN         43
++#define R_AVR32_NUM           44
++
++/* AVR32 dynamic tags */
++#define DT_AVR32_GOTSZ                0x70000001 /* Total size of GOT in bytes */
+ #define R_H8_NONE       0
+ #define R_H8_DIR32      1
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/Makefile
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/Makefile    2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,93 @@
++# Makefile for uClibc
++#
++# Copyright (C) 2000-2003 Erik Andersen <andersen@uclibc.org>
++#
++# This program is free software; you can redistribute it and/or modify it under
++# the terms of the GNU Library General Public License as published by the Free
++# Software Foundation; either version 2 of the License, or (at your option) any
++# later version.
++#
++# This program is distributed in the hope that it will be useful, but WITHOUT
++# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++# FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more
++# details.
++#
++# You should have received a copy of the GNU Library General Public License
++# along with this program; if not, write to the Free Software Foundation, Inc.,
++# 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++
++TOPDIR=../../../../
++include $(TOPDIR)Rules.mak
++ASFLAGS=$(CFLAGS)
++
++CRT_SRC       = crt1.S
++CRT_OBJ = crt1.o
++SCRT_OBJ = $(patsubst %,S%, $(CRT_OBJ))
++CTOR_TARGETS=$(TOPDIR)lib/crti.o $(TOPDIR)lib/crtn.o
++
++SSRC=__longjmp.S setjmp.S bsd-setjmp.S vfork.S \
++      bsd-_setjmp.S sigrestorer.S syscall.S
++SOBJS=$(patsubst %.S,%.o, $(SSRC))
++
++CSRC=clone.c brk.c sigaction.c mmap.c
++COBJS=$(patsubst %.c,%.o, $(CSRC))
++
++OBJS=$(SOBJS) $(COBJS)
++
++OBJ_LIST=../../../obj.sysdeps.$(TARGET_ARCH)
++
++all: $(OBJ_LIST)
++
++$(OBJ_LIST): $(OBJS) $(CRT_OBJ) $(SCRT_OBJ) $(CTOR_TARGETS)
++      echo $(patsubst %, sysdeps/linux/$(TARGET_ARCH)/%, $(OBJS)) > $(OBJ_LIST)
++      $(INSTALL) -d $(TOPDIR)lib/
++      cp $(CRT_OBJ) $(SCRT_OBJ) $(TOPDIR)lib/
++
++$(CRT_OBJ): $(CRT_SRC)
++      $(CC) $(ASFLAGS) -DL_$* $< -c -o $*.o
++      $(STRIPTOOL) -x -R .note -R .comment $*.o
++
++$(SCRT_OBJ): $(CRT_SRC)
++      $(CC) $(ASFLAGS) $(PIEFLAG) -DL_$* $< -c -o $*.o
++      $(STRIPTOOL) -x -R .note -R .comment $*.o
++
++$(SOBJS): %.o : %.S
++      $(CC) $(ASFLAGS) -c $< -o $@
++      $(STRIPTOOL) -x -R .note -R .comment $*.o
++
++$(COBJS): %.o : %.c
++      $(CC) $(CFLAGS) -c $< -o $@
++      $(STRIPTOOL) -x -R .note -R .comment $*.o
++
++ifeq ($(strip $(UCLIBC_CTOR_DTOR)),y)
++crti.o: crti.S
++      $(CC) $(ASFLAGS) -c crti.S -o crti.o
++
++$(TOPDIR)lib/crti.o: crti.o
++      $(INSTALL) -d $(TOPDIR)lib/
++      cp crti.o $(TOPDIR)lib/
++
++crtn.o: crtn.S
++      $(CC) $(ASFLAGS) -c crtn.S -o crtn.o
++
++$(TOPDIR)lib/crtn.o: crtn.o
++      $(INSTALL) -d $(TOPDIR)lib/
++      cp crtn.o $(TOPDIR)lib/
++else
++$(TOPDIR)lib/crti.o:
++      $(INSTALL) -d $(TOPDIR)lib/
++      $(AR) $(ARFLAGS) $(TOPDIR)lib/crti.o
++$(TOPDIR)lib/crtn.o:
++      $(INSTALL) -d $(TOPDIR)lib/
++      $(AR) $(ARFLAGS) $(TOPDIR)lib/crtn.o
++endif
++
++
++headers:
++#     $(LN) -fs ../libc/sysdeps/linux/avr32/fpu_control.h $(TOPDIR)/include/
++
++clean:
++      $(RM) *.[oa] *~ core
++      $(RM) bits/sysnum.h
++      $(RM) gmon-start.S
++
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/__longjmp.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/__longjmp.S 2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,17 @@
++/* longjmp for AVR32
++ *
++ * Copyright (C) 2004 Atmel Norway AS
++ */
++
++      .global __longjmp
++      .type   __longjmp,"function"
++      .align  1
++__longjmp:
++      ldm     r12++, r0,r1,r2,r3,r4,r5,r6,r7,r8,sp,lr
++      mov     r12, r11        /* get the return value right */
++      mustr   r8              /* restore status register (lower half) */
++      cp      r12, 0          /* can't return zero */
++      frs
++      moveq   r12, 1
++      mov     pc,lr
++      .size   __longjmp, . - __longjmp
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/_mmap.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/_mmap.c     2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,33 @@
++/* Copyright (C) 2005 Atmel Norway
++
++   This program is free software; you can redistribute it and/or modify it under
++   the terms of the GNU Library General Public License as published by the Free
++   Software Foundation; either version 2 of the License, or (at your option) any
++   later version.
++
++   This program is distributed in the hope that it will be useful, but WITHOUT
++   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++   FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more
++   details.
++
++   You should have received a copy of the GNU Library General Public License
++   along with this program; if not, write to the Free Software Foundation, Inc.,
++   59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++
++   Derived in part from the Linux-8086 C library, the GNU C Library, and several
++   other sundry sources.  Files within this library are copyright by their
++   respective copyright holders.
++ */
++
++#include <errno.h>
++#include <sys/mman.h>
++#include <sys/syscall.h>
++
++#define __NR_mmap2 __NR_mmap
++
++static _syscall6(__ptr_t, mmap2, __ptr_t, addr, size_t, len, int, prot, int, flags, int, fd, __off_t, pgoff);
++
++__ptr_t mmap(__ptr_t addr, size_t len, int prot, int flags, int fd, __off_t offset)
++{
++      return mmap2(addr, len, prot, flags, fd, offset >> 12);
++}
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/atomicity.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/atomicity.h    2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,86 @@
++/* Low-level functions for atomic operations.  AVR32 version.
++   Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++#ifndef _ATOMICITY_H
++#define _ATOMICITY_H 1
++
++#include <inttypes.h>
++
++static inline int
++__attribute__((unused))
++exchange_and_add (volatile uint32_t *mem, int val)
++{
++      int tmp, result;
++
++      __asm__ __volatile__(
++              "/* Inline exchange and add */\n"
++              "1:     ssrf    5\n"
++              "       ld.w    %0, %3\n"
++              "       add     %1, %0, %4\n"
++              "       stcond  %2, %1\n"
++              "       brne    1b"
++              : "=&r"(result), "=&r"(tmp), "=m"(*mem)
++              : "m"(*mem), "r"(val)
++              : "cc", "memory");
++
++      return result;
++}
++
++static inline void
++__attribute__((unused))
++atomic_add (volatile uin32_t *mem, int val)
++{
++      int result;
++
++      __asm__ __volatile__(
++              "/* Inline atomic add */\n"
++              "1:     ssrf    5\n"
++              "       ld.w    %0, %2\n"
++              "       add     %0, %3\n"
++              "       stcond  %2, %0\n"
++              "       brne    1b"
++              : "=&r"(result), "=m"(*mem)
++              : "m"(*mem), "r"(val)
++              : "cc", "memory");
++}
++
++static inline int
++__attribute__((unused))
++compare_and_swap(volatile long int *p, long int oldval, long int newval)
++{
++      long int result, tmp;
++
++      __asm__ __volatile__(
++              "/* Inline compare and swap */\n"
++              "1:     ssrf    5\n"
++              "       ld.w    %1, %3\n"
++              "       cp.w    %1, %5\n"
++              "       sreq    %0\n"
++              "       brne    2f\n"
++              "       stcond  %2, %4\n"
++              "       brne    1b\n"
++              "2:"
++              : "=&r"(result), "=&r"(tmp), "=m"(*p)
++              : "m"(*p), "r"(newval), "r"(oldval)
++              : "cc", "memory");
++
++      return result;
++}
++
++#endif /* atomicity.h */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/byteswap.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/byteswap.h     2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,80 @@
++/* Macros to swap the order of bytes in integer values.
++   Copyright (C) 2005 Atmel Norway.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++#if !defined _BYTESWAP_H && !defined _NETINET_IN_H
++# error "Never use <bits/byteswap.h> directly; include <byteswap.h> instead."
++#endif
++
++#ifndef _BITS_BYTESWAP_H
++#define _BITS_BYTESWAP_H 1
++
++/* Swap bytes in 16 bit value.  */
++#if defined __GNUC__
++# define __bswap_16(x) (__extension__ __builtin_bswap_16(x))
++#else
++/* This is better than nothing.  */
++static __inline unsigned short int
++__bswap_16 (unsigned short int __bsx)
++{
++      return ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8));
++}
++#endif
++
++/* Swap bytes in 32 bit value.  */
++#if defined __GNUC__
++# define __bswap_32(x) (__extension__ __builtin_bswap_32(x))
++#else
++static __inline unsigned int
++__bswap_32 (unsigned int __bsx)
++{
++  return ((((__bsx) & 0xff000000) >> 24) | (((__bsx) & 0x00ff0000) >>  8) |
++        (((__bsx) & 0x0000ff00) <<  8) | (((__bsx) & 0x000000ff) << 24));
++}
++#endif
++
++#if defined __GNUC__
++/* Swap bytes in 64 bit value.  */
++# define __bswap_constant_64(x)                               \
++      ((((x) & 0xff00000000000000ull) >> 56)          \
++       | (((x) & 0x00ff000000000000ull) >> 40)        \
++       | (((x) & 0x0000ff0000000000ull) >> 24)        \
++       | (((x) & 0x000000ff00000000ull) >> 8)         \
++       | (((x) & 0x00000000ff000000ull) << 8)         \
++       | (((x) & 0x0000000000ff0000ull) << 24)        \
++       | (((x) & 0x000000000000ff00ull) << 40)        \
++       | (((x) & 0x00000000000000ffull) << 56))
++
++# define __bswap_64(x)                                                        \
++      (__extension__                                                  \
++       ({                                                             \
++               union {                                                \
++                       __extension__ unsigned long long int __ll;     \
++                       unsigned int __l[2];                           \
++               } __w, __r;                                            \
++               if (__builtin_constant_p(x))                           \
++                       __r.__ll = __bswap_constant_64(x);             \
++               else {                                                 \
++                       __w.__ll = (x);                                \
++                       __r.__l[0] = __bswap_32(__w.__l[1]);           \
++                       __r.__l[1] = __bswap_32(__w.__l[0]);           \
++               }                                                      \
++               __r.__ll;                                              \
++       }))
++#endif
++
++#endif /* _BITS_BYTESWAP_H */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/endian.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/endian.h       2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,7 @@
++/* AVR32 is big-endian */
++
++#ifndef _ENDIAN_H
++# error "Never use <bits/endian.h> directly; include <endian.h> instead."
++#endif
++
++#define __BYTE_ORDER __BIG_ENDIAN
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/fcntl.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/fcntl.h        2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,167 @@
++/*
++ * Copyright (C) 2004 Atmel Norway AS
++ *
++ * This file is part of the Linux kernel
++ */
++#ifndef _FCNTL_H
++# error "Never use <bits/fcntl.h> directly; include <fcntl.h> instead."
++#endif
++
++#include <sys/types.h>
++
++/* open/fcntl - O_SYNC is only implemented on blocks devices and on files
++   located on an ext2 file system */
++#define O_ACCMODE       0003
++#define O_RDONLY          00
++#define O_WRONLY          01
++#define O_RDWR                    02
++#define O_CREAT                 0100  /* not fcntl */
++#define O_EXCL                  0200  /* not fcntl */
++#define O_NOCTTY        0400  /* not fcntl */
++#define O_TRUNC                01000  /* not fcntl */
++#define O_APPEND       02000
++#define O_NONBLOCK     04000
++#define O_NDELAY      O_NONBLOCK
++#define O_SYNC                010000
++#define O_ASYNC               020000
++
++#ifdef __USE_GNU
++# define O_DIRECTORY  040000  /* must be a directory */
++# define O_NOFOLLOW   0100000 /* don't follow links */
++# define O_DIRECT     0200000 /* direct disk access */
++#endif
++
++#ifdef __USE_LARGEFILE64
++# define O_LARGEFILE  0400000
++#endif
++
++/* For now Linux has synchronisity options for data and read operations.
++   We define the symbols here but let them do the same as O_SYNC since
++   this is a superset.        */
++#if defined __USE_POSIX199309 || defined __USE_UNIX98
++# define O_DSYNC      O_SYNC  /* Synchronize data.  */
++# define O_RSYNC      O_SYNC  /* Synchronize read operations.  */
++#endif
++
++#define F_DUPFD               0       /* dup */
++#define F_GETFD               1       /* get close_on_exec */
++#define F_SETFD               2       /* set/clear close_on_exec */
++#define F_GETFL               3       /* get file->f_flags */
++#define F_SETFL               4       /* set file->f_flags */
++
++#ifndef __USE_FILE_OFFSET64
++# define F_GETLK      5
++# define F_SETLK      6
++# define F_SETLKW     7
++#else
++# define F_GETLK      F_GETLK64
++# define F_SETLK      F_SETLK64
++# define F_SETLKW     F_SETLKW64
++#endif
++#define F_GETLK64     12      /*  using 'struct flock64' */
++#define F_SETLK64     13
++#define F_SETLKW64    14
++
++#if defined __USE_BSD || defined __USE_XOPEN2K
++# define F_SETOWN     8       /*  for sockets. */
++# define F_GETOWN     9       /*  for sockets. */
++#endif
++
++#ifdef __USE_GNU
++# define F_SETSIG     10      /*  for sockets. */
++# define F_GETSIG     11      /*  for sockets. */
++#endif
++
++#ifdef __USE_GNU
++# define F_SETLEASE   1024    /* Set a lease.  */
++# define F_GETLEASE   1025    /* Enquire what lease is active.  */
++# define F_NOTIFY     1026    /* Request notfications on a directory.  */
++#endif
++
++/* for F_[GET|SET]FL */
++#define FD_CLOEXEC    1       /* actually anything with low bit set goes */
++
++/* for posix fcntl() and lockf() */
++#define F_RDLCK               0
++#define F_WRLCK               1
++#define F_UNLCK               2
++
++/* for old implementation of bsd flock () */
++#define F_EXLCK               4       /* or 3 */
++#define F_SHLCK               8       /* or 4 */
++
++/* for leases */
++#define F_INPROGRESS  16
++
++#ifdef __USE_BSD
++/* operations for bsd flock(), also used by the kernel implementation */
++# define LOCK_SH      1       /* shared lock */
++# define LOCK_EX      2       /* exclusive lock */
++# define LOCK_NB      4       /* or'd with one of the above to prevent
++                                 blocking */
++# define LOCK_UN      8       /* remove lock */
++#endif
++
++#ifdef __USE_GNU
++# define LOCK_MAND    32      /* This is a mandatory flock */
++# define LOCK_READ    64      /* ... Which allows concurrent
++                                     read operations */
++# define LOCK_WRITE   128     /* ... Which allows concurrent
++                                     write operations */
++# define LOCK_RW      192     /* ... Which allows concurrent
++                                     read & write ops */
++#endif
++
++#ifdef __USE_GNU
++/* Types of directory notifications that may be requested with F_NOTIFY.  */
++# define DN_ACCESS    0x00000001      /* File accessed.  */
++# define DN_MODIFY    0x00000002      /* File modified.  */
++# define DN_CREATE    0x00000004      /* File created.  */
++# define DN_DELETE    0x00000008      /* File removed.  */
++# define DN_RENAME    0x00000010      /* File renamed.  */
++# define DN_ATTRIB    0x00000020      /* File changed attibutes.  */
++# define DN_MULTISHOT 0x80000000      /* Don't remove notifier.  */
++#endif
++
++struct flock {
++      short l_type;
++      short l_whence;
++#ifndef __USE_FILE_OFFSET64
++      __off_t l_start;
++      __off_t l_len;
++#else
++      __off64_t l_start;
++      __off64_t l_len;
++#endif
++      __pid_t l_pid;
++};
++
++#ifdef __USE_LARGEFILE64
++struct flock64 {
++      short  l_type;
++      short  l_whence;
++      __off64_t l_start;
++      __off64_t l_len;
++      __pid_t  l_pid;
++};
++#endif
++
++/* Define some more compatibility macros to be backward compatible with
++ *    BSD systems which did not managed to hide these kernel macros.  */
++#ifdef  __USE_BSD
++# define FAPPEND        O_APPEND
++# define FFSYNC         O_FSYNC
++# define FASYNC         O_ASYNC
++# define FNONBLOCK      O_NONBLOCK
++# define FNDELAY        O_NDELAY
++#endif /* Use BSD.  */
++
++/* Advise to `posix_fadvise'.  */
++#ifdef __USE_XOPEN2K
++# define POSIX_FADV_NORMAL      0 /* No further special treatment.  */
++# define POSIX_FADV_RANDOM      1 /* Expect random page references.  */
++# define POSIX_FADV_SEQUENTIAL  2 /* Expect sequential page references.  */
++# define POSIX_FADV_WILLNEED    3 /* Will need these pages.  */
++# define POSIX_FADV_DONTNEED    4 /* Don't need these pages.  */
++# define POSIX_FADV_NOREUSE     5 /* Data will be accessed once.  */
++#endif
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/kernel_stat.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/kernel_stat.h  2006-05-05 09:28:32.000000000 +0200
+@@ -0,0 +1,63 @@
++#ifndef _BITS_STAT_STRUCT_H
++#define _BITS_STAT_STRUCT_H
++
++/*
++ * This file provides struct stat, taken from kernel 2.6.4
++ * (include/asm-avr32/stat.h revision 1.1).
++ */
++
++struct kernel_stat {
++        unsigned long st_dev;
++        unsigned long st_ino;
++        unsigned short st_mode;
++        unsigned short st_nlink;
++        unsigned short st_uid;
++        unsigned short st_gid;
++        unsigned long  st_rdev;
++        unsigned long  st_size;
++        unsigned long  st_blksize;
++        unsigned long  st_blocks;
++        unsigned long  st_atime;
++        unsigned long  st_atime_nsec;
++        unsigned long  st_mtime;
++        unsigned long  st_mtime_nsec;
++        unsigned long  st_ctime;
++        unsigned long  st_ctime_nsec;
++        unsigned long  __unused4;
++        unsigned long  __unused5;
++};
++
++#define STAT_HAVE_NSEC 1
++
++struct kernel_stat64 {
++      unsigned long long st_dev;
++
++      unsigned long long st_ino;
++      unsigned int    st_mode;
++      unsigned int    st_nlink;
++
++      unsigned long   st_uid;
++      unsigned long   st_gid;
++
++      unsigned long long st_rdev;
++
++      long long       st_size;
++      unsigned long   __pad1;
++      unsigned long   st_blksize;
++
++      unsigned long long st_blocks;
++
++      unsigned long   st_atime;
++      unsigned long   st_atime_nsec;
++
++      unsigned long   st_mtime;
++      unsigned long   st_mtime_nsec;
++
++      unsigned long   st_ctime;
++      unsigned long   st_ctime_nsec;
++
++      unsigned long   __unused1;
++      unsigned long   __unused2;
++};
++
++#endif /* _BITS_STAT_STRUCT_H */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/kernel_types.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/kernel_types.h 2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,56 @@
++/* Note that we use the exact same include guard #define names
++ * as asm/posix_types.h.  This will avoid gratuitous conflicts
++ * with the posix_types.h kernel header, and will ensure that
++ * our private content, and not the kernel header, will win.
++ *  -Erik
++ */
++#ifndef __ASM_AVR32_POSIX_TYPES_H
++#define __ASM_AVR32_POSIX_TYPES_H
++
++/*
++ * This file is generally used by user-level software, so you need to
++ * be a little careful about namespace pollution etc.  Also, we cannot
++ * assume GCC is being used.
++ */
++
++typedef unsigned long __kernel_dev_t;
++typedef unsigned long   __kernel_ino_t;
++typedef unsigned short  __kernel_mode_t;
++typedef unsigned short  __kernel_nlink_t;
++typedef long            __kernel_off_t;
++typedef int             __kernel_pid_t;
++typedef unsigned short  __kernel_ipc_pid_t;
++typedef unsigned int  __kernel_uid_t;
++typedef unsigned int  __kernel_gid_t;
++typedef unsigned long __kernel_size_t;
++typedef int             __kernel_ssize_t;
++typedef int             __kernel_ptrdiff_t;
++typedef long            __kernel_time_t;
++typedef long            __kernel_suseconds_t;
++typedef long            __kernel_clock_t;
++typedef int             __kernel_timer_t;
++typedef int             __kernel_clockid_t;
++typedef int             __kernel_daddr_t;
++typedef char *          __kernel_caddr_t;
++typedef unsigned short  __kernel_uid16_t;
++typedef unsigned short  __kernel_gid16_t;
++typedef unsigned int    __kernel_uid32_t;
++typedef unsigned int    __kernel_gid32_t;
++
++typedef unsigned short  __kernel_old_uid_t;
++typedef unsigned short  __kernel_old_gid_t;
++typedef unsigned short  __kernel_old_dev_t;
++
++#ifdef __GNUC__
++typedef long long       __kernel_loff_t;
++#endif
++
++typedef struct {
++#if defined(__USE_ALL)
++    int     val[2];
++#else
++    int     __val[2];
++#endif
++} __kernel_fsid_t;
++
++#endif /* __ASM_AVR32_POSIX_TYPES_H */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/machine-gmon.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/machine-gmon.h 2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,69 @@
++/* Machine-dependent definitions for profiling support.  AVR32 version.
++   Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++#define mcount_internal __mcount_internal
++
++#define _MCOUNT_DECL(frompc, selfpc) \
++static void __attribute((used)) mcount_internal(unsigned long frompc, unsigned long selfpc)
++
++/*
++ * This mcount implementation expects to get called after the prologue
++ * has been run. It also expects that r7 contains a valid frame
++ * pointer.
++ *
++ * When profiling, the compiler should generate something like this at
++ * each function entry:
++ *
++ *    pushm   r0-r7,lr        // lr mandatory, others optional
++ *    mov     r7, sp
++ *    // rest of prologue goes here
++ *    mcall   pc[.LC1 - .]
++ *      // rest of function goes here
++ * .LC1:
++ *    .long   mcount
++ *
++ * or for PIC:
++ *
++ *    pushm   r0-r7,lr
++ *    mov     r7, sp
++ *    // rest of prologue goes here
++ *    lddpc   r0, .LC1
++ * .L1: rsub  r0, pc
++ *    mcall   r0[mcount@GOT]
++ *    // rest of function goes here
++ * .LC1:
++ *    .long   .L1 - _GLOBAL_OFFSET_TABLE_
++ *
++ * This way, when mcount() is called, r7 points to the calling
++ * function's return address. It is guaranteed that calling mcount
++ * will clobber no registers except LR, which is unavoidable.
++ */
++#define MCOUNT asm(                           \
++      "       .align  4\n"                    \
++      "       .global _mcount\n"              \
++      "       .type   _mcount,@function\n"    \
++      "_mcount:\n"                            \
++      "       pushm   r8-r12,lr\n"            \
++      "       mov     r11, lr\n"              \
++      "       ld.w    r12, r7[0]\n"           \
++      "       rcall   __mcount_internal\n"    \
++      "       popm    r8-r12,pc\n"            \
++      "       .size   _mcount, . - _mcount\n" \
++      "       .weak   mcount\n"               \
++      "       mcount = _mcount");
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/mman.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/mman.h 2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,95 @@
++/* Definitions for POSIX memory map interface.  Linux/AVR32 version.
++   Copyright (C) 1997, 2000 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++#ifndef _SYS_MMAN_H
++# error "Never include this file directly.  Use <sys/mman.h> instead"
++#endif
++
++/* The following definitions basically come from the kernel headers.
++   But the kernel header is not namespace clean.  */
++
++
++/* Protections are chosen from these bits, OR'd together.  The
++   implementation does not necessarily support PROT_EXEC or PROT_WRITE
++   without PROT_READ.  The only guarantees are that no writing will be
++   allowed without PROT_WRITE and no access will be allowed for PROT_NONE. */
++
++#define PROT_READ     0x1             /* Page can be read.  */
++#define PROT_WRITE    0x2             /* Page can be written.  */
++#define PROT_EXEC     0x4             /* Page can be executed.  */
++#define PROT_NONE     0x0             /* Page can not be accessed.  */
++
++/* Sharing types (must choose one and only one of these).  */
++#define MAP_SHARED    0x01            /* Share changes.  */
++#define MAP_PRIVATE   0x02            /* Changes are private.  */
++#ifdef __USE_MISC
++# define MAP_TYPE     0x0f            /* Mask for type of mapping.  */
++#endif
++
++/* Other flags.  */
++#define MAP_FIXED     0x10            /* Interpret addr exactly.  */
++#ifdef __USE_MISC
++# define MAP_FILE     0
++# define MAP_ANONYMOUS        0x20            /* Don't use a file.  */
++# define MAP_ANON     MAP_ANONYMOUS
++#endif
++
++/* These are Linux-specific.  */
++#ifdef __USE_MISC
++# define MAP_GROWSDOWN        0x0100          /* Stack-like segment.  */
++# define MAP_DENYWRITE        0x0800          /* ETXTBSY */
++# define MAP_EXECUTABLE       0x1000          /* Mark it as an executable.  */
++# define MAP_LOCKED   0x2000          /* Lock the mapping.  */
++# define MAP_NORESERVE        0x4000          /* Don't check for reservations.  */
++# define MAP_POPULATE 0x8000          /* populate (prefault) pagetables */
++# define MAP_NONBLOCK 0x10000         /* do not block on IO */
++#endif
++
++/* Flags to `msync'.  */
++#define MS_ASYNC      1               /* Sync memory asynchronously.  */
++#define MS_SYNC               4               /* Synchronous memory sync.  */
++#define MS_INVALIDATE 2               /* Invalidate the caches.  */
++
++/* Flags for `mlockall'.  */
++#define MCL_CURRENT   1               /* Lock all currently mapped pages.  */
++#define MCL_FUTURE    2               /* Lock all additions to address
++                                         space.  */
++
++/* Flags for `mremap'.  */
++#ifdef __USE_GNU
++# define MREMAP_MAYMOVE       1
++#endif
++
++/* Advise to `madvise'.  */
++#ifdef __USE_BSD
++# define MADV_NORMAL   0      /* No further special treatment.  */
++# define MADV_RANDOM   1      /* Expect random page references.  */
++# define MADV_SEQUENTIAL 2    /* Expect sequential page references.  */
++# define MADV_WILLNEED         3      /* Will need these pages.  */
++# define MADV_DONTNEED         4      /* Don't need these pages.  */
++#endif
++
++/* The POSIX people had to invent similar names for the same things.  */
++#ifdef __USE_XOPEN2K
++# define POSIX_MADV_NORMAL    0 /* No further special treatment.  */
++# define POSIX_MADV_RANDOM    1 /* Expect random page references.  */
++# define POSIX_MADV_SEQUENTIAL        2 /* Expect sequential page references.  */
++# define POSIX_MADV_WILLNEED  3 /* Will need these pages.  */
++# define POSIX_MADV_DONTNEED  4 /* Don't need these pages.  */
++#endif
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/profil-counter.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/profil-counter.h       2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,26 @@
++/* Low-level statistical profiling support function.  Linux/AVR32 version.
++   Copyright (C) 1996, 1997, 1998, 2002 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++#include <signal.h>
++
++void
++profil_counter(int signo, siginfo_t *si, struct sigcontext *sc)
++{
++      profil_count((void *)sc->pc);
++}
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/setjmp.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/setjmp.h       2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,21 @@
++/*
++ * Copyright (C) 2004-2005 Atmel Norway
++ */
++#ifndef _SETJMP_H
++# error "Never include <bits/setjmp.h> directly; use <setjmp.h> instead."
++#endif
++
++#ifndef _ASM
++/*
++ * The jump buffer contains r0-r7, sr, sp and lr. Other registers are
++ * not saved.
++ */
++typedef int __jmp_buf[11];
++#endif
++
++#define __JMP_BUF_SP  4
++
++/* Test if longjmp to JMPBUF would unwind the frame containing a local
++   variable at ADDRESS.  */
++#define _JMPBUF_UNWINDS(jmpbuf, address) \
++  ((void *)(address) < (void *)(jmpbuf[__JMP_BUF_SP]))
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/syscalls.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/syscalls.h     2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,143 @@
++#ifndef _SYSCALL_H
++# error "Never use <bits/syscalls.h> directly; include <sys/syscall.h> instead."
++#endif
++
++/*
++ * This includes the `__NR_<name>' syscall numbers taken from the
++ * Linux kernel header files. It also defines the traditional
++ * `SYS_<name>' macros for older programs.
++ */
++#include <bits/sysnum.h>
++
++#ifndef __set_errno
++# define __set_errno(val) (*__errno_location()) = (val)
++#endif
++#ifndef SYS_ify
++# define SYS_ify(syscall_name) (__NR_##syscall_name)
++#endif
++
++#ifndef __ASSEMBLER__
++
++#undef _syscall0
++#define _syscall0(type,name)                          \
++      type name(void)                                 \
++      {                                               \
++              return (type)(INLINE_SYSCALL(name, 0)); \
++      }
++
++#undef _syscall1
++#define _syscall1(type,name,type1,arg1)                               \
++      type name(type1 arg1)                                   \
++      {                                                       \
++              return (type)(INLINE_SYSCALL(name, 1, arg1));   \
++      }
++
++#undef _syscall2
++#define _syscall2(type,name,type1,arg1,type2,arg2)                    \
++      type name(type1 arg1, type2 arg2)                               \
++      {                                                               \
++              return (type)(INLINE_SYSCALL(name, 2, arg1, arg2));     \
++      }
++
++#undef _syscall3
++#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)         \
++      type name(type1 arg1, type2 arg2, type3 arg3)                   \
++      {                                                               \
++              return (type)(INLINE_SYSCALL(name, 3, arg1,             \
++                                           arg2, arg3));              \
++      }
++
++#undef _syscall4
++#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,         \
++                type4,arg4)                                           \
++      type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4)       \
++      {                                                               \
++              return (type)(INLINE_SYSCALL(name, 4, arg1, arg2,       \
++                                           arg3, arg4));              \
++      }
++
++#undef _syscall5
++#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,         \
++                type4,arg4,type5,arg5)                                \
++      type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4,       \
++                type5 arg5)                                           \
++      {                                                               \
++              return (type)(INLINE_SYSCALL(name, 5, arg1, arg2,       \
++                                           arg3, arg4, arg5));        \
++      }
++
++#undef _syscall6
++#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,         \
++                type4,arg4,type5,arg5,type6,arg6)                     \
++      type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4,       \
++                type5 arg5, type6 arg6)                               \
++      {                                                               \
++              return (type)(INLINE_SYSCALL(name, 6, arg1, arg2, arg3, \
++                                           arg4, arg5, arg6));        \
++      }
++
++#undef unlikely
++#define unlikely(x) __builtin_expect((x), 0)
++
++#undef INLINE_SYSCALL
++#define INLINE_SYSCALL(name, nr, args...)                             \
++      ({                                                              \
++              unsigned _sys_result = INTERNAL_SYSCALL(name, , nr, args); \
++              if (unlikely(INTERNAL_SYSCALL_ERROR_P(_sys_result, ))) { \
++                      __set_errno(INTERNAL_SYSCALL_ERRNO(_sys_result, )); \
++                      _sys_result = (unsigned int) -1;                \
++              }                                                       \
++              (int) _sys_result;                                      \
++      })
++
++#undef INTERNAL_SYSCALL_DECL
++#define INTERNAL_SYSCALL_DECL(err) do { } while(0)
++
++#undef INTERNAL_SYSCALL
++#define INTERNAL_SYSCALL(name, err, nr, args...)                      \
++      ({                                                              \
++              register int _a1 asm ("r12");                           \
++              register int _scno asm("r8") = SYS_ify(name);           \
++              LOAD_ARGS_##nr (args);                                  \
++              asm volatile ("scall    /* syscall " #name " */"        \
++                            : "=r" (_a1)                              \
++                            : "r"(_scno) ASM_ARGS_##nr                \
++                            : "lr", "cc", "memory");                  \
++              _a1;                                                    \
++      })
++
++#undef INTERNAL_SYSCALL_ERROR_P
++#define INTERNAL_SYSCALL_ERROR_P(val, err)            \
++      ((unsigned int)(val) >= 0xfffff001U)
++
++#undef INTERNAL_SYSCALL_ERRNO
++#define INTERNAL_SYSCALL_ERRNO(val, errr) (-(val))
++
++#define LOAD_ARGS_0() do { } while(0)
++#define ASM_ARGS_0
++#define LOAD_ARGS_1(a1)                                       \
++      _a1 = (int) (a1);                               \
++      LOAD_ARGS_0()
++#define ASM_ARGS_1    ASM_ARGS_0, "r"(_a1)
++#define LOAD_ARGS_2(a1, a2)                           \
++      register int _a2 asm("r11") = (int)(a2);        \
++      LOAD_ARGS_1(a1)
++#define ASM_ARGS_2    ASM_ARGS_1, "r"(_a2)
++#define LOAD_ARGS_3(a1, a2, a3)                               \
++      register int _a3 asm("r10") = (int)(a3);        \
++      LOAD_ARGS_2(a1, a2)
++#define ASM_ARGS_3    ASM_ARGS_2, "r"(_a3)
++#define LOAD_ARGS_4(a1, a2, a3, a4)                   \
++      register int _a4 asm("r9") = (int)(a4);         \
++      LOAD_ARGS_3(a1, a2, a3)
++#define ASM_ARGS_4    ASM_ARGS_3, "r"(_a4)
++#define LOAD_ARGS_5(a1, a2, a3, a4, a5)                       \
++      register int _a5 asm("r5") = (int)(a5);         \
++      LOAD_ARGS_4(a1, a2, a3, a4)
++#define ASM_ARGS_5    ASM_ARGS_4, "r"(_a5)
++#define LOAD_ARGS_6(a1, a2, a3, a4, a5, a6)           \
++      register int _a6 asm("r3") = (int)(a6);         \
++      LOAD_ARGS_5(a1, a2, a3, a4, a5)
++#define ASM_ARGS_6    ASM_ARGS_5, "r"(_a6)
++
++#endif /* __ASSEMBLER__ */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/wordsize.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bits/wordsize.h     2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1 @@
++#define __WORDSIZE    32
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/brk.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/brk.c       2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,23 @@
++/*
++ * Copyright (C) 2004 Atmel Norway AS
++ */
++#include <errno.h>
++#include <sys/syscall.h>
++
++void *__curbrk = 0;
++
++int brk (void *addr)
++{
++      void *newbrk;
++
++      newbrk = INLINE_SYSCALL(brk, 1, addr);
++
++      __curbrk = newbrk;
++
++      if (newbrk < addr) {
++              __set_errno (ENOMEM);
++              return -1;
++      }
++
++      return 0;
++}
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bsd-_setjmp.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bsd-_setjmp.S       2006-05-05 09:26:42.000000000 +0200
+@@ -0,0 +1,12 @@
++/*
++ * Copyright (C) 2004 Atmel Norway AS
++ */
++
++      /* This just does a tail-call to __sigsetjmp(env, 0) */
++      .global _setjmp
++      .type   _setjmp,"function"
++      .align  1
++_setjmp:
++      mov     r11, 0
++      bral    __sigsetjmp_internal
++      .size   _setjmp, . - _setjmp
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/bsd-setjmp.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/bsd-setjmp.S        2006-05-05 09:26:42.000000000 +0200
+@@ -0,0 +1,12 @@
++/*
++ * Copyright (C) 2004 Atmel Norway AS
++ */
++
++      /* This just does a tail-call to __sigsetjmp(env, 1) */
++      .global setjmp
++      .type   setjmp,"function"
++      .align  1
++setjmp:
++      mov     r11, 1
++      bral    __sigsetjmp_internal
++      .size   setjmp, . - setjmp
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/clone.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/clone.c     2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,37 @@
++/*
++ * Copyright (C) 2004 Atmel Norway AS
++ */
++#include <errno.h>
++#include <sys/syscall.h>
++#include <unistd.h>
++
++/*
++ * I don't know if we can be absolutely certain that the fn and arg
++ * parameters are preserved when returning as the child. If the
++ * compiler stores them in registers (r0-r7), they should be.
++ */
++int clone(int (*fn)(void *arg), void *child_stack, int flags, void *arg)
++{
++      register int (*_fn)(void *arg) = fn;
++      register void *_arg = arg;
++      int err;
++
++      /* Sanity check the arguments */
++      err = -EINVAL;
++      if (!fn)
++              goto syscall_error;
++      if (!child_stack)
++              goto syscall_error;
++
++      err = INLINE_SYSCALL(clone, 2, flags, child_stack);
++      if (err < 0)
++              goto syscall_error;
++      else if (err != 0)
++              return err;
++
++      _exit(_fn(_arg));
++
++syscall_error:
++      __set_errno (-err);
++      return -1;
++}
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/crt1.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/crt1.S      2006-05-05 09:28:23.000000000 +0200
+@@ -0,0 +1,93 @@
++/*
++ * Copyright (C) 2004 Atmel Norway AS
++ *
++ * When we enter _start, the stack looks like this:
++ *    argc            argument counter
++ *    argv[0]         pointer to program name
++ *    argv[1..argc-1] pointers to program args
++ *    NULL
++ *    env[0..N]       pointers to environment variables
++ *    NULL
++ *
++ * r12 contains a function pointer to be registered with `atexit'.
++ * This is how the dynamic linker arranges to have DT_FINI functions
++ * called for shared libraries that have been loaded before this
++ * code runs.
++ *
++ * We're going to call the following function:
++ * __uClibc_main(int (*main)(int, char **, char **), int argc,
++ *             char **argv, void (*app_init)(void), void (*app_fini)(void),
++ *             void (*rtld_fini)(void), void *stack_end)
++ *
++ * So we need to set up things as follows:
++ *    r12 = address of main
++ *    r11 = argc
++ *    r10 = &argv[0]
++ *    r9  = address of _init
++ *    r8  = address of _fini
++ *    sp[0] = whatever we got passed in r12
++ */
++
++#include <features.h>
++
++      .text
++      .global _start
++      .type   _start, @function
++_start:
++      /* Clear the frame pointer and link register since this is the outermost frame.  */
++      mov     r7, 0
++      mov     lr, 0
++
++      ld.w    r11, sp++               /* argc         */
++      mov     r10, sp                 /* &argv[0]     */
++
++      st.w    --sp, r10               /* stack_end */
++      st.w    --sp, r12               /* rtld_fini */
++
++#ifdef __PIC__
++      lddpc   r6, .L_GOT
++.L_RGOT:
++      rsub    r6, pc
++      lda.w   r9, _init
++      lda.w   r8, _fini
++      lda.w   r12, main
++
++      /* Ok, now run uClibc's main() -- should not return */
++      call    __uClibc_main
++
++      .align  2
++.L_GOT:
++      .long   .L_RGOT - _GLOBAL_OFFSET_TABLE_
++#else
++      lddpc   r9, __init_addr         /* app_init */
++      lddpc   r8, __fini_addr         /* app_fini */
++      lddpc   r12, __main_addr        /* main */
++
++      /* Ok, now run uClibc's main() -- should not return */
++      lddpc   pc, ___uClibc_main_addr
++
++      .align  2
++__init_addr:
++      .long   _init
++__fini_addr:
++      .long   _fini
++__main_addr:
++      .long   main
++___uClibc_main_addr:
++      .long   __uClibc_main
++#endif
++      .size   _start, . - _start
++
++      /*
++       * The LSB says we need this.
++       */
++      .section ".note.ABI-tag", "a"
++      .align  4
++      .long   2f - 1f         /* namesz */
++      .long   4f - 3f         /* descsz */
++      .long   1               /* type   */
++1:    .asciz  "GNU"           /* name */
++2:    .align  4
++3:    .long   0               /* Linux executable */
++      .long   2,6,0           /* Earliest compatible kernel */
++4:    .align  4
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/crti.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/crti.S      2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,17 @@
++
++      .section .init
++      .align  2
++      .global _init
++      .type   _init, @function
++_init:
++      /* Use a four-byte instruction to avoid NOPs */
++      stm     --sp, r0-r7,lr
++      .align  2
++
++      .section .fini
++      .align  2
++      .global _fini
++      .type   _fini, @function
++_fini:
++      stm     --sp, r0-r7,lr
++      .align  2
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/crtn.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/crtn.S      2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,14 @@
++
++      .section .init
++      .align  2
++      .global _init
++      .type   _init, @function
++      ldm     sp++, r0-r7,pc
++      .size   _init, . - _init
++
++      .section .fini
++      .align  2
++      .global _fini
++      .type   _fini, @function
++      ldm     sp++, r0-r7,pc
++      .size   _fini, . - _fini
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/mmap.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/mmap.c      2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,31 @@
++/* Copyright (C) 2005 Atmel Norway
++
++   This program is free software; you can redistribute it and/or modify it under
++   the terms of the GNU Library General Public License as published by the Free
++   Software Foundation; either version 2 of the License, or (at your option) any
++   later version.
++
++   This program is distributed in the hope that it will be useful, but WITHOUT
++   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++   FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more
++   details.
++
++   You should have received a copy of the GNU Library General Public License
++   along with this program; if not, write to the Free Software Foundation, Inc.,
++   59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++
++   Derived in part from the Linux-8086 C library, the GNU C Library, and several
++   other sundry sources.  Files within this library are copyright by their
++   respective copyright holders.
++ */
++
++#include <errno.h>
++#include <sys/mman.h>
++#include <sys/syscall.h>
++
++static _syscall6(__ptr_t, mmap2, __ptr_t, addr, size_t, len, int, prot, int, flags, int, fd, __off_t, pgoff);
++
++__ptr_t mmap(__ptr_t addr, size_t len, int prot, int flags, int fd, __off_t offset)
++{
++      return mmap2(addr, len, prot, flags, fd, offset >> 12);
++}
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/setjmp.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/setjmp.S    2006-05-05 09:28:28.000000000 +0200
+@@ -0,0 +1,43 @@
++/*
++ * Copyright (C) 2004 Atmel Norway AS
++ */
++#define _SETJMP_H
++#define _ASM
++#include <bits/setjmp.h>
++
++      .text
++
++      .global __sigsetjmp
++      .type   __sigsetjmp,"function"
++
++      /* Create a global, hidden symbol for use by setjmp() and _setjmp().
++         If it's not hidden, the linker will complain about a relative
++         jump to a dynamic symbol when building a shared library.
++
++         Also, if a user overrides the __sigsetjmp function, he might not
++         expect the setjmp() and _setjmp() function to effectively be
++         overridden as well.  */
++      .global __sigsetjmp_internal
++      .hidden __sigsetjmp_internal
++      .type   __sigsetjmp_internal,"function"
++      .align  1
++__sigsetjmp:
++__sigsetjmp_internal:
++      mustr   r8
++      stm     r12, r0,r1,r2,r3,r4,r5,r6,r7,r8,sp,lr
++
++      /* Make a tail call to __sigjmp_save; it takes the same args.  */
++#ifdef __PIC__
++      mov     r9, r6
++      lddpc   r6, .LG
++.L1:  rsub    r6, pc
++      ld.w    r8, r6[__sigjmp_save@got]
++      mov     r6, r9
++      mov     pc, r8
++
++      .align  2
++.LG:  .long   .L1 - _GLOBAL_OFFSET_TABLE_
++#else
++      rjmp    __sigjmp_save
++#endif
++      .size   __sigsetjmp, . - __sigsetjmp
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/sigaction.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/sigaction.c 2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,49 @@
++/*
++ * Copyright (C) 2004 Atmel Norway AS
++ */
++#include <errno.h>
++#include <signal.h>
++#include <string.h>
++#include <sys/syscall.h>
++#include <bits/kernel_sigaction.h>
++
++#define SA_RESTORER   0x04000000
++extern void __default_rt_sa_restorer(void);
++
++/*
++ * If act is not NULL, change the action for sig to *act.
++ * If oact is not NULL, put the old action for sig in *oact.
++ */
++int __libc_sigaction(int signum, const struct sigaction *act,
++                   struct sigaction *oldact)
++{
++      struct kernel_sigaction kact, koact;
++      int result;
++
++      if (act) {
++              kact.k_sa_handler = act->sa_handler;
++              memcpy(&kact.sa_mask, &act->sa_mask, sizeof (kact.sa_mask));
++              kact.sa_flags = act->sa_flags;
++              if (kact.sa_flags & (SA_RESTORER | SA_ONSTACK))
++                      kact.sa_restorer = act->sa_restorer;
++              else
++                      kact.sa_restorer = __default_rt_sa_restorer;
++              kact.sa_flags |= SA_RESTORER;
++      }
++
++      result = __syscall_rt_sigaction(signum, act ? __ptrvalue(&kact) : NULL,
++                                      oldact ? __ptrvalue(&koact) : NULL,
++                                      _NSIG / 8);
++
++      if (oldact && result >= 0) {
++              oldact->sa_handler = koact.k_sa_handler;
++              memcpy(&oldact->sa_mask, &koact.sa_mask,
++                     sizeof(oldact->sa_mask));
++              oldact->sa_flags = koact.sa_flags;
++              oldact->sa_restorer = koact.sa_restorer;
++      }
++
++      return result;
++}
++
++weak_alias(__libc_sigaction, sigaction)
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/sigrestorer.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/sigrestorer.S       2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,11 @@
++/*
++ * Copyright (C) 2004 Atmel Norway AS
++ */
++#include <sys/syscall.h>
++
++      .global __default_rt_sa_restorer
++      .type   __default_rt_sa_restorer,"function"
++      .align  1
++__default_rt_sa_restorer:
++      mov     r8, __NR_rt_sigreturn
++      scall
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/elf.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/elf.h   2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,26 @@
++/* Copyright (C) 1996, 1997, 1999, 2001 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++#ifndef _SYS_ELF_H
++#define _SYS_ELF_H    1
++
++#warning "This header is obsolete; use <sys/procfs.h> instead."
++
++#include <sys/procfs.h>
++
++#endif        /* sys/elf.h */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/io.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/io.h    2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,48 @@
++/* Copyright (C) 1996, 1998, 1999 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++#ifndef       _SYS_IO_H
++
++#define       _SYS_IO_H       1
++#include <features.h>
++
++__BEGIN_DECLS
++
++/* If TURN_ON is TRUE, request for permission to do direct i/o on the
++   port numbers in the range [FROM,FROM+NUM-1].  Otherwise, turn I/O
++   permission off for that range.  This call requires root privileges.  */
++extern int ioperm (unsigned long int __from, unsigned long int __num,
++                 int __turn_on) __THROW;
++
++/* Set the I/O privilege level to LEVEL.  If LEVEL is nonzero,
++   permission to access any I/O port is granted.  This call requires
++   root privileges. */
++extern int iopl (int __level) __THROW;
++
++/* The functions that actually perform reads and writes.  */
++extern unsigned char inb (unsigned long int port) __THROW;
++extern unsigned short int inw (unsigned long int port) __THROW;
++extern unsigned long int inl (unsigned long int port) __THROW;
++
++extern void outb (unsigned char value, unsigned long int port) __THROW;
++extern void outw (unsigned short value, unsigned long int port) __THROW;
++extern void outl (unsigned long value, unsigned long int port) __THROW;
++
++__END_DECLS
++
++#endif /* _SYS_IO_H */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/procfs.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/procfs.h        2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,123 @@
++/* Copyright (C) 1996, 1997, 1999, 2001 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++#ifndef _SYS_PROCFS_H
++#define _SYS_PROCFS_H 1
++
++/* This is somewhat modelled after the file of the same name on SVR4
++   systems.  It provides a definition of the core file format for ELF
++   used on Linux.  It doesn't have anything to do with the /proc file
++   system, even though Linux has one.
++
++   Anyway, the whole purpose of this file is for GDB and GDB only.
++   Don't read too much into it.  Don't use it for anything other than
++   GDB unless you know what you are doing.  */
++
++#include <features.h>
++#include <sys/time.h>
++#include <sys/types.h>
++#include <sys/user.h>
++
++__BEGIN_DECLS
++
++/* Type for a general-purpose register.  */
++typedef unsigned long elf_greg_t;
++
++/* And the whole bunch of them.  We could have used `struct
++   user_regs' directly in the typedef, but tradition says that
++   the register set is an array, which does have some peculiar
++   semantics, so leave it that way.  */
++#define ELF_NGREG (sizeof (struct user_regs) / sizeof(elf_greg_t))
++typedef elf_greg_t elf_gregset_t[ELF_NGREG];
++
++/* Register set for the floating-point registers.  */
++typedef struct user_fpregs elf_fpregset_t;
++
++/* Signal info.  */
++struct elf_siginfo
++  {
++    int si_signo;                     /* Signal number.  */
++    int si_code;                      /* Extra code.  */
++    int si_errno;                     /* Errno.  */
++  };
++
++/* Definitions to generate Intel SVR4-like core files.  These mostly
++   have the same names as the SVR4 types with "elf_" tacked on the
++   front to prevent clashes with Linux definitions, and the typedef
++   forms have been avoided.  This is mostly like the SVR4 structure,
++   but more Linuxy, with things that Linux does not support and which
++   GDB doesn't really use excluded.  */
++
++struct elf_prstatus
++  {
++    struct elf_siginfo pr_info;               /* Info associated with signal.  */
++    short int pr_cursig;              /* Current signal.  */
++    unsigned long int pr_sigpend;     /* Set of pending signals.  */
++    unsigned long int pr_sighold;     /* Set of held signals.  */
++    __pid_t pr_pid;
++    __pid_t pr_ppid;
++    __pid_t pr_pgrp;
++    __pid_t pr_sid;
++    struct timeval pr_utime;          /* User time.  */
++    struct timeval pr_stime;          /* System time.  */
++    struct timeval pr_cutime;         /* Cumulative user time.  */
++    struct timeval pr_cstime;         /* Cumulative system time.  */
++    elf_gregset_t pr_reg;             /* GP registers.  */
++    int pr_fpvalid;                   /* True if math copro being used.  */
++  };
++
++
++#define ELF_PRARGSZ     (80)    /* Number of chars for args.  */
++
++struct elf_prpsinfo
++  {
++    char pr_state;                    /* Numeric process state.  */
++    char pr_sname;                    /* Char for pr_state.  */
++    char pr_zomb;                     /* Zombie.  */
++    char pr_nice;                     /* Nice val.  */
++    unsigned long int pr_flag;                /* Flags.  */
++    unsigned short int pr_uid;
++    unsigned short int pr_gid;
++    int pr_pid, pr_ppid, pr_pgrp, pr_sid;
++    /* Lots missing */
++    char pr_fname[16];                        /* Filename of executable.  */
++    char pr_psargs[ELF_PRARGSZ];      /* Initial part of arg list.  */
++  };
++
++/* The rest of this file provides the types for emulation of the
++   Solaris <proc_service.h> interfaces that should be implemented by
++   users of libthread_db.  */
++
++/* Addresses.  */
++typedef void *psaddr_t;
++
++/* Register sets.  Linux has different names.  */
++typedef elf_gregset_t prgregset_t;
++typedef elf_fpregset_t prfpregset_t;
++
++/* We don't have any differences between processes and threads,
++   therefore have only one PID type.  */
++typedef __pid_t lwpid_t;
++
++/* Process status and info.  In the end we do provide typedefs for them.  */
++typedef struct elf_prstatus prstatus_t;
++typedef struct elf_prpsinfo prpsinfo_t;
++
++__END_DECLS
++
++#endif        /* sys/procfs.h */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/ucontext.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/ucontext.h      2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,94 @@
++/* Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++/* Linux/AVR32 ABI compliant context switching support.  */
++
++#ifndef _SYS_UCONTEXT_H
++#define _SYS_UCONTEXT_H       1
++
++#include <features.h>
++#include <signal.h>
++#include <sys/procfs.h>
++#include <bits/sigcontext.h>
++
++typedef int greg_t;
++
++/* Number of general registers.  */
++#define NGREG 16
++
++/* Container for all general registers.  */
++typedef elf_gregset_t gregset_t;
++
++/* Number of each register is the `gregset_t' array.  */
++enum
++{
++  R0 = 0,
++#define R0    R0
++  R1 = 1,
++#define R1    R1
++  R2 = 2,
++#define R2    R2
++  R3 = 3,
++#define R3    R3
++  R4 = 4,
++#define R4    R4
++  R5 = 5,
++#define R5    R5
++  R6 = 6,
++#define R6    R6
++  R7 = 7,
++#define R7    R7
++  R8 = 8,
++#define R8    R8
++  R9 = 9,
++#define R9    R9
++  R10 = 10,
++#define R10   R10
++  R11 = 11,
++#define R11   R11
++  R12 = 12,
++#define R12   R12
++  R13 = 13,
++#define R13   R13
++  R14 = 14,
++#define R14   R14
++  R15 = 15
++#define R15   R15
++};
++
++/* Structure to describe FPU registers.  */
++typedef elf_fpregset_t        fpregset_t;
++
++/* Context to describe whole processor state.  */
++typedef struct
++  {
++    gregset_t gregs;
++    fpregset_t fpregs;
++  } mcontext_t;
++
++/* Userlevel context.  */
++typedef struct ucontext
++{
++    unsigned long     uc_flags;
++    struct ucontext  *uc_link;
++    stack_t           uc_stack;
++    struct sigcontext uc_mcontext;
++    sigset_t          uc_sigmask;   /* mask last for extensibility */
++} ucontext_t;
++
++#endif /* sys/ucontext.h */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/user.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/sys/user.h  2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,46 @@
++#ifndef _SYS_USER_H
++#define _SYS_USER_H
++
++struct user_fpregs
++{
++
++};
++
++struct user_regs
++{
++      unsigned long sr;
++      unsigned long pc;
++      unsigned long lr;
++      unsigned long sp;
++      unsigned long r12;
++      unsigned long r11;
++      unsigned long r10;
++      unsigned long r9;
++      unsigned long r8;
++      unsigned long r7;
++      unsigned long r6;
++      unsigned long r5;
++      unsigned long r4;
++      unsigned long r3;
++      unsigned long r2;
++      unsigned long r1;
++      unsigned long r0;
++      unsigned long r12_orig;
++};
++
++struct user
++{
++      struct user_regs        regs;           /* general registers */
++      size_t                  u_tsize;        /* text size (pages) */
++      size_t                  u_dsize;        /* data size (pages) */
++      size_t                  u_ssize;        /* stack size (pages) */
++      unsigned long           start_code;     /* text starting address */
++      unsigned long           start_data;     /* data starting address */
++      unsigned long           start_stack;    /* stack starting address */
++      long int                signal;         /* signal causing core dump */
++      struct user_regs *      u_ar0;          /* help gdb find registers */
++      unsigned long           magic;          /* identifies a core file */
++      char                    u_comm[32];     /* user command name */
++};
++
++#endif /* _SYS_USER_H */
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/syscall.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/syscall.S   2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,81 @@
++/*
++ * syscall for AVR32/uClibc
++ *
++ * Copyright (C) 2004 Atmel Norway
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU Library General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or (at your
++ * option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License
++ * for more details.
++ *
++ * You should have received a copy of the GNU Library General Public License
++ * along with this program; if not, write to the Free Software Foundation,
++ * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++#include <features.h>
++
++      .text
++
++      /*
++       * long int syscall(long int sysno, ...)
++       */
++      .global syscall
++      .type   syscall, @function
++      .align  2
++syscall:
++      stm     --sp, r3,r5,lr
++      sub     lr, sp, -12
++      mov     r8, r12
++      ldm     lr, r3,r5,r9-r12
++      scall
++      cp.w    r12, -4095
++      brlo    .Ldone
++
++#ifdef __PIC__
++      lddpc   r5, .Lgot
++.Lgotcalc:
++      rsub    r5, pc
++# ifdef __UCLIBC_HAS_THREADS__
++      mov     r3, r12
++      mcall   r5[__errno_location@got]
++      st.w    r12[0], r3
++# else
++      ld.w    r3, r5[errno@got]
++      st.w    r3[0], r12
++# endif
++#else
++# ifdef __UCLIBC_HAS_THREADS__
++      mov     r3, r12
++      mcall   .Lerrno_location
++      st.w    r12[0], r3
++# else
++      lddpc   r3, .Lerrno
++      st.w    r3[0], r12
++# endif
++#endif
++      mov     r12, -1
++
++.Ldone:
++      ldm     sp++, r3,r5,pc
++
++      .align  2
++#ifdef __PIC__
++.Lgot:
++      .long   .Lgotcalc - _GLOBAL_OFFSET_TABLE_
++#else
++# ifdef __UCLIBC_HAS_THREADS__
++.Lerrno_location:
++      .long   __errno_location
++# else
++.Lerrno:
++      .long   errno
++# endif
++#endif
++
++
++      .size   syscall, . - syscall
+Index: uClibc-0.9.28/libc/sysdeps/linux/avr32/vfork.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libc/sysdeps/linux/avr32/vfork.S     2006-04-19 12:48:33.000000000 +0200
+@@ -0,0 +1,55 @@
++      /*
++       * vfork for uClibc
++       *
++       * Copyright (C) 2005 Atmel Norway
++       */
++
++      /*
++       * Clone the process without copying the address space.  The
++       * calling process is suspended until the child either exits
++       * or calls execve.
++       *
++       * This all means that we cannot rely on the stack to store
++       * away registers, since they will be overwritten by the child
++       * as soon as it makes another function call (e.g. execve()).
++       * Fortunately, the Linux kernel preserves LR across system calls.
++       */
++#include <features.h>
++#include <sys/syscall.h>
++
++      .global __vfork
++      .type   __vfork,@function
++      .align  1
++__vfork:
++      mov     r8, __NR_vfork
++      scall
++      cp.w    r12, -4096
++      retls   r12
++
++      /* vfork failed, so we may use the stack freely */
++      pushm   r4-r7,lr
++#ifdef __PIC__
++      lddpc   r6, .L_GOT
++      rsub    r4, r12, 0
++.L_RGOT:
++      rsub    r6, pc
++      mcall   r6[__errno_location@got]
++#else
++      rsub    r4, r12, 0
++      mcall   .L__errno_location
++#endif
++      st.w    r12[0], r4
++      popm    r4-r7,pc,r12=-1
++
++      .align  2
++#ifdef __PIC__
++.L_GOT:
++      .long   .L_RGOT - _GLOBAL_OFFSET_TABLE_
++#else
++.L__errno_location:
++      .long   __errno_location
++#endif
++      .size   __vfork, . - __vfork
++
++      .weak   vfork
++      vfork   = __vfork
+Index: uClibc-0.9.28/Rules.mak
+===================================================================
+--- uClibc-0.9.28.orig/Rules.mak       2006-05-05 09:26:01.000000000 +0200
++++ uClibc-0.9.28/Rules.mak    2006-05-05 09:27:17.000000000 +0200
+@@ -231,6 +231,10 @@ ifeq ($(strip $(TARGET_ARCH)),frv)
+       UCLIBC_LDSO=ld.so.1
+ endif
++ifeq ($(strip $(TARGET_ARCH)),avr32)
++      CPU_CFLAGS-$(CONFIG_AP7000)     += -mcpu=ap7000
++endif
++
+ # Keep the check_gcc from being needlessly executed
+ ifndef PIEFLAG
+ ifneq ($(UCLIBC_BUILD_PIE),y)
diff --git a/toolchain/uClibc/patches/401-avr32-linkrelax-option.patch b/toolchain/uClibc/patches/401-avr32-linkrelax-option.patch
new file mode 100644 (file)
index 0000000..991e344
--- /dev/null
@@ -0,0 +1,40 @@
+From nobody Mon Sep 17 00:00:00 2001
+Subject: [PATCH] Make linkrelax configurable
+From: HÃ¥vard Skinnemoen <hskinnemoen@atmel.com>
+Date: 1133951618 +0100
+
+Add a linkrelax option to the configure system which will give
+appropriate options to the compiler, assembler and linker to enable
+link-time optimizations.
+
+---
+
+ Rules.mak                  |    2 ++
+ extra/Configs/Config.avr32 |    4 ++++
+ 2 files changed, 6 insertions(+)
+
+Index: uClibc-0.9.28/Rules.mak
+===================================================================
+--- uClibc-0.9.28.orig/Rules.mak       2006-02-08 17:58:53.000000000 +0100
++++ uClibc-0.9.28/Rules.mak    2006-02-08 17:59:07.000000000 +0100
+@@ -233,6 +233,8 @@ endif
+ ifeq ($(strip $(TARGET_ARCH)),avr32)
+       CPU_CFLAGS-$(CONFIG_AP7000)     += -mcpu=ap7000
++      CPU_CFLAGS-$(LINKRELAX)         += -masm-addr-pseudos -Wa,--pic,--linkrelax
++      CPU_LDFLAGS-$(LINKRELAX)        += --relax
+ endif
+ # Keep the check_gcc from being needlessly executed
+Index: uClibc-0.9.28/extra/Configs/Config.avr32
+===================================================================
+--- uClibc-0.9.28.orig/extra/Configs/Config.avr32      2006-02-08 17:58:53.000000000 +0100
++++ uClibc-0.9.28/extra/Configs/Config.avr32   2006-02-08 17:59:07.000000000 +0100
+@@ -36,3 +36,7 @@ config CONFIG_AP7000
+       bool "AP7000"
+ endchoice
++
++config LINKRELAX
++      bool "Enable linker optimizations"
++      default n
diff --git a/toolchain/uClibc/patches/402-avr32-string-ops.patch b/toolchain/uClibc/patches/402-avr32-string-ops.patch
new file mode 100644 (file)
index 0000000..8518ccf
--- /dev/null
@@ -0,0 +1,1139 @@
+Subject: [PATCH] AVR32-optimized string operations
+
+Add hand-optimized AVR32-specific string operations. Some of them
+need a bit more testing, though.
+
+---
+
+ libc/string/avr32/Makefile      |   40 +++++++++++
+ libc/string/avr32/bcopy.S       |   15 ++++
+ libc/string/avr32/bzero.S       |   12 +++
+ libc/string/avr32/memchr.S      |   62 +++++++++++++++++
+ libc/string/avr32/memcmp.S      |   50 +++++++++++++
+ libc/string/avr32/memcpy.S      |  110 ++++++++++++++++++++++++++++++
+ libc/string/avr32/memmove.S     |  114 +++++++++++++++++++++++++++++++
+ libc/string/avr32/memset.S      |   60 ++++++++++++++++
+ libc/string/avr32/strcat.S      |   95 ++++++++++++++++++++++++++
+ libc/string/avr32/strcmp.S      |   80 ++++++++++++++++++++++
+ libc/string/avr32/strcpy.S      |   63 +++++++++++++++++
+ libc/string/avr32/stringtest.c  |  144 ++++++++++++++++++++++++++++++++++++++++
+ libc/string/avr32/strlen.S      |   52 ++++++++++++++
+ libc/string/avr32/strncpy.S     |   77 +++++++++++++++++++++
+ libc/string/avr32/test_memcpy.c |   66 ++++++++++++++++++
+ 15 files changed, 1040 insertions(+)
+
+Index: uClibc-0.9.28-avr32/libc/string/avr32/bcopy.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/bcopy.S      2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,15 @@
++/*
++ * Copyright (C) 2004 Atmel Norway
++ */
++
++      .text
++      .global bcopy
++      .type   bcopy, @function
++      .align  1
++bcopy:
++      /* Swap the first two arguments */
++      eor     r11, r12
++      eor     r12, r11
++      eor     r11, r12
++      rjmp    __memmove
++      .size   bcopy, . - bcopy
+Index: uClibc-0.9.28-avr32/libc/string/avr32/bzero.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/bzero.S      2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,12 @@
++/*
++ * Copyright (C) 2004 Atmel Norway
++ */
++
++      .text
++      .global bzero
++      .type   bzero, @function
++      .align  1
++bzero:
++      mov     r10, r11
++      mov     r11, 0
++      rjmp    __memset
+Index: uClibc-0.9.28-avr32/libc/string/avr32/Makefile
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/Makefile     2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,40 @@
++# Makefile for uClibc
++#
++# Copyright (C) 2000-2003 Erik Andersen <andersen@uclibc.org>
++#
++# This program is free software; you can redistribute it and/or modify it under
++# the terms of the GNU Library General Public License as published by the Free
++# Software Foundation; either version 2 of the License, or (at your option) any
++# later version.
++#
++# This program is distributed in the hope that it will be useful, but WITHOUT
++# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++# FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more
++# details.
++#
++# You should have received a copy of the GNU Library General Public License
++# along with this program; if not, write to the Free Software Foundation, Inc.,
++# 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++
++TOPDIR=../../../
++include $(TOPDIR)Rules.mak
++
++SSRC  := bcopy.S bzero.S memcmp.S memcpy.S memmove.S
++SSRC  += memset.S strcmp.S strlen.S
++# memchr.S, strcat.S, strcpy.S, strncpy.S is broken
++SOBJS := $(patsubst %.S,%.o, $(SSRC))
++OBJS  := $(SOBJS)
++
++OBJ_LIST:= ../../obj.string.$(TARGET_ARCH)
++
++all: $(OBJ_LIST)
++
++$(OBJ_LIST): $(OBJS)
++      echo $(addprefix string/$(TARGET_ARCH)/, $(OBJS)) > $@
++
++$(SOBJS): %.o: %.S
++      $(CC) $(ASFLAGS) -c $< -o $@
++      $(STRIPTOOL) -x -R .note -R .comment $@
++
++clean:
++      $(RM) *.[oa] *~ core
+Index: uClibc-0.9.28-avr32/libc/string/avr32/memchr.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/memchr.S     2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,62 @@
++/*
++ * Copyright (C) 2004 Atmel Norway
++ */
++
++#define str r12
++#define chr r11
++#define len r10
++
++      .text
++      .global memchr
++      .type   memchr, @function
++memchr:
++      or      chr, chr, chr << 8
++      or      chr, chr, chr << 16
++
++      mov     r9, str
++      andl    r9, 3, COH
++      brne    .Lunaligned_str
++
++1:    sub     len, 4
++      brlt    2f
++      ld.w    r8, str++
++      psub.b  r9, r8, r11
++      tnbz    r9
++      brne    1b
++
++      sub     str, 4
++      bfextu  r9, r8, 24, 8
++      cp.b    r9, r11
++      reteq   str
++      sub     str, -1
++      bfextu  r9, r8, 16, 8
++      cp.b    r9, r11
++      reteq   str
++      sub     str, -1
++      bfextu  r9, r8, 8, 8
++      cp.b    r9, r11
++      reteq   str
++      sub     str, -1
++      retal   str
++
++2:    sub     len, -4
++      reteq   0
++
++3:    ld.ub   r8, str++
++      cp.w    r8, 0
++      reteq   str
++      sub     len, 1
++      brne    3b
++
++      retal   0
++
++.Lunaligned_str:
++1:    sub     len, 1
++      retlt   0
++      ld.ub   r8, str++
++      cp.b    r8, r11
++      reteq   str
++      sub     r9, 1
++      brge    1b
++
++      rjmp    .Laligned_search
+Index: uClibc-0.9.28-avr32/libc/string/avr32/memcmp.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/memcmp.S     2006-10-20 10:42:09.000000000 +0200
+@@ -0,0 +1,50 @@
++/*
++ * Copyright (C) 2004 Atmel Norway.
++ */
++
++#define s1 r12
++#define s2 r11
++#define len r10
++
++      .text
++      .global memcmp
++      .type   memcmp, @function
++      .align  1
++memcmp:
++      sub     len, 4
++      brlt    .Lless_than_4
++
++1:    ld.w    r8, s1++
++      ld.w    r9, s2++
++      cp.w    r8, r9
++      brne    .Lfound_word
++      sub     len, 4
++      brge    1b
++
++.Lless_than_4:
++      sub     len, -4
++      reteq   0
++
++1:    ld.ub   r8, s1++
++      ld.ub   r9, s2++
++      sub     r8, r9
++      retne   r8
++      sub     len, 1
++      brgt    1b
++
++      retal   0
++
++.Lfound_word:
++      psub.b  r9, r8, r9
++      bfextu  r8, r9, 24, 8
++      retne   r8
++      bfextu  r8, r9, 16, 8
++      retne   r8
++      bfextu  r8, r9, 8, 8
++      retne   r8
++      retal   r9
++
++      .size   memcmp, . - memcmp
++
++      .weak   bcmp
++      bcmp = memcmp
+Index: uClibc-0.9.28-avr32/libc/string/avr32/memcpy.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/memcpy.S     2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,110 @@
++/*
++ * Copyright (C) 2004 Atmel Norway
++ */
++
++/* Don't use r12 as dst since we must return it unmodified */
++#define dst r9
++#define src r11
++#define len r10
++
++      .text
++      .global memcpy
++      .type   memcpy, @function
++
++      .global __memcpy
++      .hidden __memcpy
++      .type   __memcpy, @function
++memcpy:
++__memcpy:
++      pref    src[0]
++      mov     dst, r12
++
++      /* If we have less than 32 bytes, don't do anything fancy */
++      cp.w    len, 32
++      brge    .Lmore_than_31
++
++      sub     len, 1
++      retlt   r12
++1:    ld.ub   r8, src++
++      st.b    dst++, r8
++      sub     len, 1
++      brge    1b
++      retal   r12
++
++.Lmore_than_31:
++      pushm   r0-r7, lr
++
++      /* Check alignment */
++      mov     r8, src
++      andl    r8, 31, COH
++      brne    .Lunaligned_src
++      mov     r8, dst
++      andl    r8, 3, COH
++      brne    .Lunaligned_dst
++
++.Laligned_copy:
++      sub     len, 32
++      brlt    .Lless_than_32
++
++1:    /* Copy 32 bytes at a time */
++      ldm     src, r0-r7
++      sub     src, -32
++      stm     dst, r0-r7
++      sub     dst, -32
++      sub     len, 32
++      brge    1b
++
++.Lless_than_32:
++      /* Copy 16 more bytes if possible */
++      sub     len, -16
++      brlt    .Lless_than_16
++      ldm     src, r0-r3
++      sub     src, -16
++      sub     len, 16
++      stm     dst, r0-r3
++      sub     dst, -16
++
++.Lless_than_16:
++      /* Do the remaining as byte copies */
++      neg     len
++      add     pc, pc, len << 2
++      .rept   15
++      ld.ub   r0, src++
++      st.b    dst++, r0
++      .endr
++
++      popm    r0-r7, pc
++
++.Lunaligned_src:
++      /* Make src cacheline-aligned. r8 = (src & 31) */
++      rsub    r8, r8, 32
++      sub     len, r8
++1:    ld.ub   r0, src++
++      st.b    dst++, r0
++      sub     r8, 1
++      brne    1b
++
++      /* If dst is word-aligned, we're ready to go */
++      pref    src[0]
++      mov     r8, 3
++      tst     dst, r8
++      breq    .Laligned_copy
++
++.Lunaligned_dst:
++      /* src is aligned, but dst is not. Expect bad performance */
++      sub     len, 4
++      brlt    2f
++1:    ld.w    r0, src++
++      st.w    dst++, r0
++      sub     len, 4
++      brge    1b
++
++2:    neg     len
++      add     pc, pc, len << 2
++      .rept   3
++      ld.ub   r0, src++
++      st.b    dst++, r0
++      .endr
++
++      popm    r0-r7, pc
++      .size   memcpy, . - memcpy
+Index: uClibc-0.9.28-avr32/libc/string/avr32/memmove.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/memmove.S    2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,114 @@
++/*
++ * Copyright (C) 2004 Atmel Norway
++ */
++
++#define dst r12
++#define src r11
++#define len r10
++
++      .text
++      .global memmove
++      .type   memmove, @function
++
++      .global __memmove
++      .hidden __memmove
++      .type   __memmove, @function
++memmove:
++__memmove:
++      cp.w    src, dst
++      brge    __memcpy
++
++      add     dst, len
++      add     src, len
++      pref    src[-1]
++
++      /*
++       * The rest is basically the same as in memcpy.S except that
++       * the direction is reversed.
++       */
++      cp.w    len, 32
++      brge    .Lmore_than_31
++
++      sub     len, 1
++      retlt   r12
++1:    ld.ub   r8, --src
++      st.b    --dst, r8
++      sub     len, 1
++      brge    1b
++      retal   r12
++
++.Lmore_than_31:
++      pushm   r0-r7, lr
++
++      /* Check alignment */
++      mov     r8, src
++      andl    r8, 31, COH
++      brne    .Lunaligned_src
++      mov     r8, r12
++      andl    r8, 3, COH
++      brne    .Lunaligned_dst
++
++.Laligned_copy:
++      sub     len, 32
++      brlt    .Lless_than_32
++
++1:    /* Copy 32 bytes at a time */
++      sub     src, 32
++      ldm     src, r0-r7
++      sub     dst, 32
++      sub     len, 32
++      stm     dst, r0-r7
++      brge    1b
++
++.Lless_than_32:
++      /* Copy 16 more bytes if possible */
++      sub     len, -16
++      brlt    .Lless_than_16
++      sub     src, 16
++      ldm     src, r0-r3
++      sub     dst, 16
++      sub     len, 16
++      stm     dst, r0-r3
++
++.Lless_than_16:
++      /* Do the remaining as byte copies */
++      sub     len, -16
++      breq    2f
++1:    ld.ub   r0, --src
++      st.b    --dst, r0
++      sub     len, 1
++      brne    1b
++
++2:    popm    r0-r7, pc
++
++.Lunaligned_src:
++      /* Make src cacheline-aligned. r8 = (src & 31) */
++      sub     len, r8
++1:    ld.ub   r0, --src
++      st.b    --dst, r0
++      sub     r8, 1
++      brne    1b
++
++      /* If dst is word-aligned, we're ready to go */
++      pref    src[-4]
++      mov     r8, 3
++      tst     dst, r8
++      breq    .Laligned_copy
++
++.Lunaligned_dst:
++      /* src is aligned, but dst is not. Expect bad performance */
++      sub     len, 4
++      brlt    2f
++1:    ld.w    r0, --src
++      st.w    --dst, r0
++      sub     len, 4
++      brge    1b
++
++2:    neg     len
++      add     pc, pc, len << 2
++      .rept   3
++      ld.ub   r0, --src
++      st.b    --dst, r0
++      .endr
++
++      popm    r0-r7, pc
+Index: uClibc-0.9.28-avr32/libc/string/avr32/memset.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/memset.S     2006-10-20 10:42:15.000000000 +0200
+@@ -0,0 +1,60 @@
++/*
++ * Copyright (C) 2004 Atmel Norway.
++ */
++
++#define s r12
++#define c r11
++#define n r10
++
++      .text
++      .global memset
++      .type   memset, @function
++
++      .global __memset
++      .hidden __memset
++      .type   __memset, @function
++
++      .align  1
++memset:
++__memset:
++      cp.w    n, 32
++      mov     r9, s
++      brge    .Llarge_memset
++
++      sub     n, 1
++      retlt   s
++1:    st.b    s++, c
++      sub     n, 1
++      brge    1b
++
++      retal   r9
++
++.Llarge_memset:
++      mov     r8, r11
++      mov     r11, 3
++      bfins   r8, r8, 8, 8
++      bfins   r8, r8, 16, 16
++      tst     s, r11
++      breq    2f
++
++1:    st.b    s++, r8
++      sub     n, 1
++      tst     s, r11
++      brne    1b
++
++2:    mov     r11, r9
++      mov     r9, r8
++      sub     n, 8
++
++3:    st.d    s++, r8
++      sub     n, 8
++      brge    3b
++
++      /* If we are done, n == -8 and we'll skip all st.b insns below */
++      neg     n
++      lsl     n, 1
++      add     pc, n
++      .rept   7
++      st.b    s++, r8
++      .endr
++      retal   r11
+Index: uClibc-0.9.28-avr32/libc/string/avr32/strcat.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/strcat.S     2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,95 @@
++/*
++ * Copyright (C) 2004 Atmel Norway
++ */
++
++#define s1 r9
++#define s2 r11
++
++      .text
++      .global strcat
++      .type   strcat, @function
++      .align  1
++strcat:
++      mov     s1, r12
++
++      /* Make sure s1 is word-aligned */
++      mov     r10, s1
++      andl    r10, 3, COH
++      breq    2f
++
++      add     pc, pc, r10 << 3
++      sub     r0, r0, 0       /* 4-byte nop */
++      ld.ub   r8, s1++
++      sub     r8, r8, 0
++      breq    2f
++      ld.ub   r8, s1++
++      sub     r8, r8, 0
++      breq    3f
++      ld.ub   r8, s1++
++      sub     r8, r8, 0
++      breq    4f
++
++      /* Find the end of the first string */
++5:    ld.w    r8, s1++
++      tnbz    r8
++      brne    5b
++
++      sub     s1, 4
++
++      bfextu  r10, r8, 24, 8
++      cp.w    r10, 0
++      breq    1f
++      sub     s1, -1
++      bfextu  r10, r8, 16, 8
++      cp.w    r10, 0
++      breq    2f
++      sub     s1, -1
++      bfextu  r10, r8, 8, 8
++      cp.w    r10, 0
++      breq    3f
++      sub     s1, -1
++      rjmp    4f
++
++      /* Now, append s2 */
++1:    ld.ub   r8, s2++
++      st.b    s1++, r8
++      cp.w    r8, 0
++      reteq   r12
++2:    ld.ub   r8, s2++
++      st.b    s1++, r8
++      cp.w    r8, 0
++      reteq   r12
++3:    ld.ub   r8, s2++
++      st.b    s1++, r8
++      cp.w    r8, 0
++      reteq   r12
++4:    ld.ub   r8, s2++
++      st.b    s1++, r8
++      cp.w    r8, 0
++      reteq   r12
++
++      /* Copy one word at a time */
++      ld.w    r8, s2++
++      tnbz    r8
++      breq    2f
++1:    st.w    r8, s2++
++      ld.w    r8, s2++
++      tnbz    r8
++      brne    1b
++
++      /* Copy the remaining bytes */
++      bfextu  r10, r8, 24, 8
++      st.b    s1++, r10
++      cp.w    r10, 0
++      reteq   r12
++      bfextu  r10, r8, 16, 8
++      st.b    s1++, r10
++      cp.w    r10, 0
++      reteq   r12
++      bfextu  r10, r8, 8, 8
++      st.b    s1++, r10
++      cp.w    r10, 0
++      reteq   r12
++      st.b    s1++, r8
++      retal   r12
++      .size   strcat, . - strcat
+Index: uClibc-0.9.28-avr32/libc/string/avr32/strcmp.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/strcmp.S     2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,80 @@
++/*
++ * Copyright (C) 2004 Atmel Norway.
++ */
++
++#define s1 r12
++#define s2 r11
++#define len r10
++
++      .text
++      .global strcmp
++      .type   strcmp, @function
++      .align  1
++strcmp:
++      mov     r8, 3
++      tst     s1, r8
++      brne    .Lunaligned_s1
++      tst     s2, r8
++      brne    .Lunaligned_s2
++
++1:    ld.w    r8, s1++
++      ld.w    r9, s2++
++      cp.w    r8, r9
++      brne    2f
++      tnbz    r8
++      brne    1b
++      retal   0
++
++2:    bfextu  r12, r8, 24, 8
++      bfextu  r11, r9, 24, 8
++      sub     r12, r11
++      retne   r12
++      cp.w    r11, 0
++      reteq   0
++      bfextu  r12, r8, 16, 8
++      bfextu  r11, r9, 16, 8
++      sub     r12, r11
++      retne   r12
++      cp.w    r11, 0
++      reteq   0
++      bfextu  r12, r8, 8, 8
++      bfextu  r11, r9, 8, 8
++      sub     r12, r11
++      retne   r12
++      cp.w    r11, 0
++      reteq   0
++      bfextu  r12, r8, 0, 8
++      bfextu  r11, r9, 0, 8
++      sub     r12, r11
++      retal   r12
++
++.Lunaligned_s1:
++3:    tst     s1, r8
++      breq    4f
++      ld.ub   r10, s1++
++      ld.ub   r9, s2++
++      sub     r10, r9
++      retne   r10
++      cp.w    r9, 0
++      brne    3b
++      retal   r10
++
++4:    tst     s2, r8
++      breq    1b
++
++.Lunaligned_s2:
++      /*
++       * s1 and s2 can't both be aligned, and unaligned word loads
++       * can trigger spurious exceptions if we cross a page boundary.
++       * Do it the slow way...
++       */
++1:    ld.ub   r8, s1++
++      ld.ub   r9, s2++
++      sub     r8, r9
++      retne   r8
++      cp.w    r9, 0
++      brne    1b
++      retal   0
++
++      .weak   strcoll
++      strcoll = strcmp
+Index: uClibc-0.9.28-avr32/libc/string/avr32/strcpy.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/strcpy.S     2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,63 @@
++/*
++ * Copyright (C) 2004 Atmel Norway
++ *
++ * To reduce the size, this one might simply call strncpy with len = -1.
++ */
++
++#define dst r9
++#define src r11
++
++      .text
++      .global strcpy
++      .type   strcpy, @function
++strcpy:
++      mov     dst, r12
++
++      pref    src[0]
++
++      /*
++       * Check alignment. If src is aligned but dst isn't, we can't
++       * do much about it...
++       */
++      mov     r8, src
++      andl    r8, 3 COH
++      brne    .Lunaligned_src
++
++.Laligned_copy:
++1:    ld.w    r8, src++
++      tnbz    r8
++      breq    2f
++      st.w    dst++, r8
++      rjmp    1b
++
++2:    /*
++       * Ok, r8 now contains the terminating '\0'. Copy the
++       * remaining bytes individually.
++       */
++      bfextu  r10, r8, 24, 8
++      st.b    dst++, r10
++      cp.w    r10, 0
++      reteq   r12
++      bfextu  r10, r8, 16, 8
++      st.b    dst++, r10
++      cp.w    r10, 0
++      reteq   r12
++      bfextu  r10, r8, 8, 8
++      st.b    dst++, r10
++      cp.w    r10, 0
++      reteq   r12
++      st.b    dst++, r8
++      retal   r12
++
++.Lunaligned_src:
++      /* Copy bytes until we're aligned */
++      rsub    r8, r8, 4
++      add     pc, pc, r8 << 3
++      nop
++      nop
++      ld.ub   r10, src++
++      st.b    dst++, r10
++      cp.w    r10, 0
++      reteq   r12
++
++      rjmp    .Laligned_copy
+Index: uClibc-0.9.28-avr32/libc/string/avr32/stringtest.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/stringtest.c 2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,144 @@
++
++#include <stdio.h>
++#include <string.h>
++#include <time.h>
++#include <sys/mman.h>
++
++#define BUF_SIZE (8 * 1024)
++
++static char *buf1;
++static char *buf1_ref;
++static char *buf2;
++
++extern void *optimized_memcpy(void *dest, void *src, size_t len);
++extern void *optimized_memmove(void *dest, void *src, size_t len);
++extern char *optimized_strcpy(char *dest, char *src);
++extern char *optimized_strncpy(char *dest, char *src, size_t len);
++
++void dump_mismatch(char *buf, char *ref, size_t len)
++{
++      int i, j;
++
++      for (i = 0; i < len; i += 16) {
++              if (memcmp(buf + i, ref + i, 16) == 0)
++                      continue;
++
++              printf("%4x buf:", i);
++              for (j = i; j < (i + 16); j++)
++                      printf(" %02x", buf[j]);
++              printf("\n     ref:");
++              for (j = i; j < (i + 16); j++)
++                      printf(" %02x", ref[j]);
++              printf("\n");
++      }
++}
++
++static void test_memcpy(int src_offset, int dst_offset, int len)
++{
++      clock_t start, old, new;
++      int i;
++
++      memset(buf1, 0x55, BUF_SIZE);
++      memset(buf1_ref, 0x55, BUF_SIZE);
++      memset(buf2, 0xaa, BUF_SIZE);
++
++      printf("Testing memcpy with offsets %d => %d and len %d...",
++             src_offset, dst_offset, len);
++
++      start = clock();
++      for (i = 0; i < 8192; i++)
++              optimized_memcpy(buf1 + dst_offset, buf2 + src_offset, len);
++      new = clock() - start;
++      start = clock();
++      for ( i = 0; i < 8192; i++)
++              memcpy(buf1_ref + dst_offset, buf2 + src_offset, len);
++      old = clock() - start;
++
++      if (memcmp(buf1, buf1_ref, BUF_SIZE) == 0)
++              printf("OK\n");
++      else {
++              printf("FAILED\n");
++              dump_mismatch(buf1, buf1_ref, BUF_SIZE);
++      }
++      printf("CPU time used: %d vs. %d\n", new, old);
++}
++
++static void test_memmove(int src_offset, int dst_offset, int len)
++{
++      clock_t start, old, new;
++
++      memset(buf1, 0x55, BUF_SIZE);
++      memset(buf1_ref, 0x55, BUF_SIZE);
++      memset(buf2, 0xaa, BUF_SIZE);
++
++      printf("Testing memmove with offsets %d => %d and len %d...",
++             src_offset, dst_offset, len);
++
++      start = clock();
++      optimized_memmove(buf1 + dst_offset, buf2 + src_offset, len);
++      new = clock() - start;
++      start = clock();
++      memmove(buf1_ref + dst_offset, buf2 + src_offset, len);
++      old = clock() - start;
++
++      if (memcmp(buf1, buf1_ref, BUF_SIZE) == 0)
++              printf("OK\n");
++      else {
++              printf("FAILED\n");
++              dump_mismatch(buf1, buf1_ref, BUF_SIZE);
++      }
++      printf("CPU time used: %d vs. %d\n", new, old);
++}
++
++int main(int argc, char *argv[])
++{
++      buf2 = mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE,
++                  MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
++      if (buf2 == MAP_FAILED) {
++              perror("Failed to allocate memory for buf2");
++              return 1;
++      }
++      buf1 = mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE,
++                  MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
++      if (buf1 == MAP_FAILED) {
++              perror("Failed to allocate memory for buf1");
++              return 1;
++      }
++      buf1_ref = mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE,
++                      MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
++      if (buf1_ref == MAP_FAILED) {
++              perror("Failed to allocate memory for buf1_ref");
++              return 1;
++      }
++      printf("\n === MEMCPY ===\n\n");
++
++      test_memcpy(0, 0, BUF_SIZE - 32);
++      test_memcpy(0, 0, 1);
++      test_memcpy(0, 0, 31);
++      test_memcpy(0, 0, 32);
++      test_memcpy(0, 0, 127);
++      test_memcpy(0, 0, 128);
++      test_memcpy(4, 4, BUF_SIZE - 32 - 4);
++      test_memcpy(1, 1, BUF_SIZE - 32 - 1);
++      test_memcpy(1, 1, 126);
++      test_memcpy(0, 3, 128);
++      test_memcpy(1, 4, 128);
++      test_memcpy(0, 0, 0);
++
++      printf("\n === MEMMOVE ===\n\n");
++
++      test_memmove(0, 0, BUF_SIZE - 32);
++      test_memmove(0, 0, 1);
++      test_memmove(0, 0, 31);
++      test_memmove(0, 0, 32);
++      test_memmove(0, 0, BUF_SIZE - 33);
++      test_memmove(0, 0, 128);
++      test_memmove(4, 4, BUF_SIZE - 32 - 4);
++      test_memmove(1, 1, BUF_SIZE - 32 - 1);
++      test_memmove(1, 1, BUF_SIZE - 130);
++      test_memmove(0, 3, BUF_SIZE - 128);
++      test_memmove(1, 4, BUF_SIZE - 128);
++      test_memmove(0, 0, 0);
++
++      return 0;
++}
+Index: uClibc-0.9.28-avr32/libc/string/avr32/strlen.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/strlen.S     2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,52 @@
++/*
++ * Copyright (C) 2004 Atmel Norway
++ */
++
++#define str r12
++
++      .text
++      .global strlen
++      .type   strlen, @function
++strlen:
++      mov     r11, r12
++
++      mov     r9, str
++      andl    r9, 3, COH
++      brne    .Lunaligned_str
++
++1:    ld.w    r8, str++
++      tnbz    r8
++      brne    1b
++
++      sub     r12, r11
++      bfextu  r9, r8, 24, 8
++      cp.w    r9, 0
++      subeq   r12, 4
++      reteq   r12
++      bfextu  r9, r8, 16, 8
++      cp.w    r9, 0
++      subeq   r12, 3
++      reteq   r12
++      bfextu  r9, r8, 8, 8
++      cp.w    r9, 0
++      subeq   r12, 2
++      reteq   r12
++      sub     r12, 1
++      retal   r12
++
++.Lunaligned_str:
++      add     pc, pc, r9 << 3
++      sub     r0, r0, 0       /* 4-byte nop */
++      ld.ub   r8, str++
++      sub     r8, r8, 0
++      breq    1f
++      ld.ub   r8, str++
++      sub     r8, r8, 0
++      breq    1f
++      ld.ub   r8, str++
++      sub     r8, r8, 0
++      brne    1b
++
++1:    sub     r12, 1
++      sub     r12, r11
++      retal   r12
+Index: uClibc-0.9.28-avr32/libc/string/avr32/strncpy.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/strncpy.S    2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,77 @@
++/*
++ * Copyright (C) 2004 Atmel Norway
++ */
++
++#define dst r9
++#define src r11
++
++      .text
++      .global strcpy
++      .type   strncpy, @function
++strncpy:
++      mov     dst, r12
++
++      pref    src[0]
++      mov     dst, r12
++
++      /*
++       * Check alignment. If src is aligned but dst isn't, we can't
++       * do much about it...
++       */
++      mov     r8, src
++      andl    r8, 3 COH
++      brne    .Lunaligned_src
++
++.Laligned_copy:
++      sub     r10, 4
++      brlt    3f
++1:    ld.w    r8, src++
++      tnbz    r8
++      breq    2f
++      st.w    dst++, r8
++      sub     r10, 4
++      brne    1b
++
++3:    sub     r10, -4
++      reteq   r12
++
++      /* This is safe as long as src is word-aligned and r10 > 0 */
++      ld.w    r8, src++
++
++2:    /*
++       * Ok, r8 now contains the terminating '\0'. Copy the
++       * remaining bytes individually.
++       */
++      bfextu  r11, r8, 24, 8
++      st.b    dst++, r11
++      cp.w    r11, 0
++      reteq   r12
++      sub     r10, 1
++      reteq   r12
++      bfextu  r11, r8, 16, 8
++      st.b    dst++, r11
++      cp.w    r11, 0
++      reteq   r12
++      sub     r10, 1
++      reteq   r12
++      bfextu  r11, r8, 8, 8
++      st.b    dst++, r11
++      cp.w    r11, 0
++      reteq   r12
++      sub     r10, 1
++      reteq   r12
++      st.b    dst++, r8
++      retal   r12
++
++.Lunaligned_src:
++      /* Copy bytes until we're aligned */
++      min     r8, r8, r10
++      sub     r10, r8
++      sub     r8, 1
++      retlt   r12
++1:    ld.ub   r10, src++
++      st.b    dst++, r10
++      sub     r8, 1
++      brge    1b
++
++      rjmp    .Laligned_copy
+Index: uClibc-0.9.28-avr32/libc/string/avr32/test_memcpy.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28-avr32/libc/string/avr32/test_memcpy.c        2006-10-19 15:05:52.000000000 +0200
+@@ -0,0 +1,66 @@
++
++#include <stdio.h>
++#include <string.h>
++
++#define BUF_SIZE 32768
++
++static char buf1[BUF_SIZE] __attribute__((aligned(32)));
++static char buf1_ref[BUF_SIZE] __attribute__((aligned(32)));
++static char buf2[BUF_SIZE] __attribute__((aligned(32)));
++
++extern void *new_memcpy(void *dest, void *src, size_t len);
++
++void dump_mismatch(char *buf, char *ref, size_t len)
++{
++      int i, j;
++
++      for (i = 0; i < len; i += 16) {
++              if (memcmp(buf + i, ref + i, 16) == 0)
++                      continue;
++
++              printf("% 4x buf:", i);
++              for (j = i; j < (i + 16); j++)
++                      printf(" %02x", buf[j]);
++              printf("\n     ref:");
++              for (j = i; j < (i + 16); j++)
++                      printf(" %02x", ref[j]);
++              printf("\n");
++      }
++}
++
++void test(int src_offset, int dst_offset, int len)
++{
++      memset(buf1, 0x55, sizeof(buf1));
++      memset(buf1_ref, 0x55, sizeof(buf1_ref));
++      memset(buf2, 0xaa, sizeof(buf2));
++
++      printf("Testing with offsets %d => %d and len %d...",
++             src_offset, dst_offset, len);
++
++      new_memcpy(buf1 + dst_offset, buf2 + src_offset, len);
++      memcpy(buf1_ref + dst_offset, buf2 + src_offset, len);
++
++      if (memcmp(buf1, buf1_ref, sizeof(buf1)) == 0)
++              printf("OK\n");
++      else {
++              printf("FAILED\n");
++              dump_mismatch(buf1, buf1_ref, sizeof(buf1));
++      }
++}
++
++int main(int argc, char *argv[])
++{
++      test(0, 0, BUF_SIZE);
++      test(0, 0, 1);
++      test(0, 0, 31);
++      test(0, 0, 32);
++      test(0, 0, 127);
++      test(0, 0, 128);
++      test(4, 4, BUF_SIZE - 4);
++      test(1, 1, BUF_SIZE - 1);
++      test(1, 1, 126);
++      test(0, 3, 128);
++      test(1, 4, 128);
++
++      return 0;
++}
diff --git a/toolchain/uClibc/patches/403-no-create_module-on-avr32.patch b/toolchain/uClibc/patches/403-no-create_module-on-avr32.patch
new file mode 100644 (file)
index 0000000..9bfdc53
--- /dev/null
@@ -0,0 +1,27 @@
+Subject: [PATCH] Don't include create_module() for AVR32
+
+The create_module() system call is obsolete in Linux 2.6, so the
+AVR32 kernel doesn't even have it.
+
+Come to think about it, this should be completely unnecessary as the
+create_module function is only a stub when __NR_create_module is
+undefined.
+---
+
+ libc/sysdeps/linux/common/create_module.c |    3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+Index: uClibc-0.9.28/libc/sysdeps/linux/common/create_module.c
+===================================================================
+--- uClibc-0.9.28.orig/libc/sysdeps/linux/common/create_module.c       2006-02-07 16:48:38.000000000 +0100
++++ uClibc-0.9.28/libc/sysdeps/linux/common/create_module.c    2006-02-07 17:17:14.000000000 +0100
+@@ -61,7 +61,8 @@ unsigned long create_module(const char *
+ {
+   return __create_module(name, size, 0, 0);
+ }
+-#else
++/* create_module is obsolete in Linux 2.6, so AVR32 doesn't have it */
++#elif !defined(__avr32__)
+ /* Sparc, MIPS, etc don't mistake return values for errors. */ 
+ _syscall2(unsigned long, create_module, const char *, name, size_t, size);
+ #endif
diff --git a/toolchain/uClibc/patches/407-ldso-avr32-2.patch b/toolchain/uClibc/patches/407-ldso-avr32-2.patch
new file mode 100644 (file)
index 0000000..ddeb84d
--- /dev/null
@@ -0,0 +1,526 @@
+Subject: [PATCH] ldso: AVR32 support
+
+This implements the AVR32-specific parts of the dynamic linker.
+
+---
+
+ ldso/ldso/avr32/dl-debug.h    |   45 +++++++++
+ ldso/ldso/avr32/dl-startup.h  |  110 ++++++++++++++++++++++++
+ ldso/ldso/avr32/dl-syscalls.h |    5 +
+ ldso/ldso/avr32/dl-sysdep.h   |  103 ++++++++++++++++++++++
+ ldso/ldso/avr32/elfinterp.c   |  191 ++++++++++++++++++++++++++++++++++++++++++
+ ldso/ldso/avr32/resolve.S     |   28 ++++++
+ 6 files changed, 482 insertions(+)
+
+Index: uClibc-0.9.28/ldso/ldso/avr32/dl-debug.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/ldso/ldso/avr32/dl-debug.h   2006-05-05 09:30:43.000000000 +0200
+@@ -0,0 +1,45 @@
++/*
++ * AVR32 ELF shared libary loader support
++ *
++ * Copyright (C) 2005 Atmel Norway
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++static const char *_dl_reltypes_tab[] = {
++    "R_AVR32_NONE",
++    "R_AVR32_32", "R_AVR32_16", "R_AVR32_8",
++    "R_AVR32_32_PCREL", "R_AVR32_16_PCREL", "R_AVR32_8_PCREL",
++    "R_AVR32_DIFF32", "R_AVR32_DIFF16", "R_AVR32_DIFF8",
++    "R_AVR32_GOT32", "R_AVR32_GOT16", "R_AVR32_GOT8",
++    "R_AVR32_21S", "R_AVR32_16U", "R_AVR32_16S", "R_AVR32_8S", "R_AVR32_8S_EXT",
++    "R_AVR32_22H_PCREL", "R_AVR32_18W_PCREL", "R_AVR32_16B_PCREL",
++    "R_AVR32_16N_PCREL", "R_AVR32_14UW_PCREL", "R_AVR32_11H_PCREL",
++    "R_AVR32_10UW_PCREL", "R_AVR32_9H_PCREL", "R_AVR32_9UW_PCREL",
++    "R_AVR32_HI16", "R_AVR32_LO16",
++    "R_AVR32_GOTPC", "R_AVR32_GOTCALL", "R_AVR32_LDA_GOT",
++    "R_AVR32_GOT21S", "R_AVR32_GOT18SW", "R_AVR32_GOT16S", "R_AVR32_GOT7UW",
++    "R_AVR32_32_CPENT", "R_AVR32_CPCALL", "R_AVR32_16_CP", "R_AVR32_9W_CP",
++    "R_AVR32_RELATIVE", "R_AVR32_GLOB_DAT", "R_AVR32_JMP_SLOT",
++    "R_AVR32_ALIGN",
++};
+Index: uClibc-0.9.28/ldso/ldso/avr32/dl-startup.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/ldso/ldso/avr32/dl-startup.h 2006-05-05 09:29:45.000000000 +0200
+@@ -0,0 +1,110 @@
++/* vi: set sw=4 ts=4: */
++/*
++ * Architecture specific code used by dl-startup.c
++ * Copyright (C) 2005 Atmel Norway
++ */
++
++/* This is the library loader's main entry point. Let _dl_boot2 do its
++ * initializations and jump to the application's entry point
++ * afterwards. */
++asm(  "       .text\n"
++      "       .global _start\n"
++      "       .type   _start,@function\n"
++      "_start:\n"
++      /* All arguments are on the stack initially */
++      "       mov     r12, sp\n"
++      "       rcall   _dl_start\n"
++      /* Returns user entry point in r12. Save it. */
++      "       mov     r0, r12\n"
++      /* We're PIC, so get the Global Offset Table */
++      "       lddpc   r6, .L_GOT\n"
++      ".L_RGOT:\n"
++      "       rsub    r6, pc\n"
++      /* Adjust argc and argv according to _dl_skip_args */
++      "       ld.w    r1, r6[_dl_skip_args@got]\n"
++      "       ld.w    r1, r1[0]\n"
++      "       ld.w    r2, sp++\n"
++      "       sub     r2, r1\n"
++      "       add     sp, sp, r1 << 2\n"
++      "       st.w    --sp, r2\n"
++      /* Load the finalizer function */
++      "       ld.w    r12, r6[_dl_fini@got]\n"
++      /* Jump to the user's entry point */
++      "       mov     pc, r0\n\n"
++
++      "       .align  2\n"
++      ".L_GOT:"
++      "       .long   .L_RGOT - _GLOBAL_OFFSET_TABLE_\n"
++      "       .size   _start, . - _start\n"
++      "       .previous\n");
++
++/* Get a pointer to the argv array.  On many platforms this can be just
++ * the address if the first argument, on other platforms we need to
++ * do something a little more subtle here. */
++#define GET_ARGV(ARGVP, ARGS) ARGVP = ((unsigned long *)ARGS + 1)
++
++
++/* We can't call functions before the GOT has been initialized */
++#define NO_FUNCS_BEFORE_BOOTSTRAP
++
++/*
++ * Relocate the GOT during dynamic loader bootstrap.  This will add
++ * the load address to all entries in the GOT, which is necessary
++ * because the linker doesn't generate R_AVR32_RELATIVE relocs for the
++ * GOT.
++ */
++static __always_inline
++void PERFORM_BOOTSTRAP_GOT(struct elf_resolve *tpnt)
++{
++      Elf32_Addr i, nr_got;
++      register Elf32_Addr *__r6 __asm__("r6");
++      Elf32_Addr *got = __r6;
++
++      nr_got = tpnt->dynamic_info[DT_AVR32_GOTSZ_IDX] / sizeof(*got);
++      for (i = 2; i < nr_got; i++)
++              got[i] += tpnt->loadaddr;
++}
++
++#define PERFORM_BOOTSTRAP_GOT(tpnt) PERFORM_BOOTSTRAP_GOT(tpnt)
++
++/* Handle relocation of the symbols in the dynamic loader. */
++static __always_inline
++void PERFORM_BOOTSTRAP_RELOC(ELF_RELOC *rpnt, unsigned long *reloc_addr,
++                           unsigned long symbol_addr,
++                           unsigned long load_addr, Elf32_Sym *symtab)
++{
++      switch(ELF32_R_TYPE(rpnt->r_info)) {
++      case R_AVR32_NONE:
++              break;
++      case R_AVR32_GLOB_DAT:
++      case R_AVR32_JMP_SLOT:
++              *reloc_addr = symbol_addr;
++              break;
++      case R_AVR32_RELATIVE:
++              SEND_STDERR_DEBUG("Applying RELATIVE relocation: ");
++              SEND_ADDRESS_STDERR_DEBUG(load_addr, 0);
++              SEND_STDERR_DEBUG(" + ");
++              SEND_ADDRESS_STDERR_DEBUG(rpnt->r_addend, 1);
++              *reloc_addr = load_addr + rpnt->r_addend;
++              break;
++      default:
++              SEND_STDERR("BOOTSTRAP_RELOC: unhandled reloc_type ");
++              SEND_NUMBER_STDERR(ELF32_R_TYPE(rpnt->r_info), 1);
++              SEND_STDERR("REL, SYMBOL, LOAD: ");
++              SEND_ADDRESS_STDERR(reloc_addr, 0);
++              SEND_STDERR(", ");
++              SEND_ADDRESS_STDERR(symbol_addr, 0);
++              SEND_STDERR(", ");
++              SEND_ADDRESS_STDERR(load_addr, 1);
++              _dl_exit(1);
++      }
++}
++
++/* Transfer control to the user's application, once the dynamic loader
++ * is done. This routine has to exit the current function, then call
++ * the _dl_elf_main function.
++ *
++ * Since our _dl_boot will simply call whatever is returned by
++ * _dl_boot2, we can just return the address we're supposed to
++ * call.  */
++#define START()       return _dl_elf_main;
+Index: uClibc-0.9.28/ldso/ldso/avr32/dl-syscalls.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/ldso/ldso/avr32/dl-syscalls.h        2006-05-05 09:29:25.000000000 +0200
+@@ -0,0 +1,5 @@
++/* We can't use the real errno in ldso, since it has not yet
++ * been dynamicly linked in yet. */
++extern int _dl_errno;
++#define __set_errno(X) {(_dl_errno) = (X);}
++#include "sys/syscall.h"
+Index: uClibc-0.9.28/ldso/ldso/avr32/dl-sysdep.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/ldso/ldso/avr32/dl-sysdep.h  2006-05-05 09:30:43.000000000 +0200
+@@ -0,0 +1,103 @@
++/* vi: set sw=4 ts=4: */
++/*
++ * Various assembly language/system dependent hacks that are required
++ * so that we can minimize the amount of platform specific code.
++ * Copyright (C) 2004-2005 Atmel Norway
++ */
++
++/* Define this if the system uses RELOCA. */
++#define ELF_USES_RELOCA
++
++#include <elf.h>
++
++#define ARCH_NUM 1
++#define DT_AVR32_GOTSZ_IDX    (DT_NUM + OS_NUM)
++
++#define ARCH_DYNAMIC_INFO(dpnt, dynamic, debug_addr)                  \
++      do {                                                            \
++              if (dpnt->d_tag == DT_AVR32_GOTSZ)                      \
++                      dynamic[DT_AVR32_GOTSZ_IDX] = dpnt->d_un.d_val; \
++      } while (0)
++
++/* Initialization sequence for the application/library GOT. */
++#define INIT_GOT(GOT_BASE,MODULE)                                     \
++      do {                                                            \
++              unsigned long i, nr_got;                                \
++                                                                      \
++              GOT_BASE[0] = (unsigned long) _dl_linux_resolve;        \
++              GOT_BASE[1] = (unsigned long) MODULE;                   \
++                                                                      \
++              /* Add load address displacement to all GOT entries */  \
++              nr_got = MODULE->dynamic_info[DT_AVR32_GOTSZ_IDX] / 4;  \
++              for (i = 2; i < nr_got; i++)                            \
++                      GOT_BASE[i] += (unsigned long)MODULE->loadaddr; \
++      } while (0)
++
++#define do_rem(result, n, base)       ((result) = (n) % (base))
++
++/* Here we define the magic numbers that this dynamic loader should accept */
++#define MAGIC1 EM_AVR32
++#undef MAGIC2
++
++/* Used for error messages */
++#define ELF_TARGET "AVR32"
++
++unsigned long _dl_linux_resolver(unsigned long got_offset, unsigned long *got);
++
++/* 4096 bytes alignment */
++#define PAGE_ALIGN 0xfffff000
++#define ADDR_ALIGN 0xfff
++#define OFFS_ALIGN 0x7ffff000
++
++#define elf_machine_type_class(type)                          \
++      ((type == R_AVR32_JMP_SLOT) * ELF_RTYPE_CLASS_PLT)
++
++/* AVR32 doesn't need any COPY relocs */
++#define DL_NO_COPY_RELOCS
++
++/* Return the link-time address of _DYNAMIC.  Conveniently, this is the
++   first element of the GOT.  This must be inlined in a function which
++   uses global data.  */
++static inline Elf32_Addr
++elf_machine_dynamic (void)
++{
++      register Elf32_Addr *got asm ("r6");
++      return *got;
++}
++
++/* Return the run-time load address of the shared object.  */
++static inline Elf32_Addr
++elf_machine_load_address (void)
++{
++      extern void __dl_start asm("_dl_start");
++      Elf32_Addr got_addr = (Elf32_Addr) &__dl_start;
++      Elf32_Addr pcrel_addr;
++
++      asm   ("        lddpc   %0, 2f\n"
++             "1:      add     %0, pc\n"
++             "        rjmp    3f\n"
++             "        .align  2\n"
++             "2:      .long   _dl_start - 1b\n"
++             "3:\n"
++             : "=r"(pcrel_addr) : : "cc");
++
++      return pcrel_addr - got_addr;
++}
++
++/*
++ * Perform any RELATIVE relocations specified by DT_RELCOUNT.
++ * Currently, we don't use that tag, but we might in the future as
++ * this would reduce the startup time somewhat (although probably not by much).
++ */
++static inline void
++elf_machine_relative (Elf32_Addr load_off, const Elf32_Addr rel_addr,
++                    Elf32_Word relative_count)
++{
++      Elf32_Rela *rpnt = (void *)rel_addr;
++
++      do {
++              Elf32_Addr *reloc_addr;
++              reloc_addr = (void *)(load_off + (rpnt++)->r_offset);
++              *reloc_addr = load_off + rpnt->r_addend;
++      } while (--relative_count);
++}
+Index: uClibc-0.9.28/ldso/ldso/avr32/elfinterp.c
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/ldso/ldso/avr32/elfinterp.c  2006-05-05 09:30:43.000000000 +0200
+@@ -0,0 +1,191 @@
++/*
++ * AVR32 ELF shared library loader suppport
++ *
++ * Copyright (C) 2004-2006 Atmel Corporation
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++unsigned long _dl_linux_resolver(unsigned long got_offset, unsigned long *got)
++{
++      struct elf_resolve *tpnt = (struct elf_resolve *)got[1];
++      Elf32_Sym *sym;
++      unsigned long local_gotno;
++      unsigned long gotsym;
++      unsigned long new_addr;
++      char *strtab, *symname;
++      unsigned long *entry;
++      unsigned long sym_index = got_offset / 4;
++
++#if 0
++      local_gotno = tpnt->dynamic_info[DT_AVR32_LOCAL_GOTNO];
++      gotsym = tpnt->dynamic_info[DT_AVR32_GOTSYM];
++
++      sym = ((Elf32_Sym *)(tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr))
++              + sym_index;
++      strtab = (char *)(tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++      symname = strtab + sym->st_name;
++
++#if 0
++      new_addr = (unsigned long) _dl_find_hash(strtab + sym->st_name,
++                                               tpnt->symbol_scope, tpnt,
++                                               resolver);
++#endif
++
++      entry = (unsigned long *)(got + local_gotno + sym_index - gotsym);
++      *entry = new_addr;
++#endif
++
++      return new_addr;
++}
++
++static int
++_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope,
++        unsigned long rel_addr, unsigned long rel_size,
++        int (*reloc_func)(struct elf_resolve *tpnt, struct dyn_elf *scope,
++                          Elf32_Rela *rpnt, Elf32_Sym *symtab, char *strtab))
++{
++      Elf32_Sym *symtab;
++      Elf32_Rela *rpnt;
++      char *strtab;
++      int i;
++
++      rpnt = (Elf32_Rela *)rel_addr;
++      rel_size /= sizeof(Elf32_Rela);
++      symtab = (Elf32_Sym *)tpnt->dynamic_info[DT_SYMTAB];
++      strtab = (char *)tpnt->dynamic_info[DT_STRTAB];
++
++      for (i = 0; i < rel_size; i++, rpnt++) {
++              int symtab_index, res;
++
++              symtab_index = ELF32_R_SYM(rpnt->r_info);
++
++              debug_sym(symtab, strtab, symtab_index);
++              debug_reloc(symtab, strtab, rpnt);
++
++              res = reloc_func(tpnt, scope, rpnt, symtab, strtab);
++
++              if (res == 0)
++                      continue;
++
++              _dl_dprintf(2, "\n%s: ", _dl_progname);
++
++              if (symtab_index)
++                      _dl_dprintf(2, "symbol '%s': ",
++                                  strtab + symtab[symtab_index].st_name);
++
++              if (res < 0) {
++                      int reloc_type = ELF32_R_TYPE(rpnt->r_info);
++#if defined(__SUPPORT_LD_DEBUG__)
++                      _dl_dprintf(2, "can't handle reloc type %s\n",
++                                  _dl_reltypes(reloc_type));
++#else
++                      _dl_dprintf(2, "can't handle reloc type %x\n",
++                                  reloc_type);
++#endif
++                      _dl_exit(-res);
++              } else {
++                      _dl_dprintf(2, "can't resolve symbol\n");
++                      return res;
++              }
++      }
++
++      return 0;
++}
++
++static int _dl_do_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope,
++                      Elf32_Rela *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++      int reloc_type;
++      int symtab_index;
++      char *symname;
++      unsigned long *reloc_addr;
++      unsigned long symbol_addr;
++#if defined(__SUPPORT_LD_DEBUG__)
++      unsigned long old_val;
++#endif
++
++      reloc_addr = (unsigned long *)(tpnt->loadaddr + rpnt->r_offset);
++      reloc_type = ELF32_R_TYPE(rpnt->r_info);
++      symtab_index = ELF32_R_SYM(rpnt->r_info);
++      symbol_addr = 0;
++      symname = strtab + symtab[symtab_index].st_name;
++
++      if (symtab_index) {
++              symbol_addr = (unsigned long)
++                      _dl_find_hash(strtab + symtab[symtab_index].st_name,
++                                    tpnt->symbol_scope, tpnt,
++                                    elf_machine_type_class(reloc_type));
++
++              /* Allow undefined references to weak symbols */
++              if (!symbol_addr &&
++                  ELF32_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK) {
++                      _dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
++                                  _dl_progname, symname);
++                      return 0;
++              }
++      }
++
++#if defined(__SUPPORT_LD_DEBUG__)
++      old_val = *reloc_addr;
++#endif
++      switch (reloc_type) {
++      case R_AVR32_NONE:
++              break;
++      case R_AVR32_GLOB_DAT:
++      case R_AVR32_JMP_SLOT:
++              *reloc_addr = symbol_addr + rpnt->r_addend;
++              break;
++      case R_AVR32_RELATIVE:
++              *reloc_addr = (unsigned long)tpnt->loadaddr
++                      + rpnt->r_addend;
++              break;
++      default:
++              return -1;
++      }
++
++#if defined(__SUPPORT_LD_DEBUG__)
++      if (_dl_debug_reloc && _dl_debug_detail)
++              _dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x\n",
++                          old_val, *reloc_addr);
++#endif
++
++      return 0;
++}
++
++void _dl_parse_lazy_relocation_information(struct dyn_elf *rpnt,
++                                         unsigned long rel_addr,
++                                         unsigned long rel_size)
++{
++      /* TODO: Might want to support this in order to get faster
++       * startup times... */
++}
++
++int _dl_parse_relocation_information(struct dyn_elf *rpnt,
++                                   unsigned long rel_addr,
++                                   unsigned long rel_size)
++{
++      return _dl_parse(rpnt->dyn, rpnt->dyn->symbol_scope, rel_addr, rel_size,
++                       _dl_do_reloc);
++}
+Index: uClibc-0.9.28/ldso/ldso/avr32/resolve.S
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/ldso/ldso/avr32/resolve.S    2006-05-05 09:29:25.000000000 +0200
+@@ -0,0 +1,28 @@
++/*
++ * Linux dynamic resolving code for AVR32. Fixes up the GOT entry as
++ * indicated in register r12 and jumps to the resolved address.
++ *
++ * This file is subject to the terms and conditions of the GNU Lesser General
++ * Public License.  See the file "COPYING.LIB" in the main directory of this
++ * archive for more details.
++ *
++ * Copyright (C) 2004 Atmel Norway
++ */
++
++#define ip r5
++
++      .text
++      .global _dl_linux_resolve
++      .type   _dl_linux_resolve,@function
++_dl_linux_resolve:
++      /* The PLT code pushed r8 for us. It contains the address of this
++         function's GOT entry, that is entry 0. ip contains the address
++         of the GOT entry of the function we wanted to call. */
++      stm     --sp, r9-r12, lr
++      mov     r11, r8
++      sub     r12, ip, r8
++      rcall   _dl_linux_resolver
++      mov     ip, r12
++      popm    r8-r12,lr
++      mov     pc, ip
++      .size   _dl_linux_resolve, . - _dl_linux_resolve
diff --git a/toolchain/uClibc/patches/409-ldso-avr32-startup-hack.patch b/toolchain/uClibc/patches/409-ldso-avr32-startup-hack.patch
new file mode 100644 (file)
index 0000000..0cdc2cc
--- /dev/null
@@ -0,0 +1,40 @@
+Subject: [PATCH] ldso: AVR32 startup hack
+
+AVR32 needs to do both PERFORM_BOOTSTRAP_GOT and a full relocation of
+the GOT. I don't quite remember why, but I think it's because some GOT
+entries just need the load address added to them, while the rest need
+the full relocation code.
+
+This patch should be revisited to figure out whether we're processing
+relocations against undefined symbols and whether that's something we
+should be doing...
+
+---
+
+ ldso/ldso/dl-startup.c |    6 ++++--
+ 1 file changed, 4 insertions(+), 2 deletions(-)
+
+Index: uClibc-0.9.28/ldso/ldso/dl-startup.c
+===================================================================
+--- uClibc-0.9.28.orig/ldso/ldso/dl-startup.c  2006-02-07 16:49:27.000000000 +0100
++++ uClibc-0.9.28/ldso/ldso/dl-startup.c       2006-02-07 17:12:09.000000000 +0100
+@@ -217,7 +217,9 @@ static void * __attribute_used__ _dl_sta
+       /* some arches (like MIPS) we have to tweak the GOT before relocations */
+       PERFORM_BOOTSTRAP_GOT(tpnt);
+-#else
++#endif
++
++#if !defined(PERFORM_BOOTSTRAP_GOT) || defined(__avr32__)
+       /* OK, now do the relocations.  We do not do a lazy binding here, so
+          that once we are done, we have considerably more flexibility. */
+@@ -259,7 +261,7 @@ static void * __attribute_used__ _dl_sta
+                               rel_addr += relative_count * sizeof(ELF_RELOC);;
+                       }
+-                      rpnt = (ELF_RELOC *) (rel_addr + load_addr);
++                      rpnt = (ELF_RELOC *) (rel_addr /* + load_addr */);
+                       for (i = 0; i < rel_size; i += sizeof(ELF_RELOC), rpnt++) {
+                               reloc_addr = (unsigned long *) (load_addr + (unsigned long) rpnt->r_offset);
+                               symtab_index = ELF_R_SYM(rpnt->r_info);
diff --git a/toolchain/uClibc/patches/410-ldd-avr32-support.patch b/toolchain/uClibc/patches/410-ldd-avr32-support.patch
new file mode 100644 (file)
index 0000000..dd61f17
--- /dev/null
@@ -0,0 +1,25 @@
+Subject: [PATCH] ldd: AVR32 support
+
+Add AVR32-specific definitions to ldd.
+
+---
+
+ utils/ldd.c |    5 +++++
+ 1 file changed, 5 insertions(+)
+
+Index: uClibc-0.9.28/utils/ldd.c
+===================================================================
+--- uClibc-0.9.28.orig/utils/ldd.c     2006-02-07 16:48:02.000000000 +0100
++++ uClibc-0.9.28/utils/ldd.c  2006-02-07 17:13:00.000000000 +0100
+@@ -56,6 +56,11 @@
+ #define ELFCLASSM     ELFCLASS32
+ #endif
++#if defined(__avr32__)
++#define MATCH_MACHINE(x) (x == EM_AVR32)
++#define ELFCLASSM     ELFCLASS32
++#endif
++
+ #if defined(__s390__)
+ #define MATCH_MACHINE(x) (x == EM_S390)
+ #define ELFCLASSM     ELFCLASS32
diff --git a/toolchain/uClibc/patches/411-libpthread-avr32.patch b/toolchain/uClibc/patches/411-libpthread-avr32.patch
new file mode 100644 (file)
index 0000000..5277677
--- /dev/null
@@ -0,0 +1,105 @@
+Subject: [PATCH] libpthread: AVR32 support
+
+Implement pt-machine.h for AVR32.
+---
+
+ libpthread/linuxthreads/sysdeps/avr32/pt-machine.h |   92 +++++++++++++++++++++
+ 1 file changed, 92 insertions(+)
+
+Index: uClibc-0.9.28/libpthread/linuxthreads/sysdeps/avr32/pt-machine.h
+===================================================================
+--- /dev/null  1970-01-01 00:00:00.000000000 +0000
++++ uClibc-0.9.28/libpthread/linuxthreads/sysdeps/avr32/pt-machine.h   2006-02-07 17:14:47.000000000 +0100
+@@ -0,0 +1,92 @@
++/* Machine-dependent pthreads configuration and inline functions.
++
++   Copyright (C) 2005 Atmel Norway
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public License as
++   published by the Free Software Foundation; either version 2.1 of the
++   License, or (at your option) any later version.
++
++   The GNU C Library 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
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; see the file COPYING.LIB.  If not,
++   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
++   Boston, MA 02111-1307, USA.  */
++
++#ifndef _PT_MACHINE_H
++#define _PT_MACHINE_H   1
++
++#include <features.h>
++
++static inline int
++_test_and_set (int *p, int v) __THROW
++{
++      int result;
++
++      __asm__ __volatile__(
++              "/* Inline test and set */\n"
++              "1:     ssrf    5\n"
++              "       ld.w    %0, %2\n"
++              "       tst     %0, %3\n"
++              "       breq    2f\n"
++              "       stcond  %1, %3\n"
++              "       brne    1b\n"
++              "2:"
++              : "=&r"(result), "=m"(*p)
++              : "m"(*p), "r"(v)
++              : "memory", "cc");
++
++      return result;
++}
++
++#ifndef PT_EI
++# define PT_EI extern inline
++#endif
++
++extern long int testandset (int *spinlock);
++extern int __compare_and_swap (long int *p, long int oldval, long int newval);
++
++/* Spinlock implementation; required.  */
++PT_EI long int
++testandset (int *spinlock)
++{
++      return _test_and_set(spinlock, 1);
++}
++
++
++/* Get some notion of the current stack.  Need not be exactly the top
++   of the stack, just something somewhere in the current frame.  */
++#define CURRENT_STACK_FRAME  stack_pointer
++register char * stack_pointer __asm__ ("sp");
++
++/* Compare-and-swap for semaphores. */
++
++#define HAS_COMPARE_AND_SWAP
++PT_EI int
++__compare_and_swap(long int *p, long int oldval, long int newval)
++{
++      long int result, tmp;
++
++      __asm__ __volatile__(
++              "/* Inline compare and swap */\n"
++              "1:     ssrf    5\n"
++              "       ld.w    %1, %3\n"
++              "       cp.w    %1, %5\n"
++              "       sreq    %0\n"
++              "       brne    2f\n"
++              "       stcond  %2, %4\n"
++              "       brne    1b\n"
++              "2:"
++              : "=&r"(result), "=&r"(tmp), "=m"(*p)
++              : "m"(*p), "r"(newval), "r"(oldval)
++              : "cc", "memory");
++
++      return result;
++}
++
++#endif /* pt-machine.h */
diff --git a/toolchain/uClibc/patches/412-sync-fcntl-h-with-linux-kernel.patch b/toolchain/uClibc/patches/412-sync-fcntl-h-with-linux-kernel.patch
new file mode 100644 (file)
index 0000000..ae6de2b
--- /dev/null
@@ -0,0 +1,54 @@
+---
+ libc/sysdeps/linux/avr32/bits/fcntl.h |   33 +++++++++++++++++----------------
+ 1 file changed, 17 insertions(+), 16 deletions(-)
+
+Index: uClibc-0.9.28-avr32/libc/sysdeps/linux/avr32/bits/fcntl.h
+===================================================================
+--- uClibc-0.9.28-avr32.orig/libc/sysdeps/linux/avr32/bits/fcntl.h     2006-11-23 17:38:30.000000000 +0100
++++ uClibc-0.9.28-avr32/libc/sysdeps/linux/avr32/bits/fcntl.h  2006-11-23 17:52:15.000000000 +0100
+@@ -11,28 +11,29 @@
+ /* open/fcntl - O_SYNC is only implemented on blocks devices and on files
+    located on an ext2 file system */
+-#define O_ACCMODE       0003
+-#define O_RDONLY          00
+-#define O_WRONLY          01
+-#define O_RDWR                    02
+-#define O_CREAT                 0100  /* not fcntl */
+-#define O_EXCL                  0200  /* not fcntl */
+-#define O_NOCTTY        0400  /* not fcntl */
+-#define O_TRUNC                01000  /* not fcntl */
+-#define O_APPEND       02000
+-#define O_NONBLOCK     04000
++#define O_ACCMODE     00000003
++#define O_RDONLY      00000000
++#define O_WRONLY      00000001
++#define O_RDWR                00000002
++#define O_CREAT               00000100        /* not fcntl */
++#define O_EXCL                00000200        /* not fcntl */
++#define O_NOCTTY      00000400        /* not fcntl */
++#define O_TRUNC               00001000        /* not fcntl */
++#define O_APPEND      00002000
++#define O_NONBLOCK    00004000
+ #define O_NDELAY      O_NONBLOCK
+-#define O_SYNC                010000
+-#define O_ASYNC               020000
++#define O_SYNC                00010000
++#define O_ASYNC               00020000
+ #ifdef __USE_GNU
+-# define O_DIRECTORY  040000  /* must be a directory */
+-# define O_NOFOLLOW   0100000 /* don't follow links */
+-# define O_DIRECT     0200000 /* direct disk access */
++# define O_DIRECT     00040000        /* must be a directory */
++# define O_DIRECTORY  00200000        /* direct disk access */
++# define O_NOFOLLOW   00400000        /* don't follow links */
++# define O_NOATIME    01000000        /* don't set atime */
+ #endif
+ #ifdef __USE_LARGEFILE64
+-# define O_LARGEFILE  0400000
++# define O_LARGEFILE  00100000
+ #endif
+ /* For now Linux has synchronisity options for data and read operations.