Ticket #24375: avr-binutils.diff

File avr-binutils.diff, 220.3 KB (added by konkers@…, 15 years ago)
  • avr-binutils

    diff -ruN avr-binutils.orig/Portfile avr-binutils/Portfile
    old new  
    33PortSystem                      1.0
    44name                            avr-binutils
    55version                         2.20
     6revision                        1
    67
    78# Parameters for this port.
    89set crossgcc-target avr
     
    5556
    5657build.dir               ${workpath}/build
    5758                                       
    58 # We don't want the etc module.
    59 post-extract {
    60         system "rm -rf ${worksrcpath}/etc"
    61 }
     59patchfiles patch-aa \
     60           patch-as-dwarf \
     61           patch-as-dwarf-avrstudio \
     62           patch-avr-size \
     63           patch-coff-avr \
     64           patch-newdevices \
     65           patch-newsections \
     66           patch-xmega
     67
    6268
    6369post-patch {
    6470        namespace eval crossgcc {}
  • files/patch-aa

    diff -ruN avr-binutils.orig/files/patch-aa avr-binutils/files/patch-aa
    old new  
     1--- etc/Makefile.in~    2009-07-31 00:44:48.000000000 +0200
     2+++ etc/Makefile.in     2010-03-03 17:13:29.000000000 +0100
     3@@ -64,7 +64,8 @@
     4 HTMLFILES = standards.html configure.html
     5 
     6 all: info
     7-install: install-info
     8+#install: install-info
     9+install:
     10 
     11 uninstall:
     12 
     13--- libiberty/Makefile.in~      2009-08-23 21:03:58.000000000 +0200
     14+++ libiberty/Makefile.in       2010-03-03 17:14:00.000000000 +0100
     15@@ -321,7 +321,8 @@
     16 @MAINT@        echo stamp > stamp-functions
     17 
     18 INSTALL_DEST = @INSTALL_DEST@
     19-install: install_to_$(INSTALL_DEST) install-subdir
     20+#install: install_to_$(INSTALL_DEST) install-subdir
     21+install:
     22 
     23 # This is tricky.  Even though CC in the Makefile contains
     24 # multilib-specific flags, it's overridden by FLAGS_TO_PASS from the
     25--- bfd/Makefile.in~    2009-10-16 13:47:48.000000000 +0200
     26+++ bfd/Makefile.in     2010-03-03 17:19:17.000000000 +0100
     27@@ -1673,8 +1673,9 @@
     28        for dir in "$(DESTDIR)$(bfdlibdir)" "$(DESTDIR)$(bfdincludedir)"; do \
     29          test -z "$$dir" || $(MKDIR_P) "$$dir"; \
     30        done
     31-install: $(BUILT_SOURCES)
     32-       $(MAKE) $(AM_MAKEFLAGS) install-recursive
     33+#install: $(BUILT_SOURCES)
     34+#      $(MAKE) $(AM_MAKEFLAGS) install-recursive
     35+install:
     36 install-exec: install-exec-recursive
     37 install-data: install-data-recursive
     38 uninstall: uninstall-recursive
     39--- opcodes/Makefile.in~        2009-09-07 14:08:03.000000000 +0200
     40+++ opcodes/Makefile.in 2010-03-03 17:19:43.000000000 +0100
     41@@ -1051,7 +1051,8 @@
     42        for dir in "$(DESTDIR)$(bfdlibdir)" "$(DESTDIR)$(bfdincludedir)"; do \
     43          test -z "$$dir" || $(MKDIR_P) "$$dir"; \
     44        done
     45-install: install-recursive
     46+#install: install-recursive
     47+install:
     48 install-exec: install-exec-recursive
     49 install-data: install-data-recursive
     50 uninstall: uninstall-recursive
  • files/patch-as-dwarf

    diff -ruN avr-binutils.orig/files/patch-as-dwarf avr-binutils/files/patch-as-dwarf
    old new  
     1diff -ru binutils-2.19.1.orig/gas/config/tc-avr.h binutils-2.19.1/gas/config/tc-avr.h
     2--- gas/config/tc-avr.h Tue Jul  3 14:01:04 2007
     3+++ gas/config/tc-avr.h Thu Apr 16 20:46:54 2009
     4@@ -147,3 +147,6 @@
     5 
     6 /* This target is buggy, and sets fix size too large.  */
     7 #define TC_FX_SIZE_SLACK(FIX) 2
     8+
     9+/* keep DWARF2_ADDR_SIZE in consistency with C compiler produced information */
     10+#define DWARF2_ADDR_SIZE(bfd) 4
  • files/patch-as-dwarf-avrstudio

    diff -ruN avr-binutils.orig/files/patch-as-dwarf-avrstudio avr-binutils/files/patch-as-dwarf-avrstudio
    old new  
     1--- gas/dwarf2dbg.c.orig        2009-09-14 13:43:26.000000000 +0200
     2+++ gas/dwarf2dbg.c     2010-03-04 11:13:52.000000000 +0100
     3@@ -112,8 +112,11 @@
     4    Note: If you want to change this, you'll have to update the
     5    "standard_opcode_lengths" table that is emitted below in
     6    out_debug_line().  */
     7+#ifndef TC_AVR
     8 #define DWARF2_LINE_OPCODE_BASE                13
     9-
     10+#else
     11+#define DWARF2_LINE_OPCODE_BASE                10
     12+#endif
     13 #ifndef DWARF2_LINE_BASE
     14   /* Minimum line offset in a special line info. opcode.  This value
     15      was chosen to give a reasonable range of values.  */
     16@@ -1439,9 +1442,11 @@
     17   out_byte (0);                        /* DW_LNS_set_basic_block */
     18   out_byte (0);                        /* DW_LNS_const_add_pc */
     19   out_byte (1);                        /* DW_LNS_fixed_advance_pc */
     20+#ifndef TC_AVR
     21   out_byte (0);                        /* DW_LNS_set_prologue_end */
     22   out_byte (0);                        /* DW_LNS_set_epilogue_begin */
     23   out_byte (1);                        /* DW_LNS_set_isa */
     24+#endif
     25 
     26   out_file_list ();
     27 
  • files/patch-avr-size

    diff -ruN avr-binutils.orig/files/patch-avr-size avr-binutils/files/patch-avr-size
    old new  
     1AVR specific only
     2===========================================================
     3--- binutils/size.c     2007-08-06 13:56:14.000000000 -0600
     4+++ binutils/size.c     2007-09-13 09:13:10.281250000 -0600
     5@@ -36,10 +36,31 @@
     6 #include "getopt.h"
     7 #include "bucomm.h"
     8 
     9-#ifndef BSD_DEFAULT
     10-#define BSD_DEFAULT 1
     11+typedef enum
     12+{
     13+    format_sysv = 0,
     14+    format_bsd = 1,
     15+    format_avr = 2,
     16+} format_type_t;
     17+
     18+
     19+/* Set the default format. */
     20+#define FORMAT_DEFAULT_SYSV 0
     21+#define FORMAT_DEFAULT_BSD 1
     22+#define FORMAT_DEFAULT_AVR 0
     23+
     24+#if FORMAT_DEFAULT_SYSV
     25+    #define FORMAT_DEFAULT format_sysv
     26+    #define FORMAT_NAME "sysv"
     27+#elif FORMAT_DEFAULT_BSD
     28+    #define FORMAT_DEFAULT format_bsd
     29+    #define FORMAT_NAME "berkeley"
     30+#elif FORMAT_DEFAULT_AVR
     31+    #define FORMAT_DEFAULT format_avr
     32+    #define FORMAT_NAME "avr"
     33 #endif
     34 
     35+
     36 /* Program options.  */
     37 
     38 static enum
     39@@ -48,9 +69,8 @@ static enum
     40   }
     41 radix = decimal;
     42 
     43-/* 0 means use AT&T-style output.  */
     44-static int berkeley_format = BSD_DEFAULT;
     45 
     46+format_type_t format = FORMAT_DEFAULT;
     47 static int show_version = 0;
     48 static int show_help = 0;
     49 static int show_totals = 0;
     50@@ -64,6 +84,238 @@ static bfd_size_type total_textsize;
     51 /* Program exit status.  */
     52 static int return_code = 0;
     53 
     54+
     55+/* AVR Size specific stuff */
     56+
     57+#define AVR64 64UL
     58+#define AVR128 128UL
     59+#define AVR256 256UL
     60+#define AVR512 512UL
     61+#define AVR1K 1024UL
     62+#define AVR2K 2048UL
     63+#define AVR4K 4096UL
     64+#define AVR8K 8192UL
     65+#define AVR16K 16384UL
     66+#define AVR20K 20480UL
     67+#define AVR24K 24576UL
     68+#define AVR32K 32768UL
     69+#define AVR36K 36864UL
     70+#define AVR40K 40960UL
     71+#define AVR64K 65536UL
     72+#define AVR68K 69632UL
     73+#define AVR128K 131072UL
     74+#define AVR136K 139264UL
     75+#define AVR200K 204800UL
     76+#define AVR256K 262144UL
     77+#define AVR264K 270336UL
     78+
     79+typedef struct
     80+{
     81+    char *name;
     82+       long flash;
     83+       long ram;
     84+       long eeprom;
     85+} avr_device_t;
     86+
     87+avr_device_t avr[] =
     88+{
     89+       {"atxmega256a3",  AVR264K, AVR16K, AVR4K},
     90+       {"atxmega256a3b", AVR264K, AVR16K, AVR4K},
     91+       {"atxmega256d3",  AVR264K, AVR16K, AVR4K},
     92+
     93+       {"atmega2560",    AVR256K, AVR8K,  AVR4K},
     94+       {"atmega2561",    AVR256K, AVR8K,  AVR4K},
     95+
     96+       {"atxmega192a3",  AVR200K, AVR16K, AVR2K},
     97+       {"atxmega192d3",  AVR200K, AVR16K, AVR2K},
     98+
     99+       {"atxmega128a1",  AVR136K, AVR8K,  AVR2K},
     100+       {"atxmega128a3",  AVR136K, AVR8K,  AVR2K},
     101+       {"atxmega128d3",  AVR136K, AVR8K,  AVR2K},
     102+
     103+       {"at43usb320",    AVR128K, 608UL,  0UL},
     104+       {"at90can128",    AVR128K, AVR4K,  AVR4K},
     105+       {"at90usb1286",   AVR128K, AVR8K,  AVR4K},
     106+       {"at90usb1287",   AVR128K, AVR8K,  AVR4K},
     107+       {"atmega128",     AVR128K, AVR4K,  AVR4K},
     108+       {"atmega1280",    AVR128K, AVR8K,  AVR4K},
     109+       {"atmega1281",    AVR128K, AVR8K,  AVR4K},
     110+       {"atmega1284p",   AVR128K, AVR16K, AVR4K},
     111+       {"atmega128rfa1", AVR128K, AVR16K, AVR4K},
     112+       {"atmega103",     AVR128K, 4000UL, AVR4K},
     113+
     114+       {"atxmega64a1",   AVR68K,  AVR4K,  AVR2K},
     115+       {"atxmega64a3",   AVR68K,  AVR4K,  AVR2K},
     116+       {"atxmega64d3",   AVR68K,  AVR4K,  AVR2K},
     117+
     118+       {"at90can64",     AVR64K,  AVR4K,  AVR2K},
     119+       {"at90scr100",    AVR64K,  AVR4K,  AVR2K},
     120+       {"at90usb646",    AVR64K,  AVR4K,  AVR2K},
     121+       {"at90usb647",    AVR64K,  AVR4K,  AVR2K},
     122+       {"atmega64",      AVR64K,  AVR4K,  AVR2K},
     123+       {"atmega640",     AVR64K,  AVR8K,  AVR4K},
     124+       {"atmega644",     AVR64K,  AVR4K,  AVR2K},
     125+       {"atmega644a",    AVR64K,  AVR4K,  AVR2K},
     126+       {"atmega644p",    AVR64K,  AVR4K,  AVR2K},
     127+       {"atmega644pa",   AVR64K,  AVR4K,  AVR2K},
     128+       {"atmega645",     AVR64K,  AVR4K,  AVR2K},
     129+       {"atmega645a",    AVR64K,  AVR4K,  AVR2K},
     130+       {"atmega645p",    AVR64K,  AVR4K,  AVR2K},
     131+       {"atmega6450",    AVR64K,  AVR4K,  AVR2K},
     132+       {"atmega6450a",   AVR64K,  AVR4K,  AVR2K},
     133+       {"atmega6450p",   AVR64K,  AVR4K,  AVR2K},
     134+       {"atmega649",     AVR64K,  AVR4K,  AVR2K},
     135+       {"atmega649a",    AVR64K,  AVR4K,  AVR2K},
     136+       {"atmega649p",    AVR64K,  AVR4K,  AVR2K},
     137+       {"atmega6490",    AVR64K,  AVR4K,  AVR2K},
     138+       {"atmega6490a",   AVR64K,  AVR4K,  AVR2K},
     139+       {"atmega6490p",   AVR64K,  AVR4K,  AVR2K},
     140+       {"atmega64c1",    AVR64K,  AVR4K,  AVR2K},
     141+       {"atmega64hve",   AVR64K,  AVR4K,  AVR1K},
     142+       {"atmega64m1",    AVR64K,  AVR4K,  AVR2K},
     143+
     144+       {"atmega406",     AVR40K,  AVR2K,  AVR512},
     145+
     146+       {"atxmega32a4",   AVR36K,  AVR4K,  AVR1K},
     147+       {"atxmega32d4",   AVR36K,  AVR4K,  AVR1K},
     148+
     149+       {"at90can32",     AVR32K,  AVR2K,  AVR1K},
     150+       {"at94k",         AVR32K,  AVR4K,  0UL},
     151+       {"atmega32",      AVR32K,  AVR2K,  AVR1K},
     152+       {"atmega323",     AVR32K,  AVR2K,  AVR1K},
     153+       {"atmega324a",    AVR32K,  AVR2K,  AVR1K},
     154+       {"atmega324p",    AVR32K,  AVR2K,  AVR1K},
     155+       {"atmega324pa",   AVR32K,  AVR2K,  AVR1K},
     156+       {"atmega325",     AVR32K,  AVR2K,  AVR1K},
     157+       {"atmega325p",    AVR32K,  AVR2K,  AVR1K},
     158+       {"atmega3250",    AVR32K,  AVR2K,  AVR1K},
     159+       {"atmega3250p",   AVR32K,  AVR2K,  AVR1K},
     160+       {"atmega328",     AVR32K,  AVR2K,  AVR1K},
     161+       {"atmega328p",    AVR32K,  AVR2K,  AVR1K},
     162+       {"atmega329",     AVR32K,  AVR2K,  AVR1K},
     163+       {"atmega329p",    AVR32K,  AVR2K,  AVR1K},
     164+       {"atmega329pa",   AVR32K,  AVR2K,  AVR1K},
     165+       {"atmega3290",    AVR32K,  AVR2K,  AVR1K},
     166+       {"atmega3290p",   AVR32K,  AVR2K,  AVR1K},
     167+       {"atmega32hvb",   AVR32K,  AVR2K,  AVR1K},
     168+       {"atmega32c1",    AVR32K,  AVR2K,  AVR1K},
     169+   {"atmega32hvb",   AVR32K,  AVR2K,  AVR1K},
     170+       {"atmega32m1",    AVR32K,  AVR2K,  AVR1K},
     171+       {"atmega32u2",    AVR32K,  AVR1K,  AVR1K},
     172+       {"atmega32u4",    AVR32K,  2560UL, AVR1K},
     173+       {"atmega32u6",    AVR32K,  2560UL, AVR1K},
     174+
     175+       {"at43usb355",    AVR24K,  1120UL,   0UL},
     176+
     177+       {"atxmega16a4",   AVR20K,  AVR2K,  AVR1K},
     178+       {"atxmega16d4",   AVR20K,  AVR2K,  AVR1K},
     179+
     180+       {"at76c711",      AVR16K,  AVR2K,  0UL},
     181+       {"at90pwm216",    AVR16K,  AVR1K,  AVR512},
     182+       {"at90pwm316",    AVR16K,  AVR1K,  AVR512},
     183+       {"at90usb162",    AVR16K,  AVR512, AVR512},
     184+       {"atmega16",      AVR16K,  AVR1K,  AVR512},
     185+       {"atmega16a",     AVR16K,  AVR1K,  AVR512},
     186+       {"atmega161",     AVR16K,  AVR1K,  AVR512},
     187+       {"atmega162",     AVR16K,  AVR1K,  AVR512},
     188+       {"atmega163",     AVR16K,  AVR1K,  AVR512},
     189+       {"atmega164",     AVR16K,  AVR1K,  AVR512},
     190+       {"atmega164a",    AVR16K,  AVR1K,  AVR512},
     191+       {"atmega164p",    AVR16K,  AVR1K,  AVR512},
     192+       {"atmega165a",    AVR16K,  AVR1K,  AVR512},
     193+       {"atmega165",     AVR16K,  AVR1K,  AVR512},
     194+       {"atmega165p",    AVR16K,  AVR1K,  AVR512},
     195+       {"atmega168",     AVR16K,  AVR1K,  AVR512},
     196+       {"atmega168a",    AVR16K,  AVR1K,  AVR512},
     197+       {"atmega168p",    AVR16K,  AVR1K,  AVR512},
     198+       {"atmega169",     AVR16K,  AVR1K,  AVR512},
     199+       {"atmega169a",    AVR16K,  AVR1K,  AVR512},
     200+       {"atmega169p",    AVR16K,  AVR1K,  AVR512},
     201+       {"atmega169pa",   AVR16K,  AVR1K,  AVR512},
     202+       {"atmega16hva",   AVR16K,  768UL,  AVR256},
     203+       {"atmega16hva2",  AVR16K,  AVR1K,  AVR256},
     204+   {"atmega16hvb",   AVR16K,  AVR1K,  AVR512},
     205+       {"atmega16m1",    AVR16K,  AVR1K,  AVR512},
     206+       {"atmega16u2",    AVR16K,  AVR512, AVR512},
     207+       {"atmega16u4",    AVR16K,  1280UL, AVR512},
     208+       {"attiny167",     AVR16K,  AVR512, AVR512},
     209+
     210+       {"at90c8534",     AVR8K,   352UL,  AVR512},
     211+       {"at90pwm1",      AVR8K,   AVR512, AVR512},
     212+       {"at90pwm2",      AVR8K,   AVR512, AVR512},
     213+       {"at90pwm2b",     AVR8K,   AVR512, AVR512},
     214+       {"at90pwm3",      AVR8K,   AVR512, AVR512},
     215+       {"at90pwm3b",     AVR8K,   AVR512, AVR512},
     216+       {"at90pwm81",     AVR8K,   AVR256, AVR512},
     217+       {"at90s8515",     AVR8K,   AVR512, AVR512},
     218+       {"at90s8535",     AVR8K,   AVR512, AVR512},
     219+       {"at90usb82",     AVR8K,   AVR512, AVR512},
     220+       {"ata6289",       AVR8K,   AVR512, 320UL},
     221+       {"atmega8",       AVR8K,   AVR1K,  AVR512},
     222+       {"atmega8515",    AVR8K,   AVR512, AVR512},
     223+       {"atmega8535",    AVR8K,   AVR512, AVR512},
     224+       {"atmega88",      AVR8K,   AVR1K,  AVR512},
     225+       {"atmega88a",     AVR8K,   AVR1K,  AVR512},
     226+       {"atmega88p",     AVR8K,   AVR1K,  AVR512},
     227+       {"atmega88pa",    AVR8K,   AVR1K,  AVR512},
     228+       {"atmega8hva",    AVR8K,   768UL,  AVR256},
     229+       {"atmega8u2",     AVR8K,   AVR512, AVR512},
     230+       {"attiny84",      AVR8K,   AVR512, AVR512},
     231+       {"attiny85",      AVR8K,   AVR512, AVR512},
     232+       {"attiny861",     AVR8K,   AVR512, AVR512},
     233+       {"attiny861a",    AVR8K,   AVR512, AVR512},
     234+       {"attiny87",      AVR8K,   AVR512, AVR512},
     235+       {"attiny88",      AVR8K,   AVR512, AVR64},
     236+
     237+       {"at90s4414",     AVR4K,   352UL,  AVR256},
     238+       {"at90s4433",     AVR4K,   AVR128, AVR256},
     239+       {"at90s4434",     AVR4K,   352UL,  AVR256},
     240+       {"atmega48",      AVR4K,   AVR512, AVR256},
     241+       {"atmega48a",     AVR4K,   AVR512, AVR256},
     242+       {"atmega48p",     AVR4K,   AVR512, AVR256},
     243+       {"attiny4313",    AVR4K,   AVR256, AVR256},
     244+       {"attiny43u",     AVR4K,   AVR256, AVR64},
     245+       {"attiny44",      AVR4K,   AVR256, AVR256},
     246+       {"attiny44a",     AVR4K,   AVR256, AVR256},
     247+       {"attiny45",      AVR4K,   AVR256, AVR256},
     248+       {"attiny461",     AVR4K,   AVR256, AVR256},
     249+       {"attiny461a",    AVR4K,   AVR256, AVR256},
     250+       {"attiny48",      AVR4K,   AVR256, AVR64},
     251+
     252+       {"at86rf401",     AVR2K,   224UL,  AVR128},
     253+       {"at90s2313",     AVR2K,   AVR128, AVR128},
     254+       {"at90s2323",     AVR2K,   AVR128, AVR128},
     255+       {"at90s2333",     AVR2K,   224UL,  AVR128},
     256+       {"at90s2343",     AVR2K,   AVR128, AVR128},
     257+   {"attiny20",      AVR2K,   AVR128, 0UL},
     258+       {"attiny22",      AVR2K,   224UL,  AVR128},
     259+       {"attiny2313",    AVR2K,   AVR128, AVR128},
     260+       {"attiny2313a",   AVR2K,   AVR128, AVR128},
     261+       {"attiny24",      AVR2K,   AVR128, AVR128},
     262+       {"attiny24a",     AVR2K,   AVR128, AVR128},
     263+       {"attiny25",      AVR2K,   AVR128, AVR128},
     264+       {"attiny26",      AVR2K,   AVR128, AVR128},
     265+       {"attiny261",     AVR2K,   AVR128, AVR128},
     266+       {"attiny261a",    AVR2K,   AVR128, AVR128},
     267+       {"attiny28",      AVR2K,   0UL,    0UL},
     268+   {"attiny40",      AVR2K,   AVR256, 0UL},
     269+
     270+       {"at90s1200",     AVR1K,   0UL,    AVR64},
     271+   {"attiny9",       AVR1K,   32UL,   0UL},
     272+   {"attiny10",      AVR1K,   32UL,   0UL},
     273+       {"attiny11",      AVR1K,   0UL,    AVR64},
     274+       {"attiny12",      AVR1K,   0UL,    AVR64},
     275+       {"attiny13",      AVR1K,   AVR64,  AVR64},
     276+       {"attiny13a",     AVR1K,   AVR64,  AVR64},
     277+       {"attiny15",      AVR1K,   0UL,    AVR64},
     278+
     279+   {"attiny4",       AVR512,  32UL,   0UL},
     280+   {"attiny5",       AVR512,  32UL,   0UL},
     281+};
     282+
     283+static char *avrmcu = NULL;
     284+
     285+
     286 static char *target = NULL;
     287 
     288 /* Forward declarations.  */
     289@@ -79,7 +329,8 @@ usage (FILE *stream, int status)
     290   fprintf (stream, _(" Displays the sizes of sections inside binary files\n"));
     291   fprintf (stream, _(" If no input file(s) are specified, a.out is assumed\n"));
     292   fprintf (stream, _(" The options are:\n\
     293-  -A|-B     --format={sysv|berkeley}  Select output style (default is %s)\n\
     294+  -A|-B|-C  --format={sysv|berkeley|avr}  Select output style (default is %s)\n\
     295+            --mcu=<avrmcu>            MCU name for AVR format only\n\
     296   -o|-d|-x  --radix={8|10|16}         Display numbers in octal, decimal or hex\n\
     297   -t        --totals                  Display the total sizes (Berkeley only)\n\
     298             --common                  Display total size for *COM* syms\n\
     299@@ -88,11 +329,7 @@ usage (FILE *stream, int status)
     300   -h        --help                    Display this information\n\
     301   -v        --version                 Display the program's version\n\
     302 \n"),
     303-#if BSD_DEFAULT
     304-  "berkeley"
     305-#else
     306-  "sysv"
     307-#endif
     308+FORMAT_NAME
     309 );
     310   list_supported_targets (program_name, stream);
     311   if (REPORT_BUGS_TO[0] && status == 0)
     312@@ -103,6 +351,7 @@ usage (FILE *stream, int status)
     313 #define OPTION_FORMAT (200)
     314 #define OPTION_RADIX (OPTION_FORMAT + 1)
     315 #define OPTION_TARGET (OPTION_RADIX + 1)
     316+#define OPTION_MCU (OPTION_TARGET + 1)
     317 
     318 static struct option long_options[] =
     319 {
     320@@ -110,6 +360,7 @@ static struct option long_options[] =
     321   {"format", required_argument, 0, OPTION_FORMAT},
     322   {"radix", required_argument, 0, OPTION_RADIX},
     323   {"target", required_argument, 0, OPTION_TARGET},
     324+  {"mcu", required_argument, 0, 203},
     325   {"totals", no_argument, &show_totals, 1},
     326   {"version", no_argument, &show_version, 1},
     327   {"help", no_argument, &show_help, 1},
     328@@ -141,7 +391,7 @@ main (int argc, char **argv)
     329   bfd_init ();
     330   set_default_bfd_target ();
     331 
     332-  while ((c = getopt_long (argc, argv, "ABHhVvdfotx", long_options,
     333+  while ((c = getopt_long (argc, argv, "ABCHhVvdfotx", long_options,
     334                           (int *) 0)) != EOF)
     335     switch (c)
     336       {
     337@@ -150,11 +401,15 @@ main (int argc, char **argv)
     338          {
     339          case 'B':
     340          case 'b':
     341-           berkeley_format = 1;
     342+           format = format_bsd;
     343            break;
     344          case 'S':
     345          case 's':
     346-           berkeley_format = 0;
     347+           format = format_sysv;
     348+           break;
     349+         case 'A':
     350+         case 'a':
     351+           format = format_avr;
     352            break;
     353          default:
     354            non_fatal (_("invalid argument to --format: %s"), optarg);
     355@@ -162,6 +416,10 @@ main (int argc, char **argv)
     356          }
     357        break;
     358 
     359+      case OPTION_MCU:
     360+       avrmcu = optarg;
     361+       break;
     362+
     363       case OPTION_TARGET:
     364        target = optarg;
     365        break;
     366@@ -190,11 +449,14 @@ main (int argc, char **argv)
     367        break;
     368 
     369       case 'A':
     370-       berkeley_format = 0;
     371+       format = format_sysv;
     372        break;
     373       case 'B':
     374-       berkeley_format = 1;
     375+       format = format_bsd;
     376        break;
     377+      case 'C':
     378+    format = format_avr;
     379+    break;
     380       case 'v':
     381       case 'V':
     382        show_version = 1;
     383@@ -240,7 +501,7 @@ main (int argc, char **argv)
     384     for (; optind < argc;)
     385       display_file (argv[optind++]);
     386 
     387-  if (show_totals && berkeley_format)
     388+  if (show_totals && format == format_bsd)
     389     {
     390       bfd_size_type total = total_textsize + total_datasize + total_bsssize;
     391 
     392@@ -599,13 +861,117 @@ print_sysv_format (bfd *file)
     393   printf ("\n\n");
     394 }
     395 
     396+
     397+static avr_device_t *
     398+avr_find_device (void)
     399+{
     400+  unsigned int i;
     401+  if (avrmcu != NULL)
     402+  {
     403+    for (i = 0; i < sizeof(avr) / sizeof(avr[0]); i++)
     404+    {
     405+      if (strcmp(avr[i].name, avrmcu) == 0)
     406+      {
     407+        /* Match found */
     408+        return (&avr[i]);
     409+      }
     410+    }
     411+  }
     412+  return (NULL);
     413+}
     414+
     415+
     416+
     417+static void
     418+print_avr_format (bfd *file)
     419+{
     420+  char *avr_name = "Unknown";
     421+  int flashmax = 0;
     422+  int rammax = 0;
     423+  int eeprommax = 0;
     424+  asection *section;
     425+  bfd_size_type datasize = 0;
     426+  bfd_size_type textsize = 0;
     427+  bfd_size_type bsssize = 0;
     428+  bfd_size_type bootloadersize = 0;
     429+  bfd_size_type noinitsize = 0;
     430+  bfd_size_type eepromsize = 0;
     431+
     432+  avr_device_t *avrdevice = avr_find_device();
     433+  if (avrdevice != NULL)
     434+  {
     435+    avr_name = avrdevice->name;
     436+    flashmax = avrdevice->flash;
     437+    rammax = avrdevice->ram;
     438+    eeprommax = avrdevice->eeprom;
     439+  }
     440+
     441+  if ((section = bfd_get_section_by_name (file, ".data")) != NULL)
     442+    datasize = bfd_section_size (file, section);
     443+  if ((section = bfd_get_section_by_name (file, ".text")) != NULL)
     444+    textsize = bfd_section_size (file, section);
     445+  if ((section = bfd_get_section_by_name (file, ".bss")) != NULL)
     446+    bsssize = bfd_section_size (file, section);
     447+  if ((section = bfd_get_section_by_name (file, ".bootloader")) != NULL)
     448+    bootloadersize = bfd_section_size (file, section);
     449+  if ((section = bfd_get_section_by_name (file, ".noinit")) != NULL)
     450+    noinitsize = bfd_section_size (file, section);
     451+  if ((section = bfd_get_section_by_name (file, ".eeprom")) != NULL)
     452+    eepromsize = bfd_section_size (file, section);
     453
     454+  bfd_size_type text = textsize + datasize + bootloadersize;
     455+  bfd_size_type data = datasize + bsssize + noinitsize;
     456+  bfd_size_type eeprom = eepromsize;
     457
     458+  printf ("AVR Memory Usage\n"
     459+          "----------------\n"
     460+          "Device: %s\n\n", avr_name);
     461
     462+  /* Text size */
     463+  printf ("Program:%8ld bytes", text);
     464+  if (flashmax > 0)
     465+  {
     466+    printf (" (%2.1f%% Full)", ((float)text / flashmax) * 100);
     467+  }
     468+  printf ("\n(.text + .data + .bootloader)\n\n");
     469
     470+  /* Data size */
     471+  printf ("Data:   %8ld bytes", data);
     472+  if (rammax > 0)
     473+  {
     474+    printf (" (%2.1f%% Full)", ((float)data / rammax) * 100);
     475+  }
     476+  printf ("\n(.data + .bss + .noinit)\n\n");
     477
     478+  /* EEPROM size */
     479+  if (eeprom > 0)
     480+  {
     481+    printf ("EEPROM: %8ld bytes", eeprom);
     482+    if (eeprommax > 0)
     483+    {
     484+      printf (" (%2.1f%% Full)", ((float)eeprom / eeprommax) * 100);
     485+    }
     486+    printf ("\n(.eeprom)\n\n");
     487+  }
     488+}
     489+
     490+
     491 static void
     492 print_sizes (bfd *file)
     493 {
     494   if (show_common)
     495     calculate_common_size (file);
     496-  if (berkeley_format)
     497-    print_berkeley_format (file);
     498-  else
     499-    print_sysv_format (file);
     500+  switch (format)
     501+  {
     502+    case format_sysv:
     503+      print_sysv_format (file);
     504+      break;
     505+    case format_bsd:
     506+      print_berkeley_format (file);
     507+      break;
     508+    case format_avr:
     509+    default:
     510+      print_avr_format (file);
     511+      break;
     512+  }
     513 }
  • files/patch-coff-avr

    diff -ruN avr-binutils.orig/files/patch-coff-avr avr-binutils/files/patch-coff-avr
    old new  
     1diff -Nruw bfd/Makefile.am bfd/Makefile.am
     2--- bfd/Makefile.am     2009-10-16 17:17:44.000000000 +0530
     3+++ bfd/Makefile.am     2010-02-11 10:59:11.320193800 +0530
     4@@ -228,6 +228,8 @@
     5        coff-apollo.lo \
     6        coff-arm.lo \
     7        coff-aux.lo \
     8+        coff-avr.lo \
     9+        coff-ext-avr.lo \
     10        coff-go32.lo \
     11        coff-h8300.lo \
     12        coff-h8500.lo \
     13@@ -411,6 +413,8 @@
     14        coff-apollo.c \
     15        coff-arm.c \
     16        coff-aux.c \
     17+       coff-avr.c \
     18+       coff-ext-avr.c \
     19        coff-go32.c \
     20        coff-h8300.c \
     21        coff-h8500.c \
     22diff -Nruw bfd/Makefile.in bfd/Makefile.in
     23--- bfd/Makefile.in     2009-10-16 17:17:48.000000000 +0530
     24+++ bfd/Makefile.in     2010-02-11 11:13:52.698455300 +0530
     25@@ -524,6 +524,8 @@
     26        coff-apollo.lo \
     27        coff-arm.lo \
     28        coff-aux.lo \
     29+       coff-avr.lo \
     30+        coff-ext-avr.lo \
     31        coff-go32.lo \
     32        coff-h8300.lo \
     33        coff-h8500.lo \
     34@@ -707,6 +709,8 @@
     35        coff-apollo.c \
     36        coff-arm.c \
     37        coff-aux.c \
     38+       coff-avr.c \
     39+       coff-ext-avr.c \
     40        coff-go32.c \
     41        coff-h8300.c \
     42        coff-h8500.c \
     43diff -Nruw bfd/coff-avr.c bfd/coff-avr.c
     44--- bfd/coff-avr.c      1970-01-01 05:30:00.000000000 +0530
     45+++ bfd/coff-avr.c      2010-02-10 17:35:58.222099600 +0530
     46@@ -0,0 +1,613 @@
     47+/* BFD back-end for Atmel AVR COFF files.
     48+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2003
     49+   Free Software Foundation, Inc.
     50+   Created mostly by substituting "avr" for "i860" in coff-i860.c
     51+
     52+This file is part of BFD, the Binary File Descriptor library.
     53+
     54+This program is free software; you can redistribute it and/or modify
     55+it under the terms of the GNU General Public License as published by
     56+the Free Software Foundation; either version 2 of the License, or
     57+(at your option) any later version.
     58+
     59+This program is distributed in the hope that it will be useful,
     60+but WITHOUT ANY WARRANTY; without even the implied warranty of
     61+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     62+GNU General Public License for more details.
     63+
     64+You should have received a copy of the GNU General Public License
     65+along with this program; if not, write to the Free Software
     66+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
     67+
     68+#include "bfd.h"
     69+#include "sysdep.h"
     70+#include "libbfd.h"
     71+
     72+#include "coff/avr.h"
     73+
     74+#include "coff/internal.h"
     75+
     76+#include "libcoff.h"
     77+
     78+static bfd_reloc_status_type coff_avr_reloc
     79+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
     80+static reloc_howto_type *coff_avr_rtype_to_howto
     81+  PARAMS ((bfd *, asection *, struct internal_reloc *,
     82+          struct coff_link_hash_entry *, struct internal_syment *,
     83+          bfd_vma *));
     84+static const bfd_target * coff_avr_object_p PARAMS ((bfd *));
     85+
     86+#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
     87+/* The page size is a guess based on ELF.  */
     88+
     89+#define COFF_PAGE_SIZE 0x1000
     90+
     91+/* For some reason when using avr COFF the value stored in the .text
     92+   section for a reference to a common symbol is the value itself plus
     93+   any desired offset.  Ian Taylor, Cygnus Support.  */
     94+
     95+/* If we are producing relocateable output, we need to do some
     96+   adjustments to the object file that are not done by the
     97+   bfd_perform_relocation function.  This function is called by every
     98+   reloc type to make any required adjustments.  */
     99+
     100+static bfd_reloc_status_type
     101+coff_avr_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
     102+                error_message)
     103+     bfd *abfd;
     104+     arelent *reloc_entry;
     105+     asymbol *symbol;
     106+     PTR data;
     107+     asection *input_section ATTRIBUTE_UNUSED;
     108+     bfd *output_bfd;
     109+     char **error_message ATTRIBUTE_UNUSED;
     110+{
     111+  symvalue diff;
     112+
     113+  if (output_bfd == (bfd *) NULL)
     114+    return bfd_reloc_continue;
     115+
     116+  if (bfd_is_com_section (symbol->section))
     117+    {
     118+      /* We are relocating a common symbol.  The current value in the
     119+        object file is ORIG + OFFSET, where ORIG is the value of the
     120+        common symbol as seen by the object file when it was compiled
     121+        (this may be zero if the symbol was undefined) and OFFSET is
     122+        the offset into the common symbol (normally zero, but may be
     123+        non-zero when referring to a field in a common structure).
     124+        ORIG is the negative of reloc_entry->addend, which is set by
     125+        the CALC_ADDEND macro below.  We want to replace the value in
     126+        the object file with NEW + OFFSET, where NEW is the value of
     127+        the common symbol which we are going to put in the final
     128+        object file.  NEW is symbol->value.  */
     129+      diff = symbol->value + reloc_entry->addend;
     130+    }
     131+  else
     132+    {
     133+      /* For some reason bfd_perform_relocation always effectively
     134+        ignores the addend for a COFF target when producing
     135+        relocateable output.  This seems to be always wrong for 860
     136+        COFF, so we handle the addend here instead.  */
     137+      diff = reloc_entry->addend;
     138+    }
     139+
     140+#define DOIT(x) \
     141+  x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
     142+
     143+    if (diff != 0)
     144+      {
     145+       reloc_howto_type *howto = reloc_entry->howto;
     146+       unsigned char *addr = (unsigned char *) data + reloc_entry->address;
     147+
     148+       switch (howto->size)
     149+         {
     150+         case 0:
     151+           {
     152+             char x = bfd_get_8 (abfd, addr);
     153+             DOIT (x);
     154+             bfd_put_8 (abfd, x, addr);
     155+           }
     156+           break;
     157+
     158+         case 1:
     159+           {
     160+             short x = bfd_get_16 (abfd, addr);
     161+             DOIT (x);
     162+             bfd_put_16 (abfd, (bfd_vma) x, addr);
     163+           }
     164+           break;
     165+
     166+         case 2:
     167+           {
     168+             long x = bfd_get_32 (abfd, addr);
     169+             DOIT (x);
     170+             bfd_put_32 (abfd, (bfd_vma) x, addr);
     171+           }
     172+           break;
     173+
     174+         default:
     175+           abort ();
     176+         }
     177+      }
     178+
     179+  /* Now let bfd_perform_relocation finish everything up.  */
     180+  return bfd_reloc_continue;
     181+}
     182+
     183+#ifndef PCRELOFFSET
     184+#define PCRELOFFSET FALSE
     185+#endif
     186+
     187+static reloc_howto_type howto_table[] =
     188+{
     189+  EMPTY_HOWTO (0),
     190+  EMPTY_HOWTO (1),
     191+  EMPTY_HOWTO (2),
     192+  EMPTY_HOWTO (3),
     193+  EMPTY_HOWTO (4),
     194+  EMPTY_HOWTO (5),
     195+  HOWTO (R_DIR32,               /* type */
     196+        0,                     /* rightshift */
     197+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
     198+        32,                    /* bitsize */
     199+        FALSE,                 /* pc_relative */
     200+        0,                     /* bitpos */
     201+        complain_overflow_bitfield, /* complain_on_overflow */
     202+        coff_avr_reloc,       /* special_function */
     203+        "dir32",               /* name */
     204+        TRUE,                  /* partial_inplace */
     205+        0xffffffff,            /* src_mask */
     206+        0xffffffff,            /* dst_mask */
     207+        TRUE),                /* pcrel_offset */
     208+  /* {7}, */
     209+  HOWTO (R_IMAGEBASE,            /* type */
     210+        0,                     /* rightshift */
     211+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
     212+        32,                    /* bitsize */
     213+        FALSE,                 /* pc_relative */
     214+        0,                     /* bitpos */
     215+        complain_overflow_bitfield, /* complain_on_overflow */
     216+        coff_avr_reloc,       /* special_function */
     217+        "rva32",                  /* name */
     218+        TRUE,                  /* partial_inplace */
     219+        0xffffffff,            /* src_mask */
     220+        0xffffffff,            /* dst_mask */
     221+        FALSE),                /* pcrel_offset */
     222+  EMPTY_HOWTO (010),
     223+  EMPTY_HOWTO (011),
     224+  EMPTY_HOWTO (012),
     225+  EMPTY_HOWTO (013),
     226+  EMPTY_HOWTO (014),
     227+  EMPTY_HOWTO (015),
     228+  EMPTY_HOWTO (016),
     229+  HOWTO (R_RELBYTE,            /* type */
     230+        0,                     /* rightshift */
     231+        0,                     /* size (0 = byte, 1 = short, 2 = long) */
     232+        8,                     /* bitsize */
     233+        FALSE,                 /* pc_relative */
     234+        0,                     /* bitpos */
     235+        complain_overflow_bitfield, /* complain_on_overflow */
     236+        coff_avr_reloc,        /* special_function */
     237+        "8",                   /* name */
     238+        TRUE,                  /* partial_inplace */
     239+        0x000000ff,            /* src_mask */
     240+        0x000000ff,            /* dst_mask */
     241+        PCRELOFFSET),          /* pcrel_offset */
     242+  HOWTO (R_RELWORD,            /* type */
     243+        0,                     /* rightshift */
     244+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
     245+        16,                    /* bitsize */
     246+        FALSE,                 /* pc_relative */
     247+        0,                     /* bitpos */
     248+        complain_overflow_bitfield, /* complain_on_overflow */
     249+        coff_avr_reloc,        /* special_function */
     250+        "16",                  /* name */
     251+        TRUE,                  /* partial_inplace */
     252+        0x0000ffff,            /* src_mask */
     253+        0x0000ffff,            /* dst_mask */
     254+        PCRELOFFSET),          /* pcrel_offset */
     255+  HOWTO (R_RELLONG,            /* type */
     256+        0,                     /* rightshift */
     257+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
     258+        32,                    /* bitsize */
     259+        FALSE,                 /* pc_relative */
     260+        0,                     /* bitpos */
     261+        complain_overflow_bitfield, /* complain_on_overflow */
     262+        coff_avr_reloc,        /* special_function */
     263+        "32",                  /* name */
     264+        TRUE,                  /* partial_inplace */
     265+        0xffffffff,            /* src_mask */
     266+        0xffffffff,            /* dst_mask */
     267+        PCRELOFFSET),          /* pcrel_offset */
     268+  HOWTO (R_PCRBYTE,            /* type */
     269+        0,                     /* rightshift */
     270+        0,                     /* size (0 = byte, 1 = short, 2 = long) */
     271+        8,                     /* bitsize */
     272+        TRUE,                  /* pc_relative */
     273+        0,                     /* bitpos */
     274+        complain_overflow_signed, /* complain_on_overflow */
     275+        coff_avr_reloc,        /* special_function */
     276+        "DISP8",               /* name */
     277+        TRUE,                  /* partial_inplace */
     278+        0x000000ff,            /* src_mask */
     279+        0x000000ff,            /* dst_mask */
     280+        PCRELOFFSET),          /* pcrel_offset */
     281+  HOWTO (R_PCRWORD,            /* type */
     282+        0,                     /* rightshift */
     283+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
     284+        16,                    /* bitsize */
     285+        TRUE,                  /* pc_relative */
     286+        0,                     /* bitpos */
     287+        complain_overflow_signed, /* complain_on_overflow */
     288+        coff_avr_reloc,        /* special_function */
     289+        "DISP16",              /* name */
     290+        TRUE,                  /* partial_inplace */
     291+        0x0000ffff,            /* src_mask */
     292+        0x0000ffff,            /* dst_mask */
     293+        PCRELOFFSET),          /* pcrel_offset */
     294+  HOWTO (R_PCRLONG,            /* type */
     295+        0,                     /* rightshift */
     296+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
     297+        32,                    /* bitsize */
     298+        TRUE,                  /* pc_relative */
     299+        0,                     /* bitpos */
     300+        complain_overflow_signed, /* complain_on_overflow */
     301+        coff_avr_reloc,        /* special_function */
     302+        "DISP32",              /* name */
     303+        TRUE,                  /* partial_inplace */
     304+        0xffffffff,            /* src_mask */
     305+        0xffffffff,            /* dst_mask */
     306+        PCRELOFFSET)           /* pcrel_offset */
     307+};
     308+
     309+/* Turn a howto into a reloc  nunmber */
     310+
     311+#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
     312+#define BADMAG(x) AVRBADMAG(x)
     313+#define AVR 1                  /* Customize coffcode.h */
     314+
     315+#define RTYPE2HOWTO(cache_ptr, dst) \
     316+           (cache_ptr)->howto = howto_table + (dst)->r_type;
     317+
     318+/* For AVR COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
     319+   library.  On some other COFF targets STYP_BSS is normally
     320+   STYP_NOLOAD.  */
     321+#define BSS_NOLOAD_IS_SHARED_LIBRARY
     322+
     323+/* Compute the addend of a reloc.  If the reloc is to a common symbol,
     324+   the object file contains the value of the common symbol.  By the
     325+   time this is called, the linker may be using a different symbol
     326+   from a different object file with a different value.  Therefore, we
     327+   hack wildly to locate the original symbol from this file so that we
     328+   can make the correct adjustment.  This macro sets coffsym to the
     329+   symbol from the original file, and uses it to set the addend value
     330+   correctly.  If this is not a common symbol, the usual addend
     331+   calculation is done, except that an additional tweak is needed for
     332+   PC relative relocs.
     333+   FIXME: This macro refers to symbols and asect; these are from the
     334+   calling function, not the macro arguments.  */
     335+
     336+#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)               \
     337+  {                                                            \
     338+    coff_symbol_type *coffsym = (coff_symbol_type *) NULL;     \
     339+    if (ptr && bfd_asymbol_bfd (ptr) != abfd)                  \
     340+      coffsym = (obj_symbols (abfd)                            \
     341+                + (cache_ptr->sym_ptr_ptr - symbols));         \
     342+    else if (ptr)                                              \
     343+      coffsym = coff_symbol_from (abfd, ptr);                  \
     344+    if (coffsym != (coff_symbol_type *) NULL                   \
     345+       && coffsym->native->u.syment.n_scnum == 0)              \
     346+      cache_ptr->addend = - coffsym->native->u.syment.n_value; \
     347+    else if (ptr && bfd_asymbol_bfd (ptr) == abfd              \
     348+            && ptr->section != (asection *) NULL)              \
     349+      cache_ptr->addend = - (ptr->section->vma + ptr->value);  \
     350+    else                                                       \
     351+      cache_ptr->addend = 0;                                   \
     352+    if (ptr && howto_table[reloc.r_type].pc_relative)          \
     353+      cache_ptr->addend += asect->vma;                         \
     354+  }
     355+
     356+/* We use the special COFF backend linker.  */
     357+#define coff_relocate_section _bfd_coff_generic_relocate_section
     358+
     359+static reloc_howto_type *
     360+coff_avr_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
     361+     bfd *abfd ATTRIBUTE_UNUSED;
     362+     asection *sec;
     363+     struct internal_reloc *rel;
     364+     struct coff_link_hash_entry *h;
     365+     struct internal_syment *sym;
     366+     bfd_vma *addendp;
     367+{
     368+
     369+  reloc_howto_type *howto;
     370+
     371+  howto = howto_table + rel->r_type;
     372+
     373+  if (howto->pc_relative)
     374+    *addendp += sec->vma;
     375+
     376+  if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
     377+    {
     378+      /* This is a common symbol.  The section contents include the
     379+        size (sym->n_value) as an addend.  The relocate_section
     380+        function will be adding in the final value of the symbol.  We
     381+        need to subtract out the current size in order to get the
     382+        correct result.  */
     383+
     384+      BFD_ASSERT (h != NULL);
     385+
     386+      /* I think we *do* want to bypass this.  If we don't, I have seen some data
     387+        parameters get the wrong relcation address.  If I link two versions
     388+        with and without this section bypassed and then do a binary comparison,
     389+        the addresses which are different can be looked up in the map.  The
     390+        case in which this section has been bypassed has addresses which correspond
     391+        to values I can find in the map.  */
     392+      *addendp -= sym->n_value;
     393+    }
     394+
     395+  /* If the output symbol is common (in which case this must be a
     396+     relocateable link), we need to add in the final size of the
     397+     common symbol.  */
     398+  if (h != NULL && h->root.type == bfd_link_hash_common)
     399+    *addendp += h->root.u.c.size;
     400+
     401+  return howto;
     402+}
     403+
     404+#define coff_rtype_to_howto coff_avr_rtype_to_howto
     405+
     406+#ifndef bfd_pe_print_pdata
     407+#define bfd_pe_print_pdata     NULL
     408+#endif
     409+
     410+#include "coffcode.h"
     411+
     412+static const bfd_target *
     413+coff_avr_object_p(a)
     414+     bfd *a;
     415+{
     416+  return coff_object_p (a);
     417+}
     418+
     419+/* Handle all the abominations of AVR COFF:
     420+
     421+   Generic COFF always uses the D1 slot to indicate the "most
     422+   important" derived type, and the D2...Dn slots for decreasing
     423+   importance.  E. g., a function symbol will always have its DT_FCN
     424+   element in D1, an array its DT_ARY (its first DT_ARY in a
     425+   multi-dimensional array).  In contrast, AVR COFF expects this most
     426+   important derived type specifier in the upmost Dn slot that is
     427+   allocated at all (i. e. that is != 0).
     428+
     429+   Generic COFF says that "Any symbol that satisfies more than one
     430+   condition [... for AUX entries] should have a union format in its
     431+   auxiliary entry."  AVR COFF uses sepearate AUX entries for multiple
     432+   derived types, and in some cases (like the ISFCN one), even puts
     433+   the most important one into the last allocated AUX entry.  We
     434+   join/split them here at the border as well.  Note that when
     435+   generating AUX entries (where we need to split them), the n_numaux
     436+   field must already have been set up properly (e. g. in
     437+   binutils/wrcoff.c) since the entry renumbering and pointerization
     438+   would not work otherwise.  Thus, we only split the information into
     439+   multiple records if n_numaux > 1.  For similar reasons, we keep
     440+   n_numaux > 1 on input to keep the appropriate AUX entries
     441+   allocated, so a symbol can be reconstructed if it is being passed
     442+   through one of the GNU tools.
     443+
     444+   Note that this adjustment is called after the symbol itself has
     445+   been swapped in, but before the AUX entries are swapped in.  This
     446+   is the only hook available that could swap (or merge) AUX entries
     447+   at all, so we have to operate on the external AUX entries still. */
     448+
     449+void
     450+avr_coff_adjust_sym_in_post (abfd, ext, in)
     451+     bfd *abfd;
     452+     PTR ext;
     453+     PTR in;
     454+{
     455+  struct internal_syment *dst = (struct internal_syment *)in;
     456+  unsigned short dt, bt, ndt;
     457+  dt = dst->n_type & ~N_BTMASK;
     458+  bt = BTYPE (dst->n_type);
     459+
     460+  /* Some AVR COFF producers seem to violate the COFF specs, and
     461+     produce symbols for tag names that have the C_FOO filled in
     462+     properly, but T_NULL as the base type value.  Patch up here,
     463+     since some of our generic COFF tools (in particular
     464+     binutils/rdcoff.c) rely on the correct data. */
     465+  if (bt == T_NULL)
     466+    switch (dst->n_sclass)
     467+      {
     468+      case C_STRTAG:
     469+       bt = T_STRUCT;
     470+       break;
     471+
     472+      case C_UNTAG:
     473+       bt = T_UNION;
     474+       break;
     475+
     476+      case C_ENTAG:
     477+       bt = T_ENUM;
     478+       break;
     479+      }
     480+
     481+  /* Swap the derived type slots. */
     482+  if (dt != 0)
     483+    {
     484+      ndt = 0;
     485+      while (dt != 0)
     486+       {
     487+         ndt = (ndt << N_TSHIFT) | (dt & (N_TMASK >> N_BTSHFT));
     488+         dt >>= N_TSHIFT;
     489+       }
     490+      dst->n_type = (ndt << N_BTSHFT) | bt;
     491+    }
     492+  else
     493+    dst->n_type = bt;
     494+
     495+  /* If the derived type is function, and there is more than one AUX
     496+     entry, swap the first and the last AUX entry, so the most
     497+     interesting one will become the first.
     498+
     499+     If the fundamental type is a tagged type (struct/union/enum), try
     500+     to find the AUX entry describing the tagged type (the one that
     501+     has x_sym.x_tagndx filled in), and merge the tag index into the
     502+     first AUX entry.  Depending on the actual input file, there might
     503+     be further DT_PTR entries which we just ignore, since we could
     504+     not handle that information anyway. */
     505+  if (dst->n_numaux > 1 && dst->n_sclass != C_FILE)
     506+    {
     507+      AUXENT caux, *auxp1, *auxp2;
     508+      size_t symesz;
     509+      unsigned int i;
     510+
     511+      symesz = bfd_coff_symesz (abfd);
     512+      i = dst->n_numaux;
     513+
     514+      auxp1 = (AUXENT *)((char *)ext + symesz);
     515+      auxp2 = (AUXENT *)((char *)ext + i * symesz);
     516+
     517+      if (ISFCN (dst->n_type)
     518+         || (ISPTR(dst->n_type)
     519+             && (bt == T_STRUCT || bt == T_UNION || bt == T_ENUM)))
     520+       {
     521+         caux = *auxp2;
     522+         *auxp2 = *auxp1;
     523+         *auxp1 = caux;
     524+       }
     525+      else
     526+       caux = *auxp1;
     527+
     528+      if ((ISFCN (dst->n_type) || ISARY (dst->n_type))
     529+         && (bt == T_STRUCT || bt == T_UNION || bt == T_ENUM))
     530+       {
     531+         while (i > 1)
     532+           {
     533+             auxp2 = (AUXENT *)((char *)ext + i * symesz);
     534+
     535+             if (auxp2->x_sym.x_tagndx[0] != 0 || auxp2->x_sym.x_tagndx[1] != 0
     536+                 || auxp2->x_sym.x_tagndx[2] != 0 || auxp2->x_sym.x_tagndx[3] != 0)
     537+               {
     538+                 memcpy (caux.x_sym.x_tagndx, auxp2->x_sym.x_tagndx,
     539+                         4 * sizeof (char));
     540+                 break;
     541+               }
     542+             i--;
     543+           }
     544+         if (i > 1)
     545+           *auxp1 = caux;
     546+       }
     547+    }
     548+}
     549+
     550+/* When exporting an AVR COFF file, just undo all that has been done
     551+   above.  Again, we are called after the symbol itself has been
     552+   swapped out, but before the AUX entries are being written.
     553+   Unfortunately, we are only given a pointer to the symbol itself, so
     554+   we have to derive the pointer to the respective aux entries from
     555+   that address, which is a bit clumsy. */
     556+void
     557+avr_coff_adjust_sym_out_post (abfd, in, ext)
     558+     bfd *abfd;
     559+     PTR in;
     560+     PTR ext;
     561+{
     562+  struct internal_syment *src = (struct internal_syment *)(in);
     563+  struct external_syment *dst = (struct external_syment *)(ext);
     564+  unsigned short dt, bt, ndt;
     565+
     566+  dt = src->n_type & ~N_BTMASK;
     567+  bt = BTYPE (src->n_type);
     568+
     569+  if (dt != 0)
     570+    {
     571+      ndt = 0;
     572+      while (dt != 0)
     573+       {
     574+         ndt = (ndt << N_TSHIFT) | (dt & (N_TMASK >> N_BTSHFT));
     575+         dt >>= N_TSHIFT;
     576+       }
     577+      H_PUT_16 (abfd, (ndt << N_BTSHFT) | bt, dst->e_type);
     578+    }
     579+
     580+  if (src->n_numaux > 1 && src->n_sclass != C_FILE)
     581+    {
     582+      combined_entry_type *srce, *dste;
     583+      char *hackp;
     584+      unsigned int i;
     585+
     586+      /* Recover the original combinend_entry_type *. */
     587+      hackp = (char *)in;
     588+      hackp -= offsetof(combined_entry_type, u.syment);
     589+      srce = (combined_entry_type *)hackp;
     590+      srce++;
     591+
     592+      /* We simply duplicate the first AUX entry as many times as
     593+        needed.  Since COFF itself normally uses just a single AUX
     594+        entry for all the information, this will work -- each COFF
     595+        consumer will then just pick the fields it is particularly
     596+        interested in.  This would not work for the AVR COFF specific
     597+        DT_PTR AUX entries, but we don't support them anyway. */
     598+      for (i = 1; i < src->n_numaux; i++)
     599+       {
     600+         dste = srce + i;
     601+         *dste = *srce;
     602+       }
     603+    }
     604+}
     605+
     606+const bfd_target
     607+#ifdef TARGET_SYM
     608+  TARGET_SYM =
     609+#else
     610+  avrcoff_vec =
     611+#endif
     612+{
     613+#ifdef TARGET_NAME
     614+  TARGET_NAME,
     615+#else
     616+  "coff-avr",                  /* name */
     617+#endif
     618+  bfd_target_coff_flavour,
     619+  BFD_ENDIAN_LITTLE,           /* data byte order is little */
     620+  BFD_ENDIAN_LITTLE,           /* header byte order is little */
     621+
     622+  (HAS_RELOC | EXEC_P |                /* object flags */
     623+   HAS_LINENO | HAS_DEBUG |
     624+   HAS_SYMS | HAS_LOCALS | WP_TEXT),
     625+
     626+  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
     627+  0,                           /* leading char */
     628+  '/',                         /* ar_pad_char */
     629+  15,                          /* ar_max_namelen */
     630+
     631+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
     632+     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
     633+     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
     634+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
     635+     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
     636+     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
     637+
     638+/* Note that we allow an object file to be treated as a core file as well.  */
     639+    {_bfd_dummy_target, coff_avr_object_p, /* bfd_check_format */
     640+       bfd_generic_archive_p, coff_avr_object_p},
     641+    {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
     642+       bfd_false},
     643+    {bfd_false, coff_write_object_contents, /* bfd_write_contents */
     644+       _bfd_write_archive_contents, bfd_false},
     645+
     646+     BFD_JUMP_TABLE_GENERIC (coff),
     647+     BFD_JUMP_TABLE_COPY (coff),
     648+     BFD_JUMP_TABLE_CORE (_bfd_nocore),
     649+     BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
     650+     BFD_JUMP_TABLE_SYMBOLS (coff),
     651+     BFD_JUMP_TABLE_RELOCS (coff),
     652+     BFD_JUMP_TABLE_WRITE (coff),
     653+     BFD_JUMP_TABLE_LINK (coff),
     654+     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
     655+
     656+  NULL,
     657+
     658+  COFF_SWAP_TABLE
     659+};
     660diff -Nruw bfd/coff-ext-avr.c bfd/coff-ext-avr.c
     661--- bfd/coff-ext-avr.c  1970-01-01 05:30:00.000000000 +0530
     662+++ bfd/coff-ext-avr.c  2010-02-10 17:35:58.222099600 +0530
     663@@ -0,0 +1,428 @@
     664+/* BFD back-end for Atmel AVR "extended" COFF files.
     665+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2003
     666+   Free Software Foundation, Inc.
     667+   This is mostly the same as avr-coff, except of the presence of the
     668+   COFF optional header.
     669+
     670+This file is part of BFD, the Binary File Descriptor library.
     671+
     672+This program is free software; you can redistribute it and/or modify
     673+it under the terms of the GNU General Public License as published by
     674+the Free Software Foundation; either version 2 of the License, or
     675+(at your option) any later version.
     676+
     677+This program is distributed in the hope that it will be useful,
     678+but WITHOUT ANY WARRANTY; without even the implied warranty of
     679+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     680+GNU General Public License for more details.
     681+
     682+You should have received a copy of the GNU General Public License
     683+along with this program; if not, write to the Free Software
     684+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
     685+
     686+#include "bfd.h"
     687+#include "sysdep.h"
     688+#include "libbfd.h"
     689+
     690+#define AVR_EXT_COFF 1
     691+#include "coff/avr.h"
     692+
     693+#include "coff/internal.h"
     694+
     695+#include "libcoff.h"
     696+
     697+static bfd_reloc_status_type coff_ext_avr_reloc
     698+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
     699+static reloc_howto_type *coff_ext_avr_rtype_to_howto
     700+  PARAMS ((bfd *, asection *, struct internal_reloc *,
     701+          struct coff_link_hash_entry *, struct internal_syment *,
     702+          bfd_vma *));
     703+static const bfd_target * coff_ext_avr_object_p PARAMS ((bfd *));
     704+
     705+#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
     706+/* The page size is a guess based on ELF.  */
     707+
     708+#define COFF_PAGE_SIZE 0x1000
     709+
     710+/* For some reason when using avr COFF the value stored in the .text
     711+   section for a reference to a common symbol is the value itself plus
     712+   any desired offset.  Ian Taylor, Cygnus Support.  */
     713+
     714+/* If we are producing relocateable output, we need to do some
     715+   adjustments to the object file that are not done by the
     716+   bfd_perform_relocation function.  This function is called by every
     717+   reloc type to make any required adjustments.  */
     718+
     719+static bfd_reloc_status_type
     720+coff_ext_avr_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
     721+                error_message)
     722+     bfd *abfd;
     723+     arelent *reloc_entry;
     724+     asymbol *symbol;
     725+     PTR data;
     726+     asection *input_section ATTRIBUTE_UNUSED;
     727+     bfd *output_bfd;
     728+     char **error_message ATTRIBUTE_UNUSED;
     729+{
     730+  symvalue diff;
     731+
     732+  if (output_bfd == (bfd *) NULL)
     733+    return bfd_reloc_continue;
     734+
     735+  if (bfd_is_com_section (symbol->section))
     736+    {
     737+      /* We are relocating a common symbol.  The current value in the
     738+        object file is ORIG + OFFSET, where ORIG is the value of the
     739+        common symbol as seen by the object file when it was compiled
     740+        (this may be zero if the symbol was undefined) and OFFSET is
     741+        the offset into the common symbol (normally zero, but may be
     742+        non-zero when referring to a field in a common structure).
     743+        ORIG is the negative of reloc_entry->addend, which is set by
     744+        the CALC_ADDEND macro below.  We want to replace the value in
     745+        the object file with NEW + OFFSET, where NEW is the value of
     746+        the common symbol which we are going to put in the final
     747+        object file.  NEW is symbol->value.  */
     748+      diff = symbol->value + reloc_entry->addend;
     749+    }
     750+  else
     751+    {
     752+      /* For some reason bfd_perform_relocation always effectively
     753+        ignores the addend for a COFF target when producing
     754+        relocateable output.  This seems to be always wrong for 860
     755+        COFF, so we handle the addend here instead.  */
     756+      diff = reloc_entry->addend;
     757+    }
     758+
     759+#define DOIT(x) \
     760+  x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
     761+
     762+    if (diff != 0)
     763+      {
     764+       reloc_howto_type *howto = reloc_entry->howto;
     765+       unsigned char *addr = (unsigned char *) data + reloc_entry->address;
     766+
     767+       switch (howto->size)
     768+         {
     769+         case 0:
     770+           {
     771+             char x = bfd_get_8 (abfd, addr);
     772+             DOIT (x);
     773+             bfd_put_8 (abfd, x, addr);
     774+           }
     775+           break;
     776+
     777+         case 1:
     778+           {
     779+             short x = bfd_get_16 (abfd, addr);
     780+             DOIT (x);
     781+             bfd_put_16 (abfd, (bfd_vma) x, addr);
     782+           }
     783+           break;
     784+
     785+         case 2:
     786+           {
     787+             long x = bfd_get_32 (abfd, addr);
     788+             DOIT (x);
     789+             bfd_put_32 (abfd, (bfd_vma) x, addr);
     790+           }
     791+           break;
     792+
     793+         default:
     794+           abort ();
     795+         }
     796+      }
     797+
     798+  /* Now let bfd_perform_relocation finish everything up.  */
     799+  return bfd_reloc_continue;
     800+}
     801+
     802+#ifndef PCRELOFFSET
     803+#define PCRELOFFSET FALSE
     804+#endif
     805+
     806+static reloc_howto_type howto_table[] =
     807+{
     808+  EMPTY_HOWTO (0),
     809+  EMPTY_HOWTO (1),
     810+  EMPTY_HOWTO (2),
     811+  EMPTY_HOWTO (3),
     812+  EMPTY_HOWTO (4),
     813+  EMPTY_HOWTO (5),
     814+  HOWTO (R_DIR32,               /* type */
     815+        0,                     /* rightshift */
     816+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
     817+        32,                    /* bitsize */
     818+        FALSE,                 /* pc_relative */
     819+        0,                     /* bitpos */
     820+        complain_overflow_bitfield, /* complain_on_overflow */
     821+        coff_ext_avr_reloc,       /* special_function */
     822+        "dir32",               /* name */
     823+        TRUE,                  /* partial_inplace */
     824+        0xffffffff,            /* src_mask */
     825+        0xffffffff,            /* dst_mask */
     826+        TRUE),                /* pcrel_offset */
     827+  /* {7}, */
     828+  HOWTO (R_IMAGEBASE,            /* type */
     829+        0,                     /* rightshift */
     830+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
     831+        32,                    /* bitsize */
     832+        FALSE,                 /* pc_relative */
     833+        0,                     /* bitpos */
     834+        complain_overflow_bitfield, /* complain_on_overflow */
     835+        coff_ext_avr_reloc,       /* special_function */
     836+        "rva32",                  /* name */
     837+        TRUE,                  /* partial_inplace */
     838+        0xffffffff,            /* src_mask */
     839+        0xffffffff,            /* dst_mask */
     840+        FALSE),                /* pcrel_offset */
     841+  EMPTY_HOWTO (010),
     842+  EMPTY_HOWTO (011),
     843+  EMPTY_HOWTO (012),
     844+  EMPTY_HOWTO (013),
     845+  EMPTY_HOWTO (014),
     846+  EMPTY_HOWTO (015),
     847+  EMPTY_HOWTO (016),
     848+  HOWTO (R_RELBYTE,            /* type */
     849+        0,                     /* rightshift */
     850+        0,                     /* size (0 = byte, 1 = short, 2 = long) */
     851+        8,                     /* bitsize */
     852+        FALSE,                 /* pc_relative */
     853+        0,                     /* bitpos */
     854+        complain_overflow_bitfield, /* complain_on_overflow */
     855+        coff_ext_avr_reloc,    /* special_function */
     856+        "8",                   /* name */
     857+        TRUE,                  /* partial_inplace */
     858+        0x000000ff,            /* src_mask */
     859+        0x000000ff,            /* dst_mask */
     860+        PCRELOFFSET),          /* pcrel_offset */
     861+  HOWTO (R_RELWORD,            /* type */
     862+        0,                     /* rightshift */
     863+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
     864+        16,                    /* bitsize */
     865+        FALSE,                 /* pc_relative */
     866+        0,                     /* bitpos */
     867+        complain_overflow_bitfield, /* complain_on_overflow */
     868+        coff_ext_avr_reloc,    /* special_function */
     869+        "16",                  /* name */
     870+        TRUE,                  /* partial_inplace */
     871+        0x0000ffff,            /* src_mask */
     872+        0x0000ffff,            /* dst_mask */
     873+        PCRELOFFSET),          /* pcrel_offset */
     874+  HOWTO (R_RELLONG,            /* type */
     875+        0,                     /* rightshift */
     876+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
     877+        32,                    /* bitsize */
     878+        FALSE,                 /* pc_relative */
     879+        0,                     /* bitpos */
     880+        complain_overflow_bitfield, /* complain_on_overflow */
     881+        coff_ext_avr_reloc,    /* special_function */
     882+        "32",                  /* name */
     883+        TRUE,                  /* partial_inplace */
     884+        0xffffffff,            /* src_mask */
     885+        0xffffffff,            /* dst_mask */
     886+        PCRELOFFSET),          /* pcrel_offset */
     887+  HOWTO (R_PCRBYTE,            /* type */
     888+        0,                     /* rightshift */
     889+        0,                     /* size (0 = byte, 1 = short, 2 = long) */
     890+        8,                     /* bitsize */
     891+        TRUE,                  /* pc_relative */
     892+        0,                     /* bitpos */
     893+        complain_overflow_signed, /* complain_on_overflow */
     894+        coff_ext_avr_reloc,    /* special_function */
     895+        "DISP8",               /* name */
     896+        TRUE,                  /* partial_inplace */
     897+        0x000000ff,            /* src_mask */
     898+        0x000000ff,            /* dst_mask */
     899+        PCRELOFFSET),          /* pcrel_offset */
     900+  HOWTO (R_PCRWORD,            /* type */
     901+        0,                     /* rightshift */
     902+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
     903+        16,                    /* bitsize */
     904+        TRUE,                  /* pc_relative */
     905+        0,                     /* bitpos */
     906+        complain_overflow_signed, /* complain_on_overflow */
     907+        coff_ext_avr_reloc,    /* special_function */
     908+        "DISP16",              /* name */
     909+        TRUE,                  /* partial_inplace */
     910+        0x0000ffff,            /* src_mask */
     911+        0x0000ffff,            /* dst_mask */
     912+        PCRELOFFSET),          /* pcrel_offset */
     913+  HOWTO (R_PCRLONG,            /* type */
     914+        0,                     /* rightshift */
     915+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
     916+        32,                    /* bitsize */
     917+        TRUE,                  /* pc_relative */
     918+        0,                     /* bitpos */
     919+        complain_overflow_signed, /* complain_on_overflow */
     920+        coff_ext_avr_reloc,    /* special_function */
     921+        "DISP32",              /* name */
     922+        TRUE,                  /* partial_inplace */
     923+        0xffffffff,            /* src_mask */
     924+        0xffffffff,            /* dst_mask */
     925+        PCRELOFFSET)           /* pcrel_offset */
     926+};
     927+
     928+/* Turn a howto into a reloc  nunmber */
     929+
     930+#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
     931+#define BADMAG(x) AVRBADMAG(x)
     932+#define AVR 1                  /* Customize coffcode.h */
     933+
     934+#define RTYPE2HOWTO(cache_ptr, dst) \
     935+           (cache_ptr)->howto = howto_table + (dst)->r_type;
     936+
     937+/* For AVR COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
     938+   library.  On some other COFF targets STYP_BSS is normally
     939+   STYP_NOLOAD.  */
     940+#define BSS_NOLOAD_IS_SHARED_LIBRARY
     941+
     942+/* Compute the addend of a reloc.  If the reloc is to a common symbol,
     943+   the object file contains the value of the common symbol.  By the
     944+   time this is called, the linker may be using a different symbol
     945+   from a different object file with a different value.  Therefore, we
     946+   hack wildly to locate the original symbol from this file so that we
     947+   can make the correct adjustment.  This macro sets coffsym to the
     948+   symbol from the original file, and uses it to set the addend value
     949+   correctly.  If this is not a common symbol, the usual addend
     950+   calculation is done, except that an additional tweak is needed for
     951+   PC relative relocs.
     952+   FIXME: This macro refers to symbols and asect; these are from the
     953+   calling function, not the macro arguments.  */
     954+
     955+#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)               \
     956+  {                                                            \
     957+    coff_symbol_type *coffsym = (coff_symbol_type *) NULL;     \
     958+    if (ptr && bfd_asymbol_bfd (ptr) != abfd)                  \
     959+      coffsym = (obj_symbols (abfd)                            \
     960+                + (cache_ptr->sym_ptr_ptr - symbols));         \
     961+    else if (ptr)                                              \
     962+      coffsym = coff_symbol_from (abfd, ptr);                  \
     963+    if (coffsym != (coff_symbol_type *) NULL                   \
     964+       && coffsym->native->u.syment.n_scnum == 0)              \
     965+      cache_ptr->addend = - coffsym->native->u.syment.n_value; \
     966+    else if (ptr && bfd_asymbol_bfd (ptr) == abfd              \
     967+            && ptr->section != (asection *) NULL)              \
     968+      cache_ptr->addend = - (ptr->section->vma + ptr->value);  \
     969+    else                                                       \
     970+      cache_ptr->addend = 0;                                   \
     971+    if (ptr && howto_table[reloc.r_type].pc_relative)          \
     972+      cache_ptr->addend += asect->vma;                         \
     973+  }
     974+
     975+/* We use the special COFF backend linker.  */
     976+#define coff_relocate_section _bfd_coff_generic_relocate_section
     977+
     978+static reloc_howto_type *
     979+coff_ext_avr_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
     980+     bfd *abfd ATTRIBUTE_UNUSED;
     981+     asection *sec;
     982+     struct internal_reloc *rel;
     983+     struct coff_link_hash_entry *h;
     984+     struct internal_syment *sym;
     985+     bfd_vma *addendp;
     986+{
     987+
     988+  reloc_howto_type *howto;
     989+
     990+  howto = howto_table + rel->r_type;
     991+
     992+  if (howto->pc_relative)
     993+    *addendp += sec->vma;
     994+
     995+  if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
     996+    {
     997+      /* This is a common symbol.  The section contents include the
     998+        size (sym->n_value) as an addend.  The relocate_section
     999+        function will be adding in the final value of the symbol.  We
     1000+        need to subtract out the current size in order to get the
     1001+        correct result.  */
     1002+
     1003+      BFD_ASSERT (h != NULL);
     1004+
     1005+      /* I think we *do* want to bypass this.  If we don't, I have seen some data
     1006+        parameters get the wrong relcation address.  If I link two versions
     1007+        with and without this section bypassed and then do a binary comparison,
     1008+        the addresses which are different can be looked up in the map.  The
     1009+        case in which this section has been bypassed has addresses which correspond
     1010+        to values I can find in the map.  */
     1011+      *addendp -= sym->n_value;
     1012+    }
     1013+
     1014+  /* If the output symbol is common (in which case this must be a
     1015+     relocateable link), we need to add in the final size of the
     1016+     common symbol.  */
     1017+  if (h != NULL && h->root.type == bfd_link_hash_common)
     1018+    *addendp += h->root.u.c.size;
     1019+
     1020+  return howto;
     1021+}
     1022+
     1023+#define coff_rtype_to_howto coff_ext_avr_rtype_to_howto
     1024+
     1025+#ifndef bfd_pe_print_pdata
     1026+#define bfd_pe_print_pdata     NULL
     1027+#endif
     1028+
     1029+#include "coffcode.h"
     1030+
     1031+static const bfd_target *
     1032+coff_ext_avr_object_p(a)
     1033+     bfd *a;
     1034+{
     1035+  return coff_object_p (a);
     1036+}
     1037+
     1038+const bfd_target
     1039+#ifdef TARGET_SYM
     1040+  TARGET_SYM =
     1041+#else
     1042+  avrextcoff_vec =
     1043+#endif
     1044+{
     1045+#ifdef TARGET_NAME
     1046+  TARGET_NAME,
     1047+#else
     1048+  "coff-ext-avr",                      /* name */
     1049+#endif
     1050+  bfd_target_coff_flavour,
     1051+  BFD_ENDIAN_LITTLE,           /* data byte order is little */
     1052+  BFD_ENDIAN_LITTLE,           /* header byte order is little */
     1053+
     1054+  (HAS_RELOC | EXEC_P |                /* object flags */
     1055+   HAS_LINENO | HAS_DEBUG |
     1056+   HAS_SYMS | HAS_LOCALS | WP_TEXT),
     1057+
     1058+  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
     1059+  0,                           /* leading char */
     1060+  '/',                         /* ar_pad_char */
     1061+  15,                          /* ar_max_namelen */
     1062+
     1063+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
     1064+     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
     1065+     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
     1066+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
     1067+     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
     1068+     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
     1069+
     1070+/* Note that we allow an object file to be treated as a core file as well.  */
     1071+    {_bfd_dummy_target, coff_ext_avr_object_p, /* bfd_check_format */
     1072+       bfd_generic_archive_p, coff_ext_avr_object_p},
     1073+    {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
     1074+       bfd_false},
     1075+    {bfd_false, coff_write_object_contents, /* bfd_write_contents */
     1076+       _bfd_write_archive_contents, bfd_false},
     1077+
     1078+     BFD_JUMP_TABLE_GENERIC (coff),
     1079+     BFD_JUMP_TABLE_COPY (coff),
     1080+     BFD_JUMP_TABLE_CORE (_bfd_nocore),
     1081+     BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
     1082+     BFD_JUMP_TABLE_SYMBOLS (coff),
     1083+     BFD_JUMP_TABLE_RELOCS (coff),
     1084+     BFD_JUMP_TABLE_WRITE (coff),
     1085+     BFD_JUMP_TABLE_LINK (coff),
     1086+     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
     1087+
     1088+  NULL,
     1089+
     1090+  COFF_SWAP_TABLE
     1091+};
     1092diff -Nruw bfd/coffcode.h bfd/coffcode.h
     1093--- bfd/coffcode.h      2009-09-10 17:17:12.000000000 +0530
     1094+++ bfd/coffcode.h      2010-02-10 17:35:58.253349600 +0530
     1095@@ -1,3 +1,4 @@
     1096+
     1097 /* Support for the generic parts of most COFF variants, for BFD.
     1098    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
     1099    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
     1100@@ -1910,6 +1911,17 @@
     1101   coff->relocbase = 0;
     1102   coff->local_toc_sym_map = 0;
     1103 
     1104+  /* These members communicate important constants about the symbol
     1105+     table to GDB's symbol-reading code.  These `constants'
     1106+     unfortunately vary among coff implementations...  */
     1107+  coff->local_n_btmask = N_BTMASK;
     1108+  coff->local_n_btshft = N_BTSHFT;
     1109+  coff->local_n_tmask = N_TMASK;
     1110+  coff->local_n_tshift = N_TSHIFT;
     1111+  coff->local_symesz = bfd_coff_symesz (abfd);
     1112+  coff->local_auxesz = bfd_coff_auxesz (abfd);
     1113+  coff->local_linesz = bfd_coff_linesz (abfd);
     1114+
     1115 /*  make_abs_section(abfd);*/
     1116 
     1117   return TRUE;
     1118@@ -1934,17 +1946,6 @@
     1119 
     1120   coff->sym_filepos = internal_f->f_symptr;
     1121 
     1122-  /* These members communicate important constants about the symbol
     1123-     table to GDB's symbol-reading code.  These `constants'
     1124-     unfortunately vary among coff implementations...  */
     1125-  coff->local_n_btmask = N_BTMASK;
     1126-  coff->local_n_btshft = N_BTSHFT;
     1127-  coff->local_n_tmask = N_TMASK;
     1128-  coff->local_n_tshift = N_TSHIFT;
     1129-  coff->local_symesz = bfd_coff_symesz (abfd);
     1130-  coff->local_auxesz = bfd_coff_auxesz (abfd);
     1131-  coff->local_linesz = bfd_coff_linesz (abfd);
     1132-
     1133   coff->timestamp = internal_f->f_timdat;
     1134 
     1135   obj_raw_syment_count (abfd) =
     1136@@ -2076,6 +2077,11 @@
     1137        }
     1138       break;
     1139 #endif
     1140+#ifdef AVRMAGIC
     1141+    case AVRMAGIC:
     1142+      arch = bfd_arch_avr;
     1143+      break;
     1144+#endif
     1145 #ifdef MC68MAGIC
     1146     case MC68MAGIC:
     1147     case M68MAGIC:
     1148@@ -2871,6 +2877,13 @@
     1149       return TRUE;
     1150 #endif
     1151 
     1152+#ifdef AVRMAGIC
     1153+    case bfd_arch_avr:
     1154+      *magicp = AVRMAGIC;
     1155+      return TRUE;
     1156+      break;
     1157+#endif
     1158+
     1159 #ifdef PPCMAGIC
     1160     case bfd_arch_powerpc:
     1161       *magicp = PPCMAGIC;
     1162@@ -3698,6 +3711,11 @@
     1163       section.s_page = 0;
     1164 #endif
     1165 
     1166+#ifdef AVR
     1167+      /* AVR uses s_paddr the way GNU uses s_vaddr, and effectively
     1168+        ignores s_vaddr. */
     1169+      section.s_paddr = current->vma;
     1170+#endif
     1171 #ifdef COFF_WITH_PE
     1172       section.s_paddr = 0;
     1173 #endif
     1174@@ -4042,6 +4060,17 @@
     1175     internal_a.magic = ZMAGIC;
     1176 #endif
     1177 
     1178+#ifdef AVR
     1179+    /* a.out is a dummy for non-extended COFF */
     1180+    internal_a.magic = AVRAOUTMAGIC;
     1181+    /* Upper nibble of f_flags must be set for historical reasons.
     1182+       The upper byte remains blank on coff-avr, so undo the F_AR32WR
     1183+       setting performed above. */
     1184+    internal_f.f_flags |= F_JUNK;
     1185+    internal_f.f_flags &= ~F_UNUSED;
     1186+#define __A_MAGIC_SET__
     1187+#endif /* AVR */
     1188+
     1189 #if defined(PPC_PE)
     1190 #define __A_MAGIC_SET__
     1191     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
     1192@@ -4109,8 +4138,16 @@
     1193 #endif
     1194   }
     1195 
     1196+#ifdef AVR_EXT_COFF
     1197+    /* Note that we do not set F_PTRINFO because the GNU toolchain
     1198+       doesn't provide any information about the target of a pointer,
     1199+       so we cannot derive which section our pointer target would be
     1200+       in. */
     1201+  internal_a.vstamp = F_FULLPATHS | F_STRUCTINFO;
     1202+#else
     1203   /* FIXME: Does anybody ever set this to another value?  */
     1204   internal_a.vstamp = 0;
     1205+#endif
     1206 
     1207   /* Now should write relocs, strings, syms.  */
     1208   obj_sym_filepos (abfd) = sym_base;
     1209@@ -4668,6 +4705,10 @@
     1210            /* In PE, 0x69 (105) denotes a weak external symbol.  */
     1211            case C_NT_WEAK:
     1212 #endif
     1213+#ifdef AVR
     1214+           /* Some AVR COFF compilers handle EXTDEF like EXT. */
     1215+           case C_EXTDEF:      /* external definition           */
     1216+#endif
     1217              switch (coff_classify_symbol (abfd, &src->u.syment))
     1218                {
     1219                case COFF_SYMBOL_GLOBAL:
     1220@@ -4891,7 +4932,9 @@
     1221                  && src->u.syment.n_scnum == 0)
     1222                break;
     1223              /* Fall through.  */
     1224+#if !defined(AVR)
     1225            case C_EXTDEF:      /* External definition.  */
     1226+#endif
     1227            case C_ULABEL:      /* Undefined label.  */
     1228            case C_USTATIC:     /* Undefined static.  */
     1229 #ifndef COFF_WITH_PE
     1230diff -Nruw bfd/coffgen.c bfd/coffgen.c
     1231--- bfd/coffgen.c       2009-09-10 17:17:12.000000000 +0530
     1232+++ bfd/coffgen.c       2010-02-11 11:20:28.795092600 +0530
     1233@@ -699,6 +699,20 @@
     1234              if (last_file != NULL)
     1235                last_file->n_value = native_index;
     1236              last_file = &(s->u.syment);
     1237+             if (bfd_get_arch (bfd_ptr) == bfd_arch_avr
     1238+                 && bfd_coff_long_filenames (bfd_ptr)
     1239+                 && s->u.syment.n_numaux > 0)
     1240+               {
     1241+                 /* AVR COFF records long filenames in successive aux
     1242+                    records.  Adjust the number of aux records
     1243+                    required here, so the renumbering will account
     1244+                    for them. */
     1245+                 unsigned int filnmlen = bfd_coff_filnmlen (bfd_ptr);
     1246+                 unsigned int namelen = strlen (coff_symbol_ptr->symbol.name);
     1247+                 unsigned int n = (namelen + filnmlen - 1) / filnmlen;
     1248+
     1249+                 s->u.syment.n_numaux = n > NAUXENTS? NAUXENTS: n;
     1250+               }
     1251            }
     1252          else
     1253            /* Modify the symbol values according to their section and
     1254@@ -827,6 +841,20 @@
     1255        {
     1256          if (name_length <= filnmlen)
     1257            strncpy (auxent->x_file.x_fname, name, filnmlen);
     1258+         else if (bfd_get_arch (abfd) == bfd_arch_avr)
     1259+           {
     1260+             /* AVR COFF records long filenames in successive aux records. */
     1261+             int i = 1;
     1262+             while (name_length > filnmlen && i < NAUXENTS)
     1263+               {
     1264+                 strncpy (auxent->x_file.x_fname, name, filnmlen);
     1265+                 name += filnmlen;
     1266+                 name_length -= filnmlen;
     1267+                 i++;
     1268+                 auxent = &(native + i)->u.auxent;
     1269+               }
     1270+             strncpy (auxent->x_file.x_fname, name, filnmlen);
     1271+           }
     1272          else
     1273            {
     1274              auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
     1275@@ -1272,6 +1300,10 @@
     1276                  if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
     1277                    return FALSE;
     1278                }
     1279+             if (bfd_get_arch (abfd) == bfd_arch_avr)
     1280+               /* AVR COFF handles long file names in aux records. */
     1281+               maxlen = name_length;
     1282+             else
     1283              maxlen = bfd_coff_filnmlen (abfd);
     1284            }
     1285          else
     1286@@ -1710,14 +1742,27 @@
     1287            {
     1288              /* Ordinary short filename, put into memory anyway.  The
     1289                  Microsoft PE tools sometimes store a filename in
     1290-                 multiple AUX entries.  */
     1291+                 multiple AUX entries.
     1292+                AVR COFF does it that way, too. */
     1293              if (internal_ptr->u.syment.n_numaux > 1
     1294-                 && coff_data (abfd)->pe)
     1295-               internal_ptr->u.syment._n._n_n._n_offset =
     1296-                 ((bfd_hostptr_t)
     1297-                  copy_name (abfd,
     1298-                             (internal_ptr + 1)->u.auxent.x_file.x_fname,
     1299-                             internal_ptr->u.syment.n_numaux * symesz));
     1300+                 && (coff_data (abfd)->pe
     1301+                     || (bfd_get_arch (abfd) == bfd_arch_avr)))
     1302+               {
     1303+                 char *b;
     1304+                 unsigned int i;
     1305+
     1306+                 /* We allocate enough storage to fit the contents of
     1307+                    this many aux records, and simply append a \0.
     1308+                    This ensures the string will always be
     1309+                    terminated, even in the case where it just fit
     1310+                    into the aux records. */
     1311+                 b = (char *) bfd_alloc (abfd,
     1312+                                         internal_ptr->u.syment.n_numaux * FILNMLEN + 1);
     1313+                 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) b;
     1314+                 b[internal_ptr->u.syment.n_numaux * FILNMLEN] = '\0';
     1315+                 for (i = 0; i < internal_ptr->u.syment.n_numaux; i++, b += FILNMLEN)
     1316+                   memcpy (b, (internal_ptr + i + 1)->u.auxent.x_file.x_fname, FILNMLEN);
     1317+               }
     1318              else
     1319                internal_ptr->u.syment._n._n_n._n_offset =
     1320                  ((bfd_hostptr_t)
     1321@@ -1823,9 +1868,9 @@
     1322 
     1323   if (new_symbol == NULL)
     1324     return NULL;
     1325-  /* @@ The 10 is a guess at a plausible maximum number of aux entries
     1326+  /* @@ The NAUXENTS is a guess at a plausible maximum number of aux entries
     1327      (but shouldn't be a constant).  */
     1328-  amt = sizeof (combined_entry_type) * 10;
     1329+  amt = sizeof (combined_entry_type) * (NAUXENTS + 1);
     1330   new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
     1331   if (!new_symbol->native)
     1332     return NULL;
     1333diff -Nruw bfd/coffswap.h bfd/coffswap.h
     1334--- bfd/coffswap.h      2009-09-07 13:45:15.000000000 +0530
     1335+++ bfd/coffswap.h      2010-02-11 11:24:25.908936000 +0530
     1336@@ -383,7 +383,11 @@
     1337                  void * ext1,
     1338                  int type,
     1339                  int in_class,
     1340-                 int indx,
     1341+                 int indx
     1342+#if defined(AVR) && __GNUC__
     1343+                __attribute__((unused))
     1344+#endif
     1345+                 ,
     1346                  int numaux,
     1347                  void * in1)
     1348 {
     1349@@ -409,9 +413,13 @@
     1350 #else
     1351          if (numaux > 1)
     1352            {
     1353+#if defined(AVR)
     1354+             memcpy (in->x_file.x_fname, ext->x_file.x_fname, sizeof (AUXENT));
     1355+#else
     1356              if (indx == 0)
     1357                memcpy (in->x_file.x_fname, ext->x_file.x_fname,
     1358                        numaux * sizeof (AUXENT));
     1359+#endif
     1360            }
     1361          else
     1362            memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
     1363diff -Nruw bfd/config.bfd bfd/config.bfd
     1364--- bfd/config.bfd      2009-08-06 23:08:00.000000000 +0530
     1365+++ bfd/config.bfd      2010-02-10 17:35:58.300224600 +0530
     1366@@ -339,6 +339,7 @@
     1367 
     1368   avr-*-*)
     1369     targ_defvec=bfd_elf32_avr_vec
     1370+    targ_selvecs="bfd_elf32_avr_vec avrcoff_vec avrextcoff_vec"
     1371     ;;
     1372 
     1373   bfin-*-*)
     1374diff -Nruw bfd/configure bfd/configure
     1375--- bfd/configure       2009-10-16 17:17:47.000000000 +0530
     1376+++ bfd/configure       2010-02-10 17:35:58.331474600 +0530
     1377@@ -14782,6 +14782,8 @@
     1378     armpe_little_vec)          tb="$tb pe-arm.lo peigen.lo cofflink.lo " ;;
     1379     armpei_big_vec)            tb="$tb pei-arm.lo peigen.lo cofflink.lo " ;;
     1380     armpei_little_vec)         tb="$tb pei-arm.lo peigen.lo cofflink.lo " ;;
     1381+    avrcoff_vec)               tb="$tb coff-avr.lo cofflink.lo " ;;
     1382+    avrextcoff_vec)            tb="$tb coff-ext-avr.lo cofflink.lo " ;;
     1383     b_out_vec_big_host)                tb="$tb bout.lo aout32.lo" ;;
     1384     b_out_vec_little_host)     tb="$tb bout.lo aout32.lo" ;;
     1385     bfd_pei_ia64_vec)          tb="$tb pei-ia64.lo pepigen.lo cofflink.lo"; target_size=64 ;;
     1386diff -Nruw bfd/configure.in bfd/configure.in
     1387--- bfd/configure.in    2009-10-16 17:17:44.000000000 +0530
     1388+++ bfd/configure.in    2010-02-10 17:35:58.331474600 +0530
     1389@@ -670,6 +670,8 @@
     1390     armpe_little_vec)          tb="$tb pe-arm.lo peigen.lo cofflink.lo " ;;
     1391     armpei_big_vec)            tb="$tb pei-arm.lo peigen.lo cofflink.lo " ;;
     1392     armpei_little_vec)         tb="$tb pei-arm.lo peigen.lo cofflink.lo " ;;
     1393+    avrcoff_vec)               tb="$tb coff-avr.lo cofflink.lo " ;;
     1394+    avrextcoff_vec)            tb="$tb coff-ext-avr.lo cofflink.lo " ;;
     1395     b_out_vec_big_host)                tb="$tb bout.lo aout32.lo" ;;
     1396     b_out_vec_little_host)     tb="$tb bout.lo aout32.lo" ;;
     1397     bfd_pei_ia64_vec)          tb="$tb pei-ia64.lo pepigen.lo cofflink.lo"; target_size=64 ;;
     1398diff -Nruw bfd/targets.c bfd/targets.c
     1399--- bfd/targets.c       2009-09-10 17:17:13.000000000 +0530
     1400+++ bfd/targets.c       2010-02-10 17:35:58.347099600 +0530
     1401@@ -564,6 +564,8 @@
     1402 extern const bfd_target armpe_little_vec;
     1403 extern const bfd_target armpei_big_vec;
     1404 extern const bfd_target armpei_little_vec;
     1405+extern const bfd_target avrcoff_vec;
     1406+extern const bfd_target avrextcoff_vec;
     1407 extern const bfd_target b_out_vec_big_host;
     1408 extern const bfd_target b_out_vec_little_host;
     1409 extern const bfd_target bfd_pei_ia64_vec;
     1410@@ -890,6 +892,8 @@
     1411        &armpe_little_vec,
     1412        &armpei_big_vec,
     1413        &armpei_little_vec,
     1414+       &avrcoff_vec,
     1415+       &avrextcoff_vec,
     1416        &b_out_vec_big_host,
     1417        &b_out_vec_little_host,
     1418 #ifdef BFD64
     1419diff -Nruw binutils/Makefile.am binutils/Makefile.am
     1420--- binutils/Makefile.am        2009-09-09 13:43:23.000000000 +0530
     1421+++ binutils/Makefile.am        2010-02-10 17:35:57.972099600 +0530
     1422@@ -101,7 +101,7 @@
     1423        resbin.c rescoff.c resrc.c resres.c \
     1424        size.c srconv.c stabs.c strings.c sysdump.c \
     1425        unwind-ia64.c version.c \
     1426-       windres.c winduni.c wrstabs.c \
     1427+       windres.c winduni.c wrcoff.c wrstabs.c \
     1428        windmc.c mclex.c
     1429 
     1430 GENERATED_CFILES = \
     1431@@ -109,7 +109,7 @@
     1432        defparse.c deflex.c nlmheader.c rcparse.c mcparse.c
     1433 
     1434 DEBUG_SRCS = rddbg.c debug.c stabs.c ieee.c rdcoff.c
     1435-WRITE_DEBUG_SRCS = $(DEBUG_SRCS) wrstabs.c
     1436+WRITE_DEBUG_SRCS = $(DEBUG_SRCS) wrstabs.c wrcoff.c
     1437 
     1438 # Code shared by all the binutils.
     1439 BULIBS = bucomm.c version.c filemode.c
     1440diff -Nruw binutils/Makefile.in binutils/Makefile.in
     1441--- binutils/Makefile.in        2009-09-09 13:43:23.000000000 +0530
     1442+++ binutils/Makefile.in        2010-02-10 17:35:57.987724600 +0530
     1443@@ -126,7 +126,7 @@
     1444 nm_new_OBJECTS = $(am_nm_new_OBJECTS)
     1445 nm_new_LDADD = $(LDADD)
     1446 am__objects_2 = rddbg.$(OBJEXT) debug.$(OBJEXT) stabs.$(OBJEXT) \
     1447-       ieee.$(OBJEXT) rdcoff.$(OBJEXT)
     1448+       ieee.$(OBJEXT) rdcoff.$(OBJEXT) wrcoff.$(OBJEXT)
     1449 am__objects_3 = $(am__objects_2) wrstabs.$(OBJEXT)
     1450 am_objcopy_OBJECTS = objcopy.$(OBJEXT) not-strip.$(OBJEXT) \
     1451        rename.$(OBJEXT) $(am__objects_3) $(am__objects_1)
     1452@@ -439,7 +439,7 @@
     1453        resbin.c rescoff.c resrc.c resres.c \
     1454        size.c srconv.c stabs.c strings.c sysdump.c \
     1455        unwind-ia64.c version.c \
     1456-       windres.c winduni.c wrstabs.c \
     1457+       windres.c winduni.c wrcoff.c wrstabs.c \
     1458        windmc.c mclex.c
     1459 
     1460 GENERATED_CFILES = \
     1461@@ -447,7 +447,7 @@
     1462        defparse.c deflex.c nlmheader.c rcparse.c mcparse.c
     1463 
     1464 DEBUG_SRCS = rddbg.c debug.c stabs.c ieee.c rdcoff.c
     1465-WRITE_DEBUG_SRCS = $(DEBUG_SRCS) wrstabs.c
     1466+WRITE_DEBUG_SRCS = $(DEBUG_SRCS) wrstabs.c wrcoff.c
     1467 
     1468 # Code shared by all the binutils.
     1469 BULIBS = bucomm.c version.c filemode.c
     1470diff -Nruw binutils/bucomm.c binutils/bucomm.c
     1471--- binutils/bucomm.c   2009-09-14 17:13:26.000000000 +0530
     1472+++ binutils/bucomm.c   2010-02-10 17:35:58.034599600 +0530
     1473@@ -550,6 +550,32 @@
     1474   return ret;
     1475 }
     1476 
     1477+/* Return the basename of "file", i. e. everything minus whatever
     1478+   directory part has been provided.  Stolen from bfd/archive.c.
     1479+   Should we also handle the VMS case (as in bfd/archive.c)?  */
     1480+const char *
     1481+bu_basename (file)
     1482+     const char *file;
     1483+{
     1484+  const char *filename = strrchr (file, '/');
     1485+
     1486+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
     1487+  {
     1488+    /* We could have foo/bar\\baz, or foo\\bar, or d:bar.  */
     1489+    char *bslash = strrchr (file, '\\');
     1490+    if (filename == NULL || (bslash != NULL && bslash > filename))
     1491+      filename = bslash;
     1492+    if (filename == NULL && file[0] != '\0' && file[1] == ':')
     1493+      filename = file + 1;
     1494+  }
     1495+#endif
     1496+  if (filename != (char *) NULL)
     1497+    filename++;
     1498+  else
     1499+    filename = file;
     1500+  return filename;
     1501+}
     1502+
     1503 /* Returns the size of the named file.  If the file does not
     1504    exist, or if it is not a real file, then a suitable non-fatal
     1505    error message is printed and zero is returned.  */
     1506diff -Nruw binutils/bucomm.h binutils/bucomm.h
     1507--- binutils/bucomm.h   2009-09-02 12:52:31.000000000 +0530
     1508+++ binutils/bucomm.h   2010-02-10 17:35:58.050224600 +0530
     1509@@ -58,6 +58,8 @@
     1510 
     1511 off_t get_file_size (const char *);
     1512 
     1513+const char *bu_basename PARAMS ((const char *));
     1514+
     1515 extern char *program_name;
     1516 
     1517 /* filemode.c */
     1518diff -Nruw binutils/budbg.h binutils/budbg.h
     1519--- binutils/budbg.h    2009-09-02 12:52:31.000000000 +0530
     1520+++ binutils/budbg.h    2010-02-10 17:35:58.050224600 +0530
     1521@@ -52,8 +52,11 @@
     1522 
     1523 extern bfd_boolean write_ieee_debugging_info (bfd *, void *);
     1524 
     1525-/* Routine used to read COFF debugging information.  */
     1526+/* Routine used to read and write COFF debugging information.  */
     1527 
     1528 extern bfd_boolean parse_coff (bfd *, asymbol **, long, void *);
     1529 
     1530+extern bfd_boolean write_coff_debugging_info
     1531+  (bfd *abfd, void *, long *symcountp, asymbol ***);
     1532+
     1533 #endif
     1534diff -Nruw binutils/debug.c binutils/debug.c
     1535--- binutils/debug.c    2009-09-14 17:13:26.000000000 +0530
     1536+++ binutils/debug.c    2010-02-11 10:50:38.043866600 +0530
     1537@@ -31,6 +31,7 @@
     1538 #include <assert.h>
     1539 #include "bfd.h"
     1540 #include "libiberty.h"
     1541+#include "bucomm.h"
     1542 #include "debug.h"
     1543 
     1544 /* Global information we keep for debugging.  A pointer to this
     1545@@ -552,6 +553,19 @@
     1546   struct debug_type_s *t;
     1547 };
     1548 
     1549+/* Simple list, used for pathname translations. */
     1550+struct xlat_list
     1551+{
     1552+  /* Next string on list. */
     1553+  struct xlat_list *next;
     1554+  /* Old part to match against. */
     1555+  const char *old;
     1556+  size_t olen;
     1557+  /* New part to replace. */
     1558+  const char *newstr;
     1559+  size_t nlen;
     1560+};
     1561+
     1562 /* Local functions.  */
     1563 
     1564 static void debug_error (const char *);
     1565@@ -588,6 +602,11 @@
     1566   (struct debug_handle *, struct debug_type_s *, struct debug_type_s *);
     1567 static bfd_boolean debug_class_type_samep
     1568   (struct debug_handle *, struct debug_type_s *, struct debug_type_s *);
     1569+static const char *debug_xlat_pathname (const char *);
     1570+
     1571+/* List of pathname translations. */
     1572+static struct xlat_list *xlat, *xltail;
     1573+static bfd_boolean xlat_basename;
     1574 
    01575
     1576 /* Issue an error message.  */
     1577 
     1578@@ -680,6 +699,8 @@
     1579 
     1580   if (name == NULL)
     1581     name = "";
     1582+  else
     1583+    name = debug_xlat_pathname (name);
     1584 
     1585   nfile = (struct debug_file *) xmalloc (sizeof *nfile);
     1586   memset (nfile, 0, sizeof *nfile);
     1587@@ -720,6 +741,8 @@
     1588 
     1589   if (name == NULL)
     1590     name = "";
     1591+  else
     1592+    name = debug_xlat_pathname (name);
     1593 
     1594   if (info->current_unit == NULL)
     1595     {
     1596@@ -3370,3 +3393,69 @@
     1597 
     1598   return TRUE;
     1599 }
     1600+
     1601+/* Register a pathname translation. */
     1602+void
     1603+debug_register_pathname_xlat (oname, nname)
     1604+     const char *oname;
     1605+     const char *nname;
     1606+{
     1607+  struct xlat_list *xlp;
     1608+
     1609+  /* Special case: if oname is given as NULL, this means the
     1610+     --basename option has been given to objcopy. */
     1611+  if (oname == NULL)
     1612+    {
     1613+      xlat_basename = TRUE;
     1614+      return;
     1615+    }
     1616+
     1617+  xlp = (struct xlat_list *) xmalloc (sizeof (struct xlat_list));
     1618+  xlp->next = NULL;
     1619+  if (xlat == NULL)
     1620+    xlat = xltail = xlp;
     1621+  else
     1622+    {
     1623+      xltail->next = xlp;
     1624+      xltail = xlp;
     1625+    }
     1626+  xlp->old = oname;
     1627+  xlp->newstr = nname;
     1628+  xlp->olen = strlen (oname);
     1629+  xlp->nlen = strlen (nname);
     1630+}
     1631+
     1632+/* Try to translate a pathname. */
     1633+static const char *
     1634+debug_xlat_pathname (oname)
     1635+     const char *oname;
     1636+{
     1637+  struct xlat_list *xlp;
     1638+  char *cp;
     1639+  size_t olen;
     1640+
     1641+  if (xlat_basename)
     1642+    return bu_basename (oname); 
     1643+
     1644+  olen = strlen (oname);
     1645+  for (xlp = xlat; xlp; xlp = xlp->next)
     1646+    {
     1647+      if (xlp->olen > olen)
     1648+       /* This cannot be our turn. */
     1649+       continue;
     1650+      /* Since we have pre-computed all our length values to avoid
     1651+        repetitively computing them, just use memcmp() since it's
     1652+        faster than strcmp(). */
     1653+      if (memcmp (xlp->old, oname, xlp->olen) == 0)
     1654+       {
     1655+         cp = (char *) xmalloc (olen + xlp->nlen - xlp->olen + 1);
     1656+         memcpy (cp, xlp->newstr, xlp->nlen);
     1657+         memcpy (cp + xlp->nlen, oname + xlp->olen,
     1658+                 olen - xlp->olen + 1);
     1659+         return cp;
     1660+       }
     1661+    }
     1662+
     1663+  /* Not found, pass the original name on. */
     1664+  return oname;
     1665+}
     1666diff -Nruw binutils/debug.h binutils/debug.h
     1667--- binutils/debug.h    2009-09-14 17:13:26.000000000 +0530
     1668+++ binutils/debug.h    2010-02-10 17:35:58.097099600 +0530
     1669@@ -440,6 +440,12 @@
     1670 
     1671 extern bfd_boolean debug_start_source (void *, const char *);
     1672 
     1673+/* Register a pathname translation for source (and include) filenames.
     1674+   This is used by the --change-pathname option of objcopy. */
     1675+
     1676+extern void debug_register_pathname_xlat
     1677+  PARAMS ((const char *, const char *));
     1678+
     1679 /* Record a function definition.  This implicitly starts a function
     1680    block.  The debug_type argument is the type of the return value.
     1681    The bfd_boolean indicates whether the function is globally visible.
     1682diff -Nruw binutils/doc/objcopy.1 binutils/doc/objcopy.1
     1683--- binutils/doc/objcopy.1      2009-10-16 17:22:19.000000000 +0530
     1684+++ binutils/doc/objcopy.1      2010-02-11 10:22:09.312500000 +0530
     1685@@ -202,6 +202,8 @@
     1686         [\fB\-\-readonly\-text\fR]
     1687         [\fB\-\-pure\fR]
     1688         [\fB\-\-impure\fR]
     1689+       [\fB\-\-change\-pathname\fR \fIold\fR=\fInew\fR]
     1690+       [\fB\-\-basename\fR]
     1691         [\fB\-\-file\-alignment=\fR\fInum\fR]
     1692         [\fB\-\-heap=\fR\fIsize\fR]
     1693         [\fB\-\-image\-base=\fR\fIaddress\fR]
     1694@@ -885,6 +887,23 @@
     1695 It can also be a useful way of reducing the size of a \fB\-\-just\-symbols\fR
     1696 linker input file.
     1697 .RE
     1698+.IP "\fB\-\-change\-pathname\fR \fIold\fR=\fInew\fR" 4
     1699+.IX Item "--change-pathname old=new"
     1700+When converting debugging information using \fB\-\-debugging\fR, for
     1701+every pathname that starts with \fIold\fR, replace the matching part
     1702+by \fInew\fR.  This is intented to map pathnames between different
     1703+debugging tools, or when parts of the object file(s) had their
     1704+pathnames recorded in a different build environment.  Note that only
     1705+leading directory name components might be changed that way, since the
     1706+trailing filename could be recorded elsewhere as well (depending on the
     1707+debugging format of the input file).
     1708+.IP "\fB\-\-basename\fR"
     1709+.IX Item "--basename"
     1710+When converting debugging information using \fB\-\-debugging\fR, for
     1711+every pathname, strip all leading directory information.  This option
     1712+takes precedence over any \fB\-\-change\-pathname\fR option.  For some
     1713+debugging formats that cannot handle long filenames, this options is
     1714+implied (notably, some COFF debugging formats).
     1715 .IP "\fB\-V\fR" 4
     1716 .IX Item "-V"
     1717 .PD 0
     1718diff -Nruw binutils/objcopy.c binutils/objcopy.c
     1719--- binutils/objcopy.c  2009-09-14 17:13:26.000000000 +0530
     1720+++ binutils/objcopy.c  2010-02-11 10:56:56.890302300 +0530
     1721@@ -32,6 +32,7 @@
     1722 #include "elf-bfd.h"
     1723 #include <sys/stat.h>
     1724 #include "libbfd.h"
     1725+#include "debug.h"
     1726 #include "coff/internal.h"
     1727 #include "libcoff.h"
     1728 
     1729@@ -297,6 +298,8 @@
     1730     OPTION_IMPURE,
     1731     OPTION_EXTRACT_SYMBOL,
     1732     OPTION_REVERSE_BYTES,
     1733+    OPTION_CHANGE_PATHNAME,
     1734+    OPTION_BASENAME,
     1735     OPTION_FILE_ALIGNMENT,
     1736     OPTION_HEAP,
     1737     OPTION_IMAGE_BASE,
     1738@@ -346,10 +349,12 @@
     1739   {"adjust-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
     1740   {"adjust-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
     1741   {"alt-machine-code", required_argument, 0, OPTION_ALT_MACH_CODE},
     1742+  {"basename", no_argument, 0, OPTION_BASENAME},
     1743   {"binary-architecture", required_argument, 0, 'B'},
     1744   {"byte", required_argument, 0, 'b'},
     1745   {"change-addresses", required_argument, 0, OPTION_CHANGE_ADDRESSES},
     1746   {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR},
     1747+  {"change-pathname", required_argument, 0, OPTION_CHANGE_PATHNAME},
     1748   {"change-section-address", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
     1749   {"change-section-lma", required_argument, 0, OPTION_CHANGE_SECTION_LMA},
     1750   {"change-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_VMA},
     1751@@ -543,6 +548,8 @@
     1752      --prefix-alloc-sections <prefix>\n\
     1753                                    Add <prefix> to start of every allocatable\n\
     1754                                      section name\n\
     1755+     --change-pathname <old>=<new> Change debug pathnames from <old> to <new>\n\
     1756+     --basename                    Strip directory part from debug pathnames\n\
     1757      --file-alignment <num>        Set PE file alignment to <num>\n\
     1758      --heap <reserve>[,<commit>]   Set PE reserve/commit heap to <reserve>/\n\
     1759                                    <commit>\n\
     1760@@ -999,6 +1006,8 @@
     1761   asymbol **from = isyms, **to = osyms;
     1762   long src_count = 0, dst_count = 0;
     1763   int relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
     1764+  bfd_boolean need_for_debugging = convert_debugging
     1765+    && bfd_get_arch (abfd) == bfd_arch_avr;
     1766 
     1767   for (; src_count < symcount; src_count++)
     1768     {
     1769@@ -1099,7 +1108,8 @@
     1770               || bfd_is_com_section (bfd_get_section (sym)))
     1771        keep = strip_symbols != STRIP_UNNEEDED;
     1772       else if ((flags & BSF_DEBUGGING) != 0)   /* Debugging symbol.  */
     1773-       keep = (strip_symbols != STRIP_DEBUG
     1774+       keep = need_for_debugging
     1775+               || (strip_symbols != STRIP_DEBUG
     1776                && strip_symbols != STRIP_UNNEEDED
     1777                && ! convert_debugging);
     1778       else if (bfd_coff_get_comdat_section (abfd, bfd_get_section (sym)))
     1779@@ -2817,6 +2827,10 @@
     1780     return write_ieee_debugging_info (obfd, dhandle);
     1781 
     1782   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
     1783+      && bfd_get_arch (obfd) == bfd_arch_avr)
     1784+    return write_coff_debugging_info (obfd, dhandle, symcountp, symppp);
     1785+
     1786+  if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
     1787       || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
     1788     {
     1789       bfd_byte *syms, *strings;
     1790@@ -3641,6 +3655,30 @@
     1791          prefix_alloc_sections_string = optarg;
     1792          break;
     1793 
     1794+       case OPTION_CHANGE_PATHNAME:
     1795+         {
     1796+           const char *s;
     1797+           int len;
     1798+           char *name;
     1799+
     1800+           s = strchr (optarg, '=');
     1801+           if (s == NULL)
     1802+             fatal (_("bad format for %s"), "--change-pathname");
     1803+
     1804+           len = s - optarg;
     1805+           name = (char *) xmalloc (len + 1);
     1806+           strncpy (name, optarg, len);
     1807+           name[len] = '\0';
     1808+
     1809+           debug_register_pathname_xlat (name, s + 1);
     1810+         }
     1811+         break;
     1812+
     1813+       case OPTION_BASENAME:
     1814+         /* very special case of pathname translation */
     1815+         debug_register_pathname_xlat (NULL, NULL);
     1816+         break;
     1817+
     1818        case OPTION_READONLY_TEXT:
     1819          bfd_flags_to_set |= WP_TEXT;
     1820          bfd_flags_to_clear &= ~WP_TEXT;
     1821diff -Nruw binutils/rdcoff.c binutils/rdcoff.c
     1822--- binutils/rdcoff.c   2009-09-02 12:52:32.000000000 +0530
     1823+++ binutils/rdcoff.c   2010-02-10 17:35:58.128349600 +0530
     1824@@ -82,6 +82,9 @@
     1825   struct coff_slots *slots;
     1826   /* Basic types.  */
     1827   debug_type basic[T_MAX + 1];
     1828+  /* Some general information, kept here for convenience. */
     1829+  size_t intsize;              /* sizeof (int) */
     1830+  size_t doublesize;           /* sizeof (double) */
     1831 };
     1832 
     1833 static debug_type *coff_get_slot (struct coff_types *, int);
     1834@@ -101,6 +104,7 @@
     1835   (bfd *, struct coff_types *, asymbol *, long, struct internal_syment *,
     1836    void *, debug_type, bfd_boolean);
     1837 static bfd_boolean external_coff_symbol_p (int sym_class);
     1838+static bfd_vma coff_convert_register (bfd *, bfd_vma);
     1839 
    11840
     1841 /* Return the slot for a type.  */
     1842 
     1843@@ -271,8 +275,7 @@
     1844       break;
     1845 
     1846     case T_INT:
     1847-      /* FIXME: Perhaps the size should depend upon the architecture.  */
     1848-      ret = debug_make_int_type (dhandle, 4, FALSE);
     1849+      ret = debug_make_int_type (dhandle, types->intsize, FALSE);
     1850       name = "int";
     1851       break;
     1852 
     1853@@ -287,7 +290,7 @@
     1854       break;
     1855 
     1856     case T_DOUBLE:
     1857-      ret = debug_make_float_type (dhandle, 8);
     1858+      ret = debug_make_float_type (dhandle, types->doublesize);
     1859       name = "double";
     1860       break;
     1861 
     1862@@ -307,7 +310,7 @@
     1863       break;
     1864 
     1865     case T_UINT:
     1866-      ret = debug_make_int_type (dhandle, 4, TRUE);
     1867+      ret = debug_make_int_type (dhandle, types->intsize, TRUE);
     1868       name = "unsigned int";
     1869       break;
     1870 
     1871@@ -565,6 +568,8 @@
     1872 
     1873     case C_WEAKEXT:
     1874     case C_EXT:
     1875+      /* AVR COFF abuses C_EXTDEF */
     1876+    case C_EXTDEF:
     1877       if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
     1878                                   DEBUG_GLOBAL, bfd_asymbol_value (sym)))
     1879        return FALSE;
     1880@@ -580,9 +585,9 @@
     1881       break;
     1882 
     1883     case C_REG:
     1884-      /* FIXME: We may need to convert the register number.  */
     1885       if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
     1886-                                  DEBUG_REGISTER, bfd_asymbol_value (sym)))
     1887+                                  DEBUG_REGISTER,
     1888+                                  coff_convert_register (abfd, bfd_asymbol_value (sym))))
     1889        return FALSE;
     1890       break;
     1891 
     1892@@ -596,9 +601,9 @@
     1893       break;
     1894 
     1895     case C_REGPARM:
     1896-      /* FIXME: We may need to convert the register number.  */
     1897       if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type,
     1898-                                   DEBUG_PARM_REG, bfd_asymbol_value (sym)))
     1899+                                   DEBUG_PARM_REG,
     1900+                                   coff_convert_register (abfd, bfd_asymbol_value (sym))))
     1901        return FALSE;
     1902       break;
     1903 
     1904@@ -648,6 +653,28 @@
     1905   return FALSE;
     1906 }
     1907 
     1908+static bfd_vma
     1909+coff_convert_register (abfd, val)
     1910+     bfd *abfd;
     1911+     bfd_vma val;
     1912+{
     1913+
     1914+  switch (bfd_get_arch (abfd))
     1915+    {
     1916+    case bfd_arch_avr:
     1917+      /* AVR COFF wants to describe up to four registers by the four
     1918+        bytes of the 32-bit value.  Unused bytes are filled with
     1919+        0xff.  In theory, this would allow for non-contiguous
     1920+        register usage to hold a single value, but hopefully, no
     1921+        compiler is going to use that feature.  We could not handle
     1922+        it anyway. */
     1923+      return val & 0xff;
     1924+
     1925+    default:
     1926+      return val;
     1927+    }
     1928+}
     1929+
     1930 /* This is the main routine.  It looks through all the symbols and
     1931    handles them.  */
     1932 
     1933@@ -674,6 +701,17 @@
     1934   types.slots = NULL;
     1935   for (i = 0; i <= T_MAX; i++)
     1936     types.basic[i] = DEBUG_TYPE_NULL;
     1937+  switch (bfd_get_arch (abfd))
     1938+    {
     1939+    case bfd_arch_avr:
     1940+      types.intsize = 2;
     1941+      types.doublesize = 4;
     1942+      break;
     1943+
     1944+    default:
     1945+      types.intsize = 4;
     1946+      types.doublesize = 8;
     1947+    }
     1948 
     1949   next_c_file = -1;
     1950   fnname = NULL;
     1951@@ -734,7 +772,6 @@
     1952       switch (syment.n_sclass)
     1953        {
     1954        case C_EFCN:
     1955-       case C_EXTDEF:
     1956        case C_ULABEL:
     1957        case C_USTATIC:
     1958        case C_LINE:
     1959@@ -757,6 +794,8 @@
     1960          /* Fall through.  */
     1961        case C_WEAKEXT:
     1962        case C_EXT:
     1963+         /* AVR COFF abuses C_EXTDEF for C_EXT */
     1964+       case C_EXTDEF:
     1965          if (ISFCN (syment.n_type))
     1966            {
     1967              fnname = name;
     1968diff -Nruw binutils/wrcoff.c binutils/wrcoff.c
     1969--- binutils/wrcoff.c   1970-01-01 05:30:00.000000000 +0530
     1970+++ binutils/wrcoff.c   2010-02-10 17:35:58.159599600 +0530
     1971@@ -0,0 +1,3410 @@
     1972+/* wrcoff.c -- Generate (AVR) COFF debugging information
     1973+   Copyright 2003 Free Software Foundation, Inc.
     1974+
     1975+   Written by Joerg Wunsch.
     1976+
     1977+   This file is part of GNU Binutils.
     1978+
     1979+   This program is free software; you can redistribute it and/or modify
     1980+   it under the terms of the GNU General Public License as published by
     1981+   the Free Software Foundation; either version 2 of the License, or
     1982+   (at your option) any later version.
     1983+
     1984+   This program is distributed in the hope that it will be useful,
     1985+   but WITHOUT ANY WARRANTY; without even the implied warranty of
     1986+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     1987+   GNU General Public License for more details.
     1988+
     1989+   You should have received a copy of the GNU General Public License
     1990+   along with this program; if not, write to the Free Software
     1991+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
     1992+   02111-1307, USA.  */
     1993+
     1994+/* This file contains code which writes out COFF debugging
     1995+   information.  By now, this has only been tested on the AVR
     1996+   platform, though any attempt has been made to keep the conversion
     1997+   applicable to possible other COFF debugging consumers as well. */
     1998+
     1999+#include <stdio.h>
     2000+#include <assert.h>
     2001+
     2002+#include "sysdep.h"
     2003+#include "bfd.h"
     2004+#include "coff/internal.h"
     2005+#include "bucomm.h"
     2006+#include "libiberty.h"
     2007+#include "safe-ctype.h"
     2008+#include "debug.h"
     2009+#include "budbg.h"
     2010+
     2011+/* Enabling COFF_DEBUG will trace the internal callback functions and
     2012+   their parameters as debug_write() calls them. */
     2013+//#define COFF_DEBUG 1
     2014+
     2015+#include "libcoff.h"
     2016+
     2017+#define N_TMASK (coff_data (info->abfd)->local_n_tmask)
     2018+#define N_BTSHFT (coff_data (info->abfd)->local_n_btshft)
     2019+#define N_BTMASK (coff_data (info->abfd)->local_n_btmask)
     2020+#define N_TSHIFT (coff_data (info->abfd)->local_n_tshift)
     2021+
     2022+/* Structure of local symbols per compilation unit. */
     2023+struct coff_compilation_unit
     2024+{
     2025+  const char *fname;
     2026+  asymbol **syms;
     2027+  long nsyms, totsyms;
     2028+};
     2029+
     2030+enum ts_kind
     2031+{
     2032+  TS_EMPTY,
     2033+  TS_VOID,
     2034+  TS_INT,
     2035+  TS_FLOAT,
     2036+  TS_COMPLEX,
     2037+  TS_ENUM,
     2038+  TS_POINTER,
     2039+  TS_FUNC,
     2040+  TS_ARRAY,
     2041+  TS_STRUCT,
     2042+  TS_NONE = -1
     2043+};
     2044+
     2045+/* Structure defining the pre-defined types. */
     2046+struct coff_predef_type
     2047+{
     2048+  enum ts_kind kind;
     2049+  unsigned int size;           /* in bytes */
     2050+  bfd_boolean isunsigned;
     2051+  int slot;
     2052+};
     2053+
     2054+struct coff_type_stack;
     2055+struct coff_hash_entry;
     2056+
     2057+struct coff_struct_fields
     2058+{
     2059+  const char *name;
     2060+  bfd_vma bitpos;
     2061+  bfd_vma bitsize;
     2062+  enum debug_visibility visibility;
     2063+  struct coff_type_stack *types;
     2064+};
     2065+
     2066+/* Our type stack. */
     2067+struct coff_type_stack
     2068+{
     2069+  struct coff_type_stack *next;
     2070+  enum ts_kind tsk;
     2071+  union
     2072+  {
     2073+    /* TS_INT */
     2074+    struct
     2075+    {
     2076+      unsigned int size;
     2077+      bfd_boolean isunsigned;
     2078+    }
     2079+    ts_int;
     2080+
     2081+    /* TS_FLOAT */
     2082+    struct
     2083+    {
     2084+      unsigned int size;
     2085+    }
     2086+    ts_float;
     2087+
     2088+    /* TS_ENUM */
     2089+    struct
     2090+    {
     2091+      union
     2092+      {
     2093+       const char *fixtag;
     2094+       char *malloctag;
     2095+      }
     2096+      tag;
     2097+      bfd_boolean tagismalloced;
     2098+      const char **names;
     2099+      bfd_signed_vma *vals;
     2100+      struct coff_enum_hash_entry *ehash;
     2101+    }
     2102+    ts_enum;
     2103+
     2104+    /* TS_FUNC */
     2105+    struct
     2106+    {
     2107+      struct coff_type_stack *savedts;
     2108+    }
     2109+    ts_func;
     2110+
     2111+    /* TS_ARRAY */
     2112+    struct
     2113+    {
     2114+      bfd_signed_vma low;
     2115+      bfd_signed_vma high;
     2116+    }
     2117+    ts_array;
     2118+
     2119+    /* TS_STRUCT */
     2120+    struct
     2121+    {
     2122+      union
     2123+      {
     2124+       const char *fixtag;
     2125+       char *malloctag;
     2126+      }
     2127+      tag;
     2128+      bfd_boolean tagismalloced;
     2129+      unsigned int id;
     2130+      bfd_boolean isstruct;
     2131+      unsigned int size;
     2132+      long nfields;
     2133+      struct coff_struct_fields *fields;
     2134+      struct coff_type_stack *savedts;
     2135+      struct coff_struct_hash_entry *shash;
     2136+    }
     2137+    ts_struct;
     2138+  }
     2139+  u;
     2140+};
     2141+
     2142+struct coff_name_type_hash_table
     2143+{
     2144+  struct bfd_hash_table root;
     2145+};
     2146+
     2147+struct coff_name_type_hash_entry
     2148+{
     2149+  struct bfd_hash_entry root;
     2150+  /* Information for this name.  */
     2151+  struct coff_type_stack *types;
     2152+  bfd_boolean emitted;
     2153+};
     2154+
     2155+struct coff_struct_hash_table
     2156+{
     2157+  struct bfd_hash_table root;
     2158+};
     2159+
     2160+struct coff_struct_hash_entry
     2161+{
     2162+  struct bfd_hash_entry root;
     2163+  /* Information for this name.  */
     2164+  struct coff_type_stack *types;
     2165+  bfd_boolean emitted;
     2166+  combined_entry_type *native;
     2167+  /* list of symbol indices that need fixing */
     2168+  long *fixidxs;
     2169+  unsigned nfixidxs;
     2170+};
     2171+
     2172+struct coff_enum_hash_table
     2173+{
     2174+  struct bfd_hash_table root;
     2175+};
     2176+
     2177+struct coff_enum_hash_entry
     2178+{
     2179+  struct bfd_hash_entry root;
     2180+  /* Information for this name.  */
     2181+  struct coff_type_stack *types;
     2182+  bfd_boolean emitted;
     2183+  combined_entry_type *native;
     2184+  /* list of symbol indices that need fixing */
     2185+  long *fixidxs;
     2186+  unsigned nfixidxs;
     2187+};
     2188+
     2189+/* COFF private symbol data.  Used as a cookie to pass data around
     2190+   between various processing stages.  The generic COFF handling code
     2191+   doesn't use any private data. */
     2192+struct coff_private_symdata
     2193+{
     2194+  unsigned int size;           /* size of symbol, used in AVR register
     2195+                                  translation */
     2196+  struct coff_struct_hash_entry *shash; /* TS_STRUCT hash for fixups */
     2197+  struct coff_enum_hash_entry *ehash; /* TS_ENUM hash for fixups */
     2198+};
     2199+
     2200+/* Stack of tags that need endndx fixing. */
     2201+struct coff_fix_stack
     2202+{
     2203+  struct coff_fix_stack *next;
     2204+  combined_entry_type *native;
     2205+};
     2206+
     2207+/* This is the handle passed through debug_write.  */
     2208+
     2209+struct coff_write_handle
     2210+{
     2211+  /* The BFD.  */
     2212+  bfd *abfd;
     2213+  /* Pointers to .text and .data sections, can be used as defaults if
     2214+     no other information is available. */
     2215+  asection *textsect;
     2216+  asection *datasect;
     2217+  /* Some special flags. */
     2218+  unsigned long flags;
     2219+  /* Flags describing architecture options. */
     2220+#define COFF_FL_AVR    0x0001  /* COFF is for AVR platform. */
     2221+#define COFF_FL_EXT_AVR        0x0002  /* AVR "extended" COFF */
     2222+  /* Flags describing internal status information. */
     2223+#define COFF_FL_FIX_ENDNDX     0x10000 /* apply endndx fix at next symbol */
     2224+#define COFF_FL_START_FCN      0x20000 /* begin of function pending */
     2225+#define COFF_FL_FIX_BB         0x40000 /* fix last ".bb" symbol */
     2226+  /* List of our compilation units, from input symbol table. */
     2227+  struct coff_compilation_unit *units;
     2228+  long nunits;
     2229+  struct coff_compilation_unit *currentfile;
     2230+  /* Global symbols from input symbol table. */
     2231+  asymbol **globals;
     2232+  long nglobals;
     2233+  /* Section syms for named sections. */
     2234+  coff_symbol_type **secsyms;
     2235+  long nsecsyms;
     2236+  /* Our COFF symbols. */
     2237+  asymbol **syms;
     2238+  long nsyms;
     2239+  /* Total line number count. */
     2240+  unsigned long totlnos;
     2241+  /* Size of standard objects on this arch. */
     2242+  unsigned int pointersize;
     2243+  unsigned int enumsize;
     2244+  /* Pending information when starting a function.  We have to defer
     2245+     almost everything, some actions can be taken when seeing the
     2246+     starting block of that function, some will even have to wait
     2247+     until we see the end of the function. */
     2248+  const char *funname;         /* name of function */
     2249+  bfd_boolean funglobal;               /* global/local function? */
     2250+  unsigned int lastlno;                /* last line number seen so far */
     2251+  long funcindex;              /* index of ".func" symbol in syms */
     2252+  unsigned int nlnos;          /* line numbers recorded for this function*/
     2253+  bfd_vma endaddr;             /* last .eb address we have seen so far */
     2254+  unsigned int funlno;         /* first line number in function */
     2255+  coff_symbol_type **fargs;    /* function arguments */
     2256+  unsigned int nfargs;
     2257+  asection *funcsection;       /* section the current function is using */
     2258+  /* Type information */
     2259+  struct coff_type_stack *tstack;
     2260+  struct coff_name_type_hash_table types;
     2261+  struct coff_struct_hash_table structs;
     2262+  struct coff_enum_hash_table enums;
     2263+  unsigned nenums;             /* counter for anonymous enum tags */
     2264+  /* Stack of pending endndx fixes, see coff_record_symbol(). */
     2265+  struct coff_fix_stack *fixes;
     2266+};
     2267+
     2268+/* Predefined types, default to usual 32-bit architectures.
     2269+   Arch-dependant different byte sizes will be tuned upon entering
     2270+   write_coff_debugging_info().  The table is looked up from front to
     2271+   end, so we put `more popular' types that might have the same size
     2272+   as other types first (e. g. "int" precedes "long" and "short"). */
     2273+static struct coff_predef_type coff_predef_types[] =
     2274+{
     2275+  { TS_INT, 4, FALSE, 4 },     /* signed int */
     2276+  { TS_INT, 1, FALSE, 2 },     /* signed char */
     2277+  { TS_INT, 2, FALSE, 3 },     /* signed short */
     2278+  { TS_INT, 4, FALSE, 5 },     /* long int */
     2279+  { TS_FLOAT, 8, FALSE, 7 },   /* double */
     2280+  { TS_FLOAT, 4, FALSE, 6 },   /* float */
     2281+  { TS_INT, 4, TRUE, 14 },     /* unsigned int */
     2282+  { TS_INT, 1, TRUE, 12 },     /* unsigned char */
     2283+  { TS_INT, 2, TRUE, 13 },     /* unsigned short */
     2284+  { TS_INT, 4, TRUE, 15 },     /* unsigned long */
     2285+};
     2286+
     2287+static bfd_boolean coff_copy_symbols
     2288+  PARAMS ((struct coff_write_handle *, long, asymbol **));
     2289+static asymbol *coff_find_symbol
     2290+  PARAMS ((struct coff_write_handle *, const char *, bfd_boolean, bfd_boolean));
     2291+static void coff_record_symbol
     2292+  PARAMS ((struct coff_write_handle *, coff_symbol_type *));
     2293+static symvalue coff_fixup_avr_register PARAMS ((symvalue, int));
     2294+static struct bfd_hash_entry *coff_name_type_newfunc
     2295+  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
     2296+static bfd_boolean coff_free_type_info
     2297+  PARAMS ((struct coff_name_type_hash_entry *, PTR));
     2298+static struct bfd_hash_entry *coff_struct_newfunc
     2299+  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
     2300+static bfd_boolean coff_free_struct_info
     2301+  PARAMS ((struct coff_struct_hash_entry *, PTR));
     2302+static struct bfd_hash_entry *coff_enum_newfunc
     2303+  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
     2304+static bfd_boolean coff_free_enum_info
     2305+  PARAMS ((struct coff_enum_hash_entry *, PTR));
     2306+static unsigned int coff_get_fundamental_type
     2307+  PARAMS ((struct coff_write_handle *, struct coff_type_stack *));
     2308+static bfd_boolean coff_make_typed_symbol
     2309+  PARAMS ((struct coff_write_handle *, coff_symbol_type **, enum ts_kind));
     2310+static bfd_boolean coff_emit_struct
     2311+  PARAMS ((struct coff_write_handle *, struct coff_type_stack *,
     2312+          struct coff_struct_hash_entry *));
     2313+static bfd_boolean coff_emit_enum
     2314+  PARAMS ((struct coff_write_handle *, struct coff_type_stack *,
     2315+          struct coff_enum_hash_entry *));
     2316+static bfd_boolean coff_emit_ndebug_sym
     2317+  PARAMS ((struct coff_write_handle *, asymbol *, bfd_boolean));
     2318+
     2319+static bfd_boolean coff_start_compilation_unit PARAMS ((PTR, const char *));
     2320+static bfd_boolean coff_start_source PARAMS ((PTR, const char *));
     2321+static bfd_boolean coff_empty_type PARAMS ((PTR));
     2322+static bfd_boolean coff_void_type PARAMS ((PTR));
     2323+static bfd_boolean coff_int_type PARAMS ((PTR, unsigned int, bfd_boolean));
     2324+static bfd_boolean coff_float_type PARAMS ((PTR, unsigned int));
     2325+static bfd_boolean coff_complex_type PARAMS ((PTR, unsigned int));
     2326+static bfd_boolean coff_bool_type PARAMS ((PTR, unsigned int));
     2327+static bfd_boolean coff_enum_type
     2328+  PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
     2329+static bfd_boolean coff_pointer_type PARAMS ((PTR));
     2330+static bfd_boolean coff_function_type PARAMS ((PTR, int, bfd_boolean));
     2331+static bfd_boolean coff_reference_type PARAMS ((PTR));
     2332+static bfd_boolean coff_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
     2333+static bfd_boolean coff_array_type
     2334+  PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, bfd_boolean));
     2335+static bfd_boolean coff_set_type PARAMS ((PTR, bfd_boolean));
     2336+static bfd_boolean coff_offset_type PARAMS ((PTR));
     2337+static bfd_boolean coff_method_type PARAMS ((PTR, bfd_boolean, int, bfd_boolean));
     2338+static bfd_boolean coff_const_type PARAMS ((PTR));
     2339+static bfd_boolean coff_volatile_type PARAMS ((PTR));
     2340+static bfd_boolean coff_start_struct_type
     2341+  PARAMS ((PTR, const char *, unsigned int, bfd_boolean, unsigned int));
     2342+static bfd_boolean coff_struct_field
     2343+  PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
     2344+static bfd_boolean coff_end_struct_type PARAMS ((PTR));
     2345+static bfd_boolean coff_start_class_type
     2346+  PARAMS ((PTR, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean,
     2347+          bfd_boolean));
     2348+static bfd_boolean coff_class_static_member
     2349+  PARAMS ((PTR, const char *, const char *, enum debug_visibility));
     2350+static bfd_boolean coff_class_baseclass
     2351+  PARAMS ((PTR, bfd_vma, bfd_boolean, enum debug_visibility));
     2352+static bfd_boolean coff_class_start_method PARAMS ((PTR, const char *));
     2353+static bfd_boolean coff_class_method_variant
     2354+  PARAMS ((PTR, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
     2355+          bfd_vma, bfd_boolean));
     2356+static bfd_boolean coff_class_static_method_variant
     2357+  PARAMS ((PTR, const char *, enum debug_visibility, bfd_boolean, bfd_boolean));
     2358+static bfd_boolean coff_class_end_method PARAMS ((PTR));
     2359+static bfd_boolean coff_end_class_type PARAMS ((PTR));
     2360+static bfd_boolean coff_typedef_type PARAMS ((PTR, const char *));
     2361+static bfd_boolean coff_tag_type
     2362+  PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
     2363+static bfd_boolean coff_typdef PARAMS ((PTR, const char *));
     2364+static bfd_boolean coff_tag PARAMS ((PTR, const char *));
     2365+static bfd_boolean coff_int_constant PARAMS ((PTR, const char *, bfd_vma));
     2366+static bfd_boolean coff_float_constant PARAMS ((PTR, const char *, double));
     2367+static bfd_boolean coff_typed_constant PARAMS ((PTR, const char *, bfd_vma));
     2368+static bfd_boolean coff_variable
     2369+  PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
     2370+static bfd_boolean coff_start_function PARAMS ((PTR, const char *, bfd_boolean));
     2371+static bfd_boolean coff_function_parameter
     2372+  PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
     2373+static bfd_boolean coff_start_block PARAMS ((PTR, bfd_vma));
     2374+static bfd_boolean coff_end_block PARAMS ((PTR, bfd_vma));
     2375+static bfd_boolean coff_end_function PARAMS ((PTR));
     2376+static bfd_boolean coff_lineno
     2377+  PARAMS ((PTR, const char *, unsigned long, bfd_vma));
     2378+
     2379+static const struct debug_write_fns coff_fns =
     2380+{
     2381+  coff_start_compilation_unit,
     2382+  coff_start_source,
     2383+  coff_empty_type,
     2384+  coff_void_type,
     2385+  coff_int_type,
     2386+  coff_float_type,
     2387+  coff_complex_type,
     2388+  coff_bool_type,
     2389+  coff_enum_type,
     2390+  coff_pointer_type,
     2391+  coff_function_type,
     2392+  coff_reference_type,
     2393+  coff_range_type,
     2394+  coff_array_type,
     2395+  coff_set_type,
     2396+  coff_offset_type,
     2397+  coff_method_type,
     2398+  coff_const_type,
     2399+  coff_volatile_type,
     2400+  coff_start_struct_type,
     2401+  coff_struct_field,
     2402+  coff_end_struct_type,
     2403+  coff_start_class_type,
     2404+  coff_class_static_member,
     2405+  coff_class_baseclass,
     2406+  coff_class_start_method,
     2407+  coff_class_method_variant,
     2408+  coff_class_static_method_variant,
     2409+  coff_class_end_method,
     2410+  coff_end_class_type,
     2411+  coff_typedef_type,
     2412+  coff_tag_type,
     2413+  coff_typdef,
     2414+  coff_tag,
     2415+  coff_int_constant,
     2416+  coff_float_constant,
     2417+  coff_typed_constant,
     2418+  coff_variable,
     2419+  coff_start_function,
     2420+  coff_function_parameter,
     2421+  coff_start_block,
     2422+  coff_end_block,
     2423+  coff_end_function,
     2424+  coff_lineno
     2425+};
     2426+
    22427
     2428+/*
     2429+ * Copy our input (non-debugging) symbols.  Local symbols will be
     2430+ * maintained in one bucket per each compilation unit, global (and
     2431+ * weak) symbols will be kept in a simple array.
     2432+ */
     2433+static bfd_boolean
     2434+coff_copy_symbols (info, count, sympp)
     2435+     struct coff_write_handle *info;
     2436+     long count;
     2437+     asymbol **sympp;
     2438+{
     2439+  asymbol *osym;
     2440+  long i;
     2441+  struct coff_compilation_unit *up;
     2442+
     2443+  up = NULL;
     2444+
     2445+  for (i = 0; i < count; i++)
     2446+    {
     2447+      osym = sympp[i];
     2448+
     2449+      /* Try to figure out the .text and .data sections from our input
     2450+        symbols as we walk them.  Unfortunately, this ought to be the
     2451+        /input/ section pointers, so their ->output_section is
     2452+        non-NULL.  That's why we can't simply walk through all the
     2453+        sections of our abfd since this is describing the output
     2454+        only. */
     2455+      if (info->textsect == NULL && osym->section->flags & SEC_CODE)
     2456+       /* Assume this to be our .text section. */
     2457+       info->textsect = osym->section;
     2458+      else if (info->datasect == NULL && osym->section->flags & SEC_DATA)
     2459+       /* Assume this to be our .data section. */
     2460+       info->datasect = osym->section;
     2461+
     2462+      if (osym->flags & BSF_FILE)
     2463+       {
     2464+         /* New file name. */
     2465+         long l;
     2466+
     2467+         up = NULL;
     2468+
     2469+         /* Well, maybe an old one actually?  If so, append it there.
     2470+            This can happen for files that contribute to multiple
     2471+            (input) sections that were concatenated by the linker
     2472+            (like crt1.S). */
     2473+         for (l = 0; l < info->nunits; l++)
     2474+           {
     2475+             if (strcmp (info->units[l].fname, osym->name) == 0)
     2476+               {
     2477+                 up = info->units + l;
     2478+                 break;
     2479+               }
     2480+           }
     2481+
     2482+         if (up == NULL)
     2483+           {
     2484+             info->units = (struct coff_compilation_unit *)
     2485+               xrealloc (info->units,
     2486+                         ++info->nunits * sizeof(struct coff_compilation_unit));
     2487+             up = info->units + (info->nunits - 1);
     2488+             up->fname = osym->name;
     2489+             up->syms = NULL;
     2490+             up->nsyms = up->totsyms = 0;
     2491+           }
     2492+       }
     2493+      else if (osym->flags & (BSF_GLOBAL | BSF_WEAK))
     2494+       {
     2495+         /* Global (or weak) symbols are recorded outside compilation
     2496+            units. */
     2497+         info->globals = (asymbol **)
     2498+           xrealloc (info->globals, ++info->nglobals * sizeof(asymbol *));
     2499+         info->globals[info->nglobals - 1] = osym;
     2500+         continue;
     2501+       }
     2502+      else if (!bfd_is_const_section(osym->section))
     2503+       {
     2504+         if (osym->flags & BSF_SECTION_SYM)
     2505+           {
     2506+             coff_symbol_type *csymp;
     2507+             /* Just record them by now, they'll be fixed up later. */
     2508+
     2509+             if (info->nsyms == 0 && (info->flags & COFF_FL_AVR) == 0)
     2510+               {
     2511+                 /* Very first symbol, fake a compilation unit name
     2512+                    for it.  Historical precedence seems to dictate
     2513+                    this, but AVR COFF does not use that. */
     2514+                 csymp = (coff_symbol_type *)
     2515+                   coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     2516+                 if (csymp == NULL)
     2517+                   return FALSE;
     2518+
     2519+                 csymp->symbol.name = xstrdup ("<fake>");
     2520+                 csymp->symbol.value = 0;
     2521+                 csymp->symbol.udata.p = NULL;
     2522+                 csymp->native->u.syment.n_sclass = C_FILE;
     2523+                 /* force filename into aux entry */
     2524+                 csymp->native->u.syment.n_numaux = 1;
     2525+                 coff_record_symbol (info, csymp);
     2526+               }
     2527+
     2528+             /* convert to COFF native section symbol */
     2529+             csymp = (coff_symbol_type *)
     2530+               coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     2531+             if (csymp == NULL)
     2532+               return FALSE;
     2533+
     2534+             csymp->symbol.name = xstrdup (osym->section->name);
     2535+             csymp->symbol.value = osym->section->output_section->vma;
     2536+             csymp->symbol.flags = BSF_DEBUGGING | BSF_SECTION_SYM;
     2537+             csymp->symbol.section = osym->section;
     2538+             csymp->symbol.udata.p = NULL;
     2539+             csymp->native->fix_scnlen = 1;
     2540+             csymp->native->u.syment.n_sclass = C_STAT;
     2541+             csymp->native->u.syment.n_type = T_NULL;
     2542+             csymp->native->u.syment.n_numaux = 1;
     2543+
     2544+             coff_record_symbol (info, csymp);
     2545+
     2546+             info->secsyms = (coff_symbol_type **)
     2547+               xrealloc (info->secsyms,
     2548+                         ++info->nsecsyms * sizeof(coff_symbol_type *));
     2549+             info->secsyms[info->nsecsyms - 1] = csymp;
     2550+           }
     2551+         else
     2552+           {
     2553+             /* Local symbol in a named section, will be recorded
     2554+                within the respective compilation unit. */
     2555+             if (up == NULL)
     2556+               {
     2557+                 fprintf (stderr,
     2558+                          _("Discarding local symbol outside any compilation unit"));
     2559+                 if (osym->name)
     2560+                   fprintf (stderr, ": %s", osym->name);
     2561+                 putc ('\n', stderr);
     2562+               }
     2563+             else
     2564+               {
     2565+                 up->syms = (asymbol **)
     2566+                   xrealloc (up->syms, ++up->nsyms * sizeof(asymbol *));
     2567+                 up->syms[up->nsyms - 1] = osym;
     2568+                 up->totsyms = up->nsyms;
     2569+                 continue;
     2570+               }
     2571+           }
     2572+       }
     2573+    }
     2574+
     2575+  return TRUE;
     2576+}
     2577+
     2578+/* Find a name in the symbol table.  If found, the respective entry in
     2579+   the symbol vector is zeroed, so after processing all debugging
     2580+   symbols, only non-debugging symbols will remain. */
     2581+static asymbol *
     2582+coff_find_symbol (info, name, isfunction, global)
     2583+     struct coff_write_handle *info;
     2584+     const char *name;
     2585+     bfd_boolean isfunction;
     2586+     bfd_boolean global;
     2587+{
     2588+  asymbol *symp;
     2589+  long i;
     2590+  size_t namelen;
     2591+
     2592+  if (global)
     2593+    {
     2594+      for (i = 0; i < info->nglobals; i++)
     2595+       {
     2596+         symp = info->globals[i];
     2597+         if (symp == NULL)
     2598+           continue;
     2599+         if (strcmp (name, symp->name) == 0
     2600+             && ((symp->flags & BSF_FUNCTION) != 0) == (isfunction == TRUE))
     2601+           {
     2602+             info->globals[i] = NULL;
     2603+             return symp;
     2604+           }
     2605+       }
     2606+      return NULL;
     2607+    }
     2608+
     2609+  if (info->currentfile == NULL)
     2610+    return NULL;
     2611+
     2612+  /* For local symbols, the match optionally stops at a dot in the
     2613+     symtab symbol's name; this is used by gcc to indicate
     2614+     function-scope static symbols (e. g. symbol "foo" will become
     2615+     "foo.1" in function scope). */
     2616+  namelen = strlen (name);
     2617+  for (i = 0; i < info->currentfile->nsyms; i++)
     2618+    {
     2619+      symp = info->currentfile->syms[i];
     2620+      if (symp == NULL)
     2621+       continue;
     2622+      if (strncmp (name, symp->name, namelen) == 0
     2623+         && (symp->name[namelen] == '\0' || symp->name[namelen] == '.')
     2624+         && ((symp->flags & BSF_FUNCTION) != 0) == (isfunction == TRUE))
     2625+       {
     2626+         info->currentfile->syms[i] = NULL;
     2627+         info->currentfile->totsyms--;
     2628+         return symp;
     2629+       }
     2630+    }
     2631+  return NULL;
     2632+}
     2633+
     2634+static void
     2635+coff_record_symbol (info, csymp)
     2636+     struct coff_write_handle *info;
     2637+     coff_symbol_type *csymp;
     2638+{
     2639+  struct coff_private_symdata *priv;
     2640+
     2641+  info->syms = (asymbol **) xrealloc (info->syms,
     2642+                                     ++info->nsyms * sizeof (asymbol *));
     2643+  info->syms[info->nsyms - 1] = (asymbol *)csymp;
     2644+
     2645+  if ((priv = csymp->symbol.udata.p) != NULL)
     2646+    {
     2647+      if (priv->shash != NULL)
     2648+       {
     2649+         struct coff_struct_hash_entry *shash = priv->shash;
     2650+         shash->fixidxs = (long *)
     2651+           xrealloc (shash->fixidxs, ++shash->nfixidxs * sizeof (long));
     2652+         shash->fixidxs[shash->nfixidxs - 1] = info->nsyms - 1;
     2653+       }
     2654+      if (priv->ehash != NULL)
     2655+       {
     2656+         struct coff_enum_hash_entry *ehash = priv->ehash;
     2657+         ehash->fixidxs = (long *)
     2658+           xrealloc (ehash->fixidxs, ++ehash->nfixidxs * sizeof (long));
     2659+         ehash->fixidxs[ehash->nfixidxs - 1] = info->nsyms - 1;
     2660+       }
     2661+      free (priv);
     2662+      csymp->symbol.udata.p = NULL;
     2663+    }
     2664+
     2665+  /* If there are any pending endndx fixes, pop the last element from
     2666+     that stack, and record the current symbol for fixing.  We need to
     2667+     do this here since we need to record our current csymp->native
     2668+     (where that csymp is completely unrelated to whatever symbol was
     2669+     previously generated that requested the fixup).  The stack of
     2670+     pending fixes is required since several endndx fixes could be
     2671+     nested, e. g. the start of a function has a pending fix that
     2672+     needs to point to the first symbol after the function, but there
     2673+     could be an anonymous struct definition inside that function's
     2674+     local variables where the endndx needs to point after the last
     2675+     symbol of this struct.  Also, structs and unions could be nested.
     2676+
     2677+     Each call to coff_record_symbol() can fix at most one endndx
     2678+     (even if more are pending in the stack), but that's OK.
     2679+
     2680+     Note that bfd/coffgen.c converts that csymp->native into a
     2681+     symtable slot number after coff_renumber_symbols() has been
     2682+     run. */
     2683+  if (info->flags & COFF_FL_FIX_ENDNDX)
     2684+    {
     2685+      struct coff_fix_stack *fsp, *ofsp;
     2686+      union internal_auxent *aux;
     2687+
     2688+      assert (info->fixes != NULL);
     2689+
     2690+      fsp = info->fixes;
     2691+      ofsp = NULL;
     2692+      while (fsp->next != NULL)
     2693+       {
     2694+         ofsp = fsp;
     2695+         fsp = fsp->next;
     2696+       }
     2697+      if (ofsp == NULL)
     2698+       info->fixes = NULL;
     2699+      else
     2700+       ofsp->next = NULL;
     2701+
     2702+      aux = &(fsp->native->u.auxent);
     2703+      fsp->native->fix_end = 1;
     2704+      aux->x_sym.x_fcnary.x_fcn.x_endndx.p = csymp->native;
     2705+      free (fsp);
     2706+
     2707+      info->flags &= ~COFF_FL_FIX_ENDNDX;
     2708+    }
     2709+}
     2710+
     2711+/* Fixup AVR COFF register handling: they don't only mention the
     2712+   starting register number, but all registers, each within one byte
     2713+   of the value.  Unused register positions are filled up with
     2714+   0xff. */
     2715+static symvalue
     2716+coff_fixup_avr_register (val, size)
     2717+     symvalue val;
     2718+     int size;
     2719+{
     2720+  union
     2721+  {
     2722+    unsigned char c[4];
     2723+    symvalue v;
     2724+  } u;
     2725+
     2726+  u.c[1] = u.c[2] = u.c[3] = 0xff;
     2727+  u.c[0] = val;
     2728+  if (size > 8)
     2729+    u.c[1] = val + 1;
     2730+  if (size > 16)
     2731+    {
     2732+      u.c[2] = val + 2;
     2733+      u.c[3] = val + 3;
     2734+    }
     2735+
     2736+  return u.v;
     2737+}
     2738+
     2739+/* Initialize an entry in the hash tables.  */
     2740+
     2741+static struct bfd_hash_entry *
     2742+coff_name_type_newfunc (entry, table, string)
     2743+     struct bfd_hash_entry *entry;
     2744+     struct bfd_hash_table *table;
     2745+     const char *string;
     2746+{
     2747+  struct coff_name_type_hash_entry *ret =
     2748+    (struct coff_name_type_hash_entry *) entry;
     2749+
     2750+  /* Allocate the structure if it has not already been allocated by a
     2751+     subclass.  */
     2752+  if (ret == NULL)
     2753+    ret = ((struct coff_name_type_hash_entry *)
     2754+          bfd_hash_allocate (table, sizeof *ret));
     2755+  if (ret == NULL)
     2756+    return NULL;
     2757+
     2758+  /* Call the allocation method of the superclass.  */
     2759+  ret = ((struct coff_name_type_hash_entry *)
     2760+        bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
     2761+  if (ret)
     2762+    {
     2763+      /* Set local fields.  */
     2764+      ret->types = NULL;
     2765+      ret->emitted = FALSE;
     2766+    }
     2767+
     2768+  return (struct bfd_hash_entry *) ret;
     2769+}
     2770+
     2771+static struct bfd_hash_entry *
     2772+coff_struct_newfunc (entry, table, string)
     2773+     struct bfd_hash_entry *entry;
     2774+     struct bfd_hash_table *table;
     2775+     const char *string;
     2776+{
     2777+  struct coff_struct_hash_entry *ret =
     2778+    (struct coff_struct_hash_entry *) entry;
     2779+
     2780+  /* Allocate the structure if it has not already been allocated by a
     2781+     subclass.  */
     2782+  if (ret == NULL)
     2783+    ret = ((struct coff_struct_hash_entry *)
     2784+          bfd_hash_allocate (table, sizeof *ret));
     2785+  if (ret == NULL)
     2786+    return NULL;
     2787+
     2788+  /* Call the allocation method of the superclass.  */
     2789+  ret = ((struct coff_struct_hash_entry *)
     2790+        bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
     2791+  if (ret)
     2792+    {
     2793+      /* Set local fields.  */
     2794+      ret->types = NULL;
     2795+      ret->emitted = FALSE;
     2796+      ret->fixidxs = NULL;
     2797+      ret->nfixidxs = 0;
     2798+      ret->native = NULL;
     2799+    }
     2800+
     2801+  return (struct bfd_hash_entry *) ret;
     2802+}
     2803+
     2804+static struct bfd_hash_entry *
     2805+coff_enum_newfunc (entry, table, string)
     2806+     struct bfd_hash_entry *entry;
     2807+     struct bfd_hash_table *table;
     2808+     const char *string;
     2809+{
     2810+  struct coff_enum_hash_entry *ret =
     2811+    (struct coff_enum_hash_entry *) entry;
     2812+
     2813+  /* Allocate the structure if it has not already been allocated by a
     2814+     subclass.  */
     2815+  if (ret == NULL)
     2816+    ret = ((struct coff_enum_hash_entry *)
     2817+          bfd_hash_allocate (table, sizeof *ret));
     2818+  if (ret == NULL)
     2819+    return NULL;
     2820+
     2821+  /* Call the allocation method of the superclass.  */
     2822+  ret = ((struct coff_enum_hash_entry *)
     2823+        bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
     2824+  if (ret)
     2825+    {
     2826+      /* Set local fields.  */
     2827+      ret->types = NULL;
     2828+      ret->emitted = FALSE;
     2829+      ret->fixidxs = NULL;
     2830+      ret->nfixidxs = 0;
     2831+      ret->native = NULL;
     2832+    }
     2833+
     2834+  return (struct bfd_hash_entry *) ret;
     2835+}
     2836+
     2837+/* Look up an entry in the hash tables.  */
     2838+
     2839+#define coff_name_type_hash_lookup(table, string, create, copy) \
     2840+  ((struct coff_name_type_hash_entry *) \
     2841+   bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
     2842+
     2843+/* Traverse the hash table.  */
     2844+
     2845+#define coff_name_type_hash_traverse(table, func, info)                        \
     2846+  (bfd_hash_traverse                                                   \
     2847+   (&(table)->root,                                                    \
     2848+    (bfd_boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func),  \
     2849+    (info)))
     2850+
     2851+#define coff_struct_hash_lookup(table, string, create, copy) \
     2852+  ((struct coff_struct_hash_entry *) \
     2853+   bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
     2854+
     2855+/* Traverse the hash table.  */
     2856+
     2857+#define coff_struct_hash_traverse(table, func, info)                   \
     2858+  (bfd_hash_traverse                                                   \
     2859+   (&(table)->root,                                                    \
     2860+    (bfd_boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func),  \
     2861+    (info)))
     2862+
     2863+#define coff_enum_hash_lookup(table, string, create, copy) \
     2864+  ((struct coff_enum_hash_entry *) \
     2865+   bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
     2866+
     2867+/* Traverse the hash table.  */
     2868+
     2869+#define coff_enum_hash_traverse(table, func, info)                     \
     2870+  (bfd_hash_traverse                                                   \
     2871+   (&(table)->root,                                                    \
     2872+    (bfd_boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func),  \
     2873+    (info)))
     2874+
     2875+#define coff_push_type(kind) \
     2876+  tst = (struct coff_type_stack *) xmalloc (sizeof (struct coff_type_stack)); \
     2877+  memset (tst, 0, sizeof (*tst)); \
     2878+  tst->next = info->tstack; \
     2879+  tst->tsk = kind; \
     2880+  info->tstack = tst
     2881+
     2882+#define coff_pop_type() \
     2883+  tst = info->tstack; \
     2884+  if (tst == NULL) { \
     2885+    fprintf (stderr, _("empty type stack in coff_pop_type()\n")); \
     2886+    return FALSE; \
     2887+  } \
     2888+  info->tstack = tst->next; \
     2889+  tst->next = NULL
     2890+
     2891+#define coff_complain_unsupp(s) \
     2892+  fprintf (stderr, _("%s type not supported in %s\n"), \
     2893+          s, info->abfd->xvec->name); \
     2894+  return FALSE
     2895+
     2896+/* These function is called via the hash traverse routine when freeing
     2897+   a hash table (at the end of a translation unit). */
     2898+static bfd_boolean
     2899+coff_free_type_info (h, p)
     2900+     struct coff_name_type_hash_entry *h;
     2901+     PTR p ATTRIBUTE_UNUSED;
     2902+{
     2903+  struct coff_type_stack *tst, *otst;
     2904+
     2905+  for (tst = h->types; tst != NULL;)
     2906+    {
     2907+      otst = tst;
     2908+      tst = tst->next;
     2909+      free (otst);
     2910+    }
     2911+  return TRUE;
     2912+}
     2913+
     2914+static bfd_boolean
     2915+coff_free_struct_info (h, p)
     2916+     struct coff_struct_hash_entry *h;
     2917+     PTR p ATTRIBUTE_UNUSED;
     2918+{
     2919+  struct coff_type_stack *tst, *otst, *xtst, *xotst;
     2920+  struct coff_struct_fields *fp;
     2921+  long i;
     2922+
     2923+  for (tst = h->types; tst != NULL;)
     2924+    {
     2925+      otst = tst;
     2926+      if (tst->u.ts_struct.tagismalloced)
     2927+       free (tst->u.ts_struct.tag.malloctag);
     2928+      for (i = 0, fp = tst->u.ts_struct.fields;
     2929+          i < tst->u.ts_struct.nfields;
     2930+          i++, fp++)
     2931+       {
     2932+         xtst = fp->types;
     2933+         while (xtst != NULL)
     2934+           {
     2935+             xotst = xtst->next;
     2936+             free (xtst);
     2937+             xtst = xotst;
     2938+           }
     2939+       }
     2940+      free (tst->u.ts_struct.fields);
     2941+      tst = tst->next;
     2942+      free (otst);
     2943+    }
     2944+  return TRUE;
     2945+}
     2946+
     2947+static bfd_boolean
     2948+coff_free_enum_info (h, p)
     2949+     struct coff_enum_hash_entry *h;
     2950+     PTR p ATTRIBUTE_UNUSED;
     2951+{
     2952+  struct coff_type_stack *tst, *otst;
     2953+
     2954+  for (tst = h->types; tst != NULL;)
     2955+    {
     2956+      otst = tst;
     2957+      if (tst->u.ts_enum.tagismalloced)
     2958+       free (tst->u.ts_enum.tag.malloctag);
     2959+      tst = tst->next;
     2960+      free (otst);
     2961+    }
     2962+  return TRUE;
     2963+}
     2964+
     2965+static unsigned int
     2966+coff_get_fundamental_type (info, tst)
     2967+     struct coff_write_handle *info ATTRIBUTE_UNUSED;
     2968+     struct coff_type_stack *tst;
     2969+{
     2970+  size_t i;
     2971+
     2972+  /* See if one of our predefined types will fit. */
     2973+  if (tst->tsk == TS_INT)
     2974+    {
     2975+      for (i = 0;
     2976+          i < sizeof coff_predef_types / sizeof (struct coff_predef_type);
     2977+          i++)
     2978+       {
     2979+         if (coff_predef_types[i].kind == TS_INT
     2980+             && coff_predef_types[i].size == tst->u.ts_int.size
     2981+             && coff_predef_types[i].isunsigned == tst->u.ts_int.isunsigned)
     2982+           return coff_predef_types[i].slot;
     2983+       }
     2984+      fprintf (stderr,
     2985+              _("%ssigned %d-bit integer type not available in COFF\n"),
     2986+              tst->u.ts_int.isunsigned? "un": "", tst->u.ts_int.size * 8);
     2987+    }
     2988+  else
     2989+    {
     2990+      for (i = 0;
     2991+          i < sizeof coff_predef_types / sizeof (struct coff_predef_type);
     2992+          i++)
     2993+       {
     2994+         if (coff_predef_types[i].kind == TS_FLOAT
     2995+             && coff_predef_types[i].size == tst->u.ts_float.size)
     2996+           return coff_predef_types[i].slot;
     2997+       }
     2998+      fprintf (stderr, _("%d-bit float type not available in COFF\n"),
     2999+              tst->u.ts_float.size * 8);
     3000+    }
     3001+
     3002+  return T_NULL;
     3003+}
     3004+
     3005+static bfd_boolean
     3006+coff_make_typed_symbol (info, csympp, stopat)
     3007+     struct coff_write_handle *info;
     3008+     coff_symbol_type **csympp;
     3009+     enum ts_kind stopat;
     3010+{
     3011+  struct coff_type_stack *tst;
     3012+  union internal_auxent *aux;
     3013+  struct coff_struct_hash_entry *shash;
     3014+  struct coff_enum_hash_entry *ehash;
     3015+  struct coff_private_symdata *priv;
     3016+  unsigned int type, numaux, arydim, size, i, nele, nderived;
     3017+  const char *name;
     3018+  bfd_boolean oldavrcoff = (info->flags & (COFF_FL_AVR | COFF_FL_EXT_AVR))
     3019+    == COFF_FL_AVR;
     3020+
     3021+  /* Synthesize a new internal COFF symbol. */
     3022+  *csympp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     3023+  if (*csympp == NULL)
     3024+    return FALSE;
     3025+
     3026+  priv = (struct coff_private_symdata *) xmalloc (sizeof *priv);
     3027+  memset (priv, 0, sizeof *priv);
     3028+
     3029+  type = arydim = size = nderived = 0;
     3030+
     3031+  aux = &(((*csympp)->native + 1)->u.auxent);
     3032+
     3033+  /* Now, walk the type stack, and see how we could convert the info
     3034+     we've got to what COFF understands. */
     3035+  for (;;)
     3036+    {
     3037+      if (info->tstack == NULL)
     3038+       break;
     3039+
     3040+      /* If we have been advised to not pop the entire stack, stop
     3041+        here. */
     3042+      if (info->tstack->tsk == stopat && info->tstack->next == NULL)
     3043+       break;
     3044+
     3045+      coff_pop_type ();
     3046+
     3047+      switch (tst->tsk)
     3048+       {
     3049+       case TS_NONE:
     3050+         /* cannot happen */
     3051+         break;
     3052+
     3053+       case TS_EMPTY:
     3054+         if (info->tstack != NULL && info->tstack->tsk != stopat)
     3055+           fprintf (stderr, _("empty type not last on type stack\n"));
     3056+         /* type |= T_NULL; */
     3057+         break;
     3058+
     3059+       case TS_VOID:
     3060+         if (info->tstack != NULL && info->tstack->tsk != stopat)
     3061+           fprintf (stderr, _("void type not last on type stack\n"));
     3062+         type |= T_VOID;
     3063+         break;
     3064+
     3065+       case TS_INT:
     3066+         if (info->tstack != NULL && info->tstack->tsk != stopat)
     3067+           fprintf (stderr, _("int type not last on type stack\n"));
     3068+         type |= coff_get_fundamental_type (info, tst);
     3069+         if (size == 0)
     3070+           size = tst->u.ts_int.size;
     3071+         break;
     3072+
     3073+       case TS_FLOAT:
     3074+         if (info->tstack != NULL && info->tstack->tsk != stopat)
     3075+           fprintf (stderr, _("float type not last on type stack\n"));
     3076+         type |= coff_get_fundamental_type (info, tst);
     3077+         if (size == 0)
     3078+           size = tst->u.ts_float.size;
     3079+         break;
     3080+
     3081+       case TS_POINTER:
     3082+         nderived++;
     3083+         type = ((type & ~N_BTMASK) << N_TSHIFT) | (DT_PTR << N_BTSHFT);
     3084+         size = info->pointersize;
     3085+         break;
     3086+
     3087+       case TS_FUNC:
     3088+         nderived++;
     3089+         type = ((type & ~N_BTMASK) << N_TSHIFT) | (DT_FCN << N_BTSHFT);
     3090+         /* AUX entry for DT_FCN will be filled in elsewhere. */
     3091+         break;
     3092+
     3093+       case TS_ARRAY:
     3094+         /* We need to limit arydim so the assignment below won't
     3095+            overwrite random locations. */
     3096+         if (arydim >= DIMNUM)
     3097+           {
     3098+             fprintf (stderr,
     3099+                      _("More than %d array dimensions, result is invalid.\n"),
     3100+                      DIMNUM);
     3101+             arydim = DIMNUM - 1;
     3102+           }
     3103+         nderived++;
     3104+         type = ((type & ~N_BTMASK) << N_TSHIFT) | (DT_ARY << N_BTSHFT);
     3105+         aux->x_sym.x_fcnary.x_ary.x_dimen[arydim++] =
     3106+           tst->u.ts_array.high - tst->u.ts_array.low + 1;
     3107+
     3108+         break;
     3109+
     3110+       case TS_COMPLEX:
     3111+         coff_complain_unsupp (_("complex"));
     3112+
     3113+       case TS_ENUM:
     3114+         type |= T_ENUM;
     3115+         if (size == 0)
     3116+           size = info->enumsize;
     3117+
     3118+         if (tst->u.ts_enum.ehash != NULL)
     3119+           {
     3120+             /* enum tag will be fixed later. */
     3121+             priv->ehash = tst->u.ts_enum.ehash;
     3122+             break;
     3123+           }
     3124+         if (tst->u.ts_enum.tagismalloced)
     3125+           name = tst->u.ts_enum.tag.malloctag;
     3126+         else
     3127+           name = tst->u.ts_enum.tag.fixtag;
     3128+         ehash = coff_enum_hash_lookup (&info->enums, name,
     3129+                                        TRUE, tst->u.ts_enum.tagismalloced);
     3130+         if (ehash == NULL)
     3131+           return FALSE;
     3132+         if (!ehash->emitted)
     3133+           {
     3134+             if (ehash->types == NULL)
     3135+               {
     3136+                 ehash->types = (struct coff_type_stack *)
     3137+                   xmalloc (sizeof (struct coff_type_stack));
     3138+                 memcpy (ehash->types, tst, sizeof (struct coff_type_stack));
     3139+               }
     3140+             ehash->emitted = TRUE;
     3141+             coff_emit_enum (info, tst, ehash);
     3142+             if (ehash->nfixidxs != 0)
     3143+               {
     3144+                 coff_symbol_type *symp;
     3145+                 unsigned i;
     3146+
     3147+                 for (i = 0; i < ehash->nfixidxs; i++)
     3148+                   {
     3149+                     combined_entry_type *np;
     3150+
     3151+                     symp = (coff_symbol_type *) info->syms[ehash->fixidxs[i]];
     3152+                     symp->native->u.syment.n_type &= ~N_BTMASK;
     3153+                     symp->native->u.syment.n_type |= T_ENUM;
     3154+
     3155+                     if (oldavrcoff)
     3156+                       continue;
     3157+
     3158+                     np = symp->native + 1;
     3159+                     np->fix_tag = 1;
     3160+                     np->u.auxent.x_sym.x_tagndx.p = ehash->native;
     3161+                     if (np->u.auxent.x_sym.x_misc.x_fsize == 0)
     3162+                       np->u.auxent.x_sym.x_misc.x_lnsz.x_size = size;
     3163+                   }
     3164+
     3165+                 free (ehash->fixidxs);
     3166+                 ehash->nfixidxs = 0;
     3167+               }
     3168+           }
     3169+         if (!oldavrcoff)
     3170+           {
     3171+             ((*csympp)->native + 1)->fix_tag = 1;
     3172+             aux->x_sym.x_tagndx.p = ehash->native;
     3173+             if (aux->x_sym.x_misc.x_fsize == 0)
     3174+               aux->x_sym.x_misc.x_lnsz.x_size = size;
     3175+           }
     3176+         break;
     3177+
     3178+       case TS_STRUCT:
     3179+         if (tst->u.ts_struct.isstruct)
     3180+           type |= T_STRUCT;
     3181+         else
     3182+           type |= T_UNION;
     3183+         if (size == 0)
     3184+           size = tst->u.ts_struct.size;
     3185+
     3186+         if (tst->u.ts_struct.shash != NULL)
     3187+           {
     3188+             /* struct tag will be fixed later. */
     3189+             priv->shash = tst->u.ts_struct.shash;
     3190+             break;
     3191+           }
     3192+         if (tst->u.ts_struct.tagismalloced)
     3193+           name = tst->u.ts_struct.tag.malloctag;
     3194+         else
     3195+           name = tst->u.ts_struct.tag.fixtag;
     3196+         shash = coff_struct_hash_lookup (&info->structs, name,
     3197+                                          TRUE, tst->u.ts_struct.tagismalloced);
     3198+         if (shash == NULL)
     3199+           return FALSE;
     3200+         if (!shash->emitted)
     3201+           {
     3202+             if (shash->types == NULL)
     3203+               {
     3204+                 shash->types = (struct coff_type_stack *)
     3205+                   xmalloc (sizeof (struct coff_type_stack));
     3206+                 memcpy (shash->types, tst, sizeof (struct coff_type_stack));
     3207+               }
     3208+             shash->emitted = TRUE;
     3209+             coff_emit_struct (info, tst, shash);
     3210+             if (shash->nfixidxs != 0)
     3211+               {
     3212+                 coff_symbol_type *symp;
     3213+                 unsigned i;
     3214+
     3215+                 for (i = 0; i < shash->nfixidxs; i++)
     3216+                   {
     3217+                     combined_entry_type *np;
     3218+
     3219+                     symp = (coff_symbol_type *) info->syms[shash->fixidxs[i]];
     3220+                     symp->native->u.syment.n_type &= ~N_BTMASK;
     3221+                     if (tst->u.ts_struct.isstruct)
     3222+                       symp->native->u.syment.n_type |= T_STRUCT;
     3223+                     else
     3224+                       symp->native->u.syment.n_type |= T_UNION;
     3225+
     3226+                     if (oldavrcoff)
     3227+                       continue;
     3228+
     3229+                     np = symp->native + 1;
     3230+                     np->fix_tag = 1;
     3231+                     np->u.auxent.x_sym.x_tagndx.p = shash->native;
     3232+                     if (np->u.auxent.x_sym.x_misc.x_fsize == 0)
     3233+                       np->u.auxent.x_sym.x_misc.x_lnsz.x_size = size;
     3234+                   }
     3235+
     3236+                 free (shash->fixidxs);
     3237+                 shash->nfixidxs = 0;
     3238+               }
     3239+           }
     3240+         if (!oldavrcoff)
     3241+           {
     3242+             ((*csympp)->native + 1)->fix_tag = 1;
     3243+             aux->x_sym.x_tagndx.p = shash->native;
     3244+             if (aux->x_sym.x_misc.x_fsize == 0)
     3245+               aux->x_sym.x_misc.x_lnsz.x_size = size;
     3246+           }
     3247+         break;
     3248+       }
     3249+      free (tst);
     3250+    }
     3251+
     3252+  if (nderived > 6)
     3253+    fprintf (stderr,
     3254+            _("More than 6 derived type specifiers, result is invalid.\n"));
     3255+
     3256+  /* Our type computation so far used the reverse order for derived
     3257+     type specifiers.  Fix this here if there was more than one
     3258+     derived type specifier. */
     3259+  if (nderived > 1)
     3260+    {
     3261+      unsigned int nty, bty;
     3262+      bty = type & N_BTMASK;
     3263+      type = type >> N_BTSHFT;
     3264+      nty = 0;
     3265+      while (nderived-- > 0)
     3266+       {
     3267+         nty = (nty << N_TSHIFT) | (type & (N_TMASK >> N_BTSHFT));
     3268+         type >>= N_TSHIFT;
     3269+       }
     3270+      type = (nty << N_BTSHFT) | bty;
     3271+    }
     3272+
     3273+  if (ISARY (type))
     3274+    {
     3275+      /* Compute size of entire array. */
     3276+      for (i = 0, nele = 1; i < arydim; i++)
     3277+       nele *= aux->x_sym.x_fcnary.x_ary.x_dimen[i];
     3278+      aux->x_sym.x_misc.x_lnsz.x_size = size * nele;
     3279+    }
     3280+
     3281+  numaux = 0;
     3282+  if (ISARY (type) || ISFCN (type))
     3283+    numaux++;
     3284+  if ((BTYPE (type) == T_STRUCT || BTYPE (type) == T_UNION
     3285+       || BTYPE (type) == T_ENUM)
     3286+      && !oldavrcoff)
     3287+    numaux++;
     3288+  /* Only AVR COFF uses multiple AUX entries. */
     3289+  if (numaux > 1 && (info->flags & COFF_FL_AVR) == 0)
     3290+    numaux = 1;
     3291+
     3292+  priv->size = size;
     3293+  (*csympp)->symbol.udata.p = priv;
     3294+  (*csympp)->native->u.syment.n_type = type;
     3295+  (*csympp)->native->u.syment.n_numaux = numaux;
     3296+
     3297+  /* If the fundamental type comes out as T_NULL, this means we don't
     3298+     have any type information.  Just don't emit any aux entries in
     3299+     that case, and drop any derived type information as well. */
     3300+  if (BTYPE (type) == T_NULL)
     3301+    {
     3302+      printf ("coff_make_typed_symbol() -> T_NULL\n");
     3303+      //(*csympp)->native->u.syment.n_type = T_NULL;
     3304+      (*csympp)->native->u.syment.n_numaux = 0;
     3305+    }
     3306+
     3307+  return TRUE;
     3308+}
     3309+
     3310+static bfd_boolean coff_emit_struct (info, tst, shash)
     3311+     struct coff_write_handle *info;
     3312+     struct coff_type_stack *tst;
     3313+     struct coff_struct_hash_entry *shash;
     3314+{
     3315+  coff_symbol_type *csymp, *scsymp, *ecsymp;
     3316+  union internal_auxent *aux;
     3317+  struct coff_fix_stack *fixp, *ofp;
     3318+  bfd_boolean isstruct = tst->u.ts_struct.isstruct;
     3319+  bfd_boolean isbitfield = FALSE;
     3320+  struct coff_type_stack *savedtst;
     3321+  struct coff_struct_fields *fp;
     3322+  unsigned short sclass;
     3323+  long i;
     3324+
     3325+  if ((info->flags & (COFF_FL_AVR | COFF_FL_EXT_AVR)) ==
     3326+      COFF_FL_AVR)
     3327+    /* old AVR COFF doesn't support struct debugging */
     3328+    return TRUE;
     3329+
     3330+  /* Synthesize a new internal COFF symbol for the struct/union. */
     3331+  scsymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     3332+  if (scsymp == NULL)
     3333+    return FALSE;
     3334+
     3335+  if (tst->u.ts_struct.tagismalloced)
     3336+    scsymp->symbol.name = xstrdup (tst->u.ts_struct.tag.malloctag);
     3337+  else
     3338+    scsymp->symbol.name = tst->u.ts_struct.tag.fixtag;
     3339+  scsymp->symbol.flags = BSF_NOT_AT_END;
     3340+  scsymp->symbol.section = bfd_und_section_ptr;
     3341+  scsymp->native->u.syment.n_sclass = isstruct? C_STRTAG: C_UNTAG;
     3342+  scsymp->native->u.syment.n_type = isstruct? T_STRUCT: T_UNION;
     3343+  scsymp->native->u.syment.n_numaux = 1;
     3344+  scsymp->symbol.udata.p = NULL;
     3345+  scsymp->symbol.value = 0;
     3346+
     3347+  shash->native = scsymp->native;
     3348+
     3349+  /* Synthesize a new internal COFF symbol for the end of struct/union. */
     3350+  ecsymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     3351+  if (ecsymp == NULL)
     3352+    return FALSE;
     3353+
     3354+  ecsymp->symbol.name = ".eos";
     3355+  ecsymp->symbol.flags = BSF_NOT_AT_END;
     3356+  /* We need to use the com section here since bfd/coffgen.c
     3357+     translates this into an N_UNDEF one without clobbering the
     3358+     value. */
     3359+  ecsymp->symbol.section = bfd_com_section_ptr;
     3360+  ecsymp->native->u.syment.n_sclass = C_EOS;
     3361+  ecsymp->symbol.udata.p = NULL;
     3362+  ecsymp->symbol.value = tst->u.ts_struct.size;
     3363+  ecsymp->native->u.syment.n_numaux = 1;
     3364+  (ecsymp->native + 1)->fix_tag = 1;
     3365+  aux = &((ecsymp->native + 1)->u.auxent);
     3366+  aux->x_sym.x_tagndx.p = scsymp->native;
     3367+  aux->x_sym.x_misc.x_lnsz.x_size = tst->u.ts_struct.size;
     3368+
     3369+  coff_record_symbol (info, scsymp);
     3370+
     3371+  savedtst = info->tstack;
     3372+
     3373+  if (isstruct)
     3374+    {
     3375+      /* First, make a quick walk along all the fields, and figure out
     3376+       * whether we've got a genuine struct or a bitfield struct. */
     3377+      for (i = 0, fp = tst->u.ts_struct.fields;
     3378+          i < tst->u.ts_struct.nfields;
     3379+          i++, fp++)
     3380+       if (fp->bitsize % 8 != 0)
     3381+         {
     3382+           isbitfield = TRUE;
     3383+           break;
     3384+         }
     3385+    }
     3386+
     3387+  sclass = isstruct? (isbitfield? C_FIELD: C_MOS): C_MOU;
     3388+
     3389+  for (i = 0, fp = tst->u.ts_struct.fields;
     3390+       i < tst->u.ts_struct.nfields;
     3391+       i++, fp++)
     3392+    {
     3393+      if (strlen (fp->name) == 0)
     3394+       {
     3395+         /* empty name could happen inside bitfield */
     3396+         fp->types = NULL;
     3397+         continue;
     3398+       }
     3399+
     3400+      info->tstack = fp->types;
     3401+      if (!coff_make_typed_symbol (info, &csymp, TS_NONE))
     3402+       return FALSE;
     3403+
     3404+      csymp->symbol.name = xstrdup (fp->name);
     3405+      csymp->symbol.flags = BSF_NOT_AT_END;
     3406+      csymp->symbol.section = bfd_com_section_ptr;
     3407+      csymp->native->u.syment.n_sclass = sclass;
     3408+      csymp->symbol.value = isbitfield? fp->bitpos: fp->bitpos / 8;
     3409+      if (isbitfield)
     3410+       {
     3411+         csymp->native->u.syment.n_numaux = 1;
     3412+         aux = &((csymp->native + 1)->u.auxent);
     3413+         aux->x_sym.x_misc.x_lnsz.x_size = fp->bitsize;
     3414+       }
     3415+
     3416+      coff_record_symbol (info, csymp);
     3417+
     3418+      fp->types = NULL;
     3419+    }
     3420+
     3421+  info->tstack = savedtst;
     3422+
     3423+  /* Record our endndx field for later fixing. */
     3424+  fixp = (struct coff_fix_stack *) xmalloc (sizeof (struct coff_fix_stack));
     3425+  fixp->native = scsymp->native + 1;   /* points to first AUX */
     3426+  fixp->next = NULL;
     3427+  if (info->fixes == NULL)
     3428+    info->fixes = fixp;
     3429+  else
     3430+    {
     3431+      for (ofp = info->fixes; ofp->next != NULL;)
     3432+       ofp = ofp->next;
     3433+      ofp->next = fixp;
     3434+    }
     3435+
     3436+  coff_record_symbol (info, ecsymp);
     3437+  info->flags |= COFF_FL_FIX_ENDNDX;
     3438+
     3439+  return TRUE;
     3440+}
     3441+
     3442+static bfd_boolean coff_emit_enum (info, tst, ehash)
     3443+     struct coff_write_handle *info;
     3444+     struct coff_type_stack *tst;
     3445+     struct coff_enum_hash_entry *ehash;
     3446+{
     3447+  coff_symbol_type *csymp, *scsymp, *ecsymp;
     3448+  union internal_auxent *aux;
     3449+  struct coff_fix_stack *fixp, *ofp;
     3450+  int i;
     3451+
     3452+  if ((info->flags & (COFF_FL_AVR | COFF_FL_EXT_AVR)) ==
     3453+      COFF_FL_AVR)
     3454+    /* old AVR COFF doesn't support enum debugging */
     3455+    return TRUE;
     3456+
     3457+  /* Synthesize a new internal COFF symbol for the enum. */
     3458+  scsymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     3459+  if (scsymp == NULL)
     3460+    return FALSE;
     3461+
     3462+  if (tst->u.ts_enum.tagismalloced)
     3463+    scsymp->symbol.name = xstrdup (tst->u.ts_enum.tag.malloctag);
     3464+  else
     3465+    scsymp->symbol.name = tst->u.ts_enum.tag.fixtag;
     3466+  scsymp->symbol.flags = BSF_NOT_AT_END;
     3467+  scsymp->symbol.section = bfd_und_section_ptr;
     3468+  scsymp->native->u.syment.n_sclass = C_ENTAG;
     3469+  scsymp->native->u.syment.n_type = T_ENUM;
     3470+  scsymp->native->u.syment.n_numaux = 1;
     3471+  scsymp->symbol.udata.p = NULL;
     3472+  scsymp->symbol.value = 0;
     3473+
     3474+  ehash->native = scsymp->native;
     3475+
     3476+  /* Synthesize a new internal COFF symbol for the end of struct/union. */
     3477+  ecsymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     3478+  if (ecsymp == NULL)
     3479+    return FALSE;
     3480+
     3481+  ecsymp->symbol.name = ".eos";
     3482+  ecsymp->symbol.flags = BSF_NOT_AT_END;
     3483+  /* We need to use the com section here since bfd/coffgen.c
     3484+     translates this into an N_UNDEF one without clobbering the
     3485+     value. */
     3486+  ecsymp->symbol.section = bfd_com_section_ptr;
     3487+  ecsymp->native->u.syment.n_sclass = C_EOS;
     3488+  ecsymp->symbol.udata.p = NULL;
     3489+  ecsymp->symbol.value = info->enumsize;
     3490+  ecsymp->native->u.syment.n_numaux = 1;
     3491+  (ecsymp->native + 1)->fix_tag = 1;
     3492+  aux = &((ecsymp->native + 1)->u.auxent);
     3493+  aux->x_sym.x_tagndx.p = scsymp->native;
     3494+  aux->x_sym.x_misc.x_lnsz.x_size = info->enumsize;
     3495+
     3496+  coff_record_symbol (info, scsymp);
     3497+
     3498+  for (i = 0;; i++)
     3499+    {
     3500+      const char *name = tst->u.ts_enum.names[i];
     3501+      if (name == NULL)
     3502+       break;
     3503+
     3504+      /* Synthesize a new internal COFF symbol for the enum. */
     3505+      csymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     3506+      if (csymp == NULL)
     3507+       return FALSE;
     3508+
     3509+      csymp->symbol.name = xstrdup (name);
     3510+      csymp->symbol.flags = BSF_NOT_AT_END;
     3511+      csymp->symbol.section = bfd_com_section_ptr;
     3512+      csymp->native->u.syment.n_sclass = C_MOE;
     3513+      csymp->symbol.udata.p = NULL;
     3514+      csymp->symbol.value = tst->u.ts_enum.vals[i];
     3515+
     3516+      coff_record_symbol (info, csymp);
     3517+    }
     3518+
     3519+  /* Record our endndx field for later fixing. */
     3520+  fixp = (struct coff_fix_stack *) xmalloc (sizeof (struct coff_fix_stack));
     3521+  fixp->native = scsymp->native + 1;   /* points to first AUX */
     3522+  fixp->next = NULL;
     3523+  if (info->fixes == NULL)
     3524+    info->fixes = fixp;
     3525+  else
     3526+    {
     3527+      for (ofp = info->fixes; ofp->next != NULL;)
     3528+       ofp = ofp->next;
     3529+      ofp->next = fixp;
     3530+    }
     3531+
     3532+  coff_record_symbol (info, ecsymp);
     3533+  info->flags |= COFF_FL_FIX_ENDNDX;
     3534+
     3535+  return TRUE;
     3536+}
     3537+
     3538+/* Emit a non-debugging symbol that came from the input symbol table,
     3539+   and has not been claimed by one of the debugging symbols. */
     3540+static bfd_boolean
     3541+coff_emit_ndebug_sym (info, osymp, localp)
     3542+     struct coff_write_handle *info;
     3543+     asymbol *osymp;
     3544+     bfd_boolean localp;
     3545+{
     3546+  coff_symbol_type *csymp;
     3547+
     3548+  /* Create new COFF symbol. */
     3549+  csymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     3550+  if (csymp == NULL)
     3551+    return FALSE;
     3552+
     3553+  csymp->symbol.name = xstrdup (osymp->name);
     3554+  csymp->symbol.value = osymp->value;
     3555+  csymp->symbol.flags = localp? BSF_LOCAL: BSF_GLOBAL;
     3556+  csymp->symbol.section = osymp->section;
     3557+  csymp->symbol.udata.p = NULL;
     3558+  csymp->native->u.syment.n_sclass = localp? C_STAT: C_EXT;
     3559+  csymp->native->u.syment.n_type = T_NULL;
     3560+
     3561+  coff_record_symbol (info, csymp);
     3562+
     3563+  return TRUE;
     3564+}
     3565+
    33566
     3567+/* The general routine to write out COFF debugging information.  This
     3568+   synthesizes and accumulates the COFF symbols.  Actual symbol table
     3569+   output is performed later on by the BFD functions.  ABFD is the BFD
     3570+   and DHANDLE is the handle for the debugging information.  symcountp
     3571+   and symppp point to the incoming (parsed) symbol list on entry, and
     3572+   will be updated to point to the new symbol table's values upon
     3573+   exit. */
     3574+
     3575+bfd_boolean
     3576+write_coff_debugging_info (abfd, dhandle, symcountp, symppp)
     3577+     bfd *abfd;
     3578+     PTR dhandle;
     3579+     long *symcountp;
     3580+     asymbol ***symppp;
     3581+{
     3582+  struct coff_write_handle info;
     3583+  long i, l;
     3584+  asymbol *symp;
     3585+  struct coff_compilation_unit *up;
     3586+  coff_symbol_type *csymp;
     3587+
     3588+  memset ((void *)&info, 0, sizeof info);
     3589+
     3590+  info.abfd = abfd;
     3591+
     3592+  info.pointersize = info.enumsize = 4;
     3593+
     3594+  switch (bfd_get_arch (abfd))
     3595+    {
     3596+    case bfd_arch_avr:
     3597+      info.flags |= COFF_FL_AVR;
     3598+      if (strcmp (abfd->xvec->name, "coff-ext-avr") == 0)
     3599+       info.flags |= COFF_FL_EXT_AVR;
     3600+      /* Fix the builtin type sizes. */
     3601+      coff_predef_types[0].size = 2;   /* sizeof(int) == 2 */
     3602+      coff_predef_types[4].size = 4;   /* sizeof(double) == 4 */
     3603+      coff_predef_types[6].size = 2;   /* sizeof(unsigned int) == 2 */
     3604+      info.pointersize = info.enumsize = 2;
     3605+      break;
     3606+
     3607+    default:
     3608+      ;
     3609+    }
     3610+
     3611+  coff_copy_symbols(&info, *symcountp, *symppp);
     3612+
     3613+  if (info.textsect == NULL)
     3614+    {
     3615+      fprintf (stderr, _("Warning: no \"text\" section found in output file\n"));
     3616+      info.textsect = bfd_abs_section_ptr;
     3617+    }
     3618+  if (info.datasect == NULL)
     3619+    {
     3620+      fprintf (stderr, _("Warning: no \"data\" section found in output file\n"));
     3621+      info.datasect = bfd_abs_section_ptr;
     3622+    }
     3623+
     3624+  if (! bfd_hash_table_init (&info.types.root, coff_name_type_newfunc,
     3625+                            sizeof(struct coff_name_type_hash_entry)))
     3626+    return FALSE;
     3627+
     3628+  if (! bfd_hash_table_init (&info.structs.root, coff_struct_newfunc,
     3629+                            sizeof(struct coff_struct_hash_entry)))
     3630+    return FALSE;
     3631+
     3632+  if (! bfd_hash_table_init (&info.enums.root, coff_enum_newfunc,
     3633+                            sizeof(struct coff_enum_hash_entry)))
     3634+    return FALSE;
     3635+
     3636+  if (! debug_write (dhandle, &coff_fns, (PTR) &info))
     3637+    return FALSE;
     3638+
     3639+  /* If there is an old compilation unit that has got any local
     3640+     non-debugging symbols left over, send them out now. */
     3641+  if (info.currentfile != NULL && info.currentfile->totsyms != 0)
     3642+    for (i = 0; i < info.currentfile->nsyms; i++)
     3643+      {
     3644+       up = info.currentfile;
     3645+
     3646+       if (up->syms[i] != NULL)
     3647+         {
     3648+           coff_emit_ndebug_sym (&info, up->syms[i], TRUE);
     3649+           up->syms[i] = NULL;
     3650+           up->totsyms--;
     3651+         }
     3652+      }
     3653+
     3654+  /* See whether there are any non-debugging symbols left from the
     3655+     input symbol table.  First look at all local symbols which must
     3656+     be from entire compilation units we didn't see yet in the
     3657+     debugging information, because anything else has already been
     3658+     handled at the end of each compilation unit (like in the loop
     3659+     immediately above).  Any compilation unit that has already been
     3660+     processed that way is supposed to have its "totsyms" counted down
     3661+     to 0 now, so we can skip them.
     3662+
     3663+     Finally, put out all remaining global non-debugging symbols. */
     3664+  for (l = 0; l < info.nunits; l++)
     3665+    {
     3666+      const char *bn;
     3667+
     3668+      up = info.units + l;
     3669+      if (up->totsyms == 0)
     3670+       continue;
     3671+
     3672+      /* Create COFF symbol for this compilation unit. */
     3673+      csymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info.abfd, 0, 0);
     3674+      if (csymp == NULL)
     3675+       return FALSE;
     3676+
     3677+      bn = bu_basename (up->fname);
     3678+
     3679+      if (bfd_coff_long_filenames (info.abfd))
     3680+       csymp->symbol.name = up->fname;
     3681+      else
     3682+       csymp->symbol.name = bn;
     3683+
     3684+      csymp->symbol.value = 0;
     3685+      csymp->symbol.udata.p = NULL;
     3686+      csymp->native->u.syment.n_sclass = C_FILE;
     3687+      csymp->native->u.syment.n_numaux = 1; /* force filename into aux entry */
     3688+      coff_record_symbol (&info, csymp);
     3689+
     3690+      for (i = 0; i < up->nsyms; i++)
     3691+       {
     3692+         symp = up->syms[i];
     3693+         if (symp == NULL)
     3694+           continue;
     3695+
     3696+         coff_emit_ndebug_sym (&info, symp, TRUE);
     3697+       }
     3698+    }
     3699+
     3700+  for (i = 0; i < info.nglobals; i++)
     3701+    {
     3702+      symp = info.globals[i];
     3703+      if (symp == NULL)
     3704+       continue;
     3705+
     3706+      coff_emit_ndebug_sym (&info, symp, FALSE);
     3707+    }
     3708+
     3709+  /* Fixup the AUX entries for the section symbols we have emitted
     3710+     earlier (so they are guaranteed to be at the beginning of the
     3711+     symbol table).  In particular, the line number count (which we
     3712+     only have for the text section) is known right now. */
     3713+  for (i = 0; i < info.nsecsyms; i++)
     3714+    {
     3715+      union internal_auxent *aux;
     3716+
     3717+      csymp = info.secsyms[i];
     3718+
     3719+      aux = &((csymp->native + 1)->u.auxent);
     3720+      aux->x_scn.x_scnlen = csymp->symbol.section->output_section->rawsize;
     3721+      aux->x_scn.x_nreloc = csymp->symbol.section->reloc_count;
     3722+      if (csymp->symbol.section == info.textsect)
     3723+       aux->x_scn.x_nlinno = info.totlnos;
     3724+    }
     3725+  free (info.secsyms);
     3726+
     3727+  coff_name_type_hash_traverse (&info.types, coff_free_type_info, NULL);
     3728+  bfd_hash_table_free (&info.types.root);
     3729+
     3730+  coff_struct_hash_traverse (&info.structs, coff_free_struct_info, NULL);
     3731+  bfd_hash_table_free (&info.structs.root);
     3732+
     3733+  coff_enum_hash_traverse (&info.enums, coff_free_enum_info, NULL);
     3734+  bfd_hash_table_free (&info.enums.root);
     3735+
     3736+  /* FIXME: free all the other stuff remembered in "info". */
     3737+
     3738+  free (*symppp);
     3739+
     3740+  *symcountp = info.nsyms;
     3741+  *symppp = (asymbol **)info.syms;
     3742+
     3743+  return TRUE;
     3744+}
     3745+
     3746+/* Start writing out information for a compilation unit.  */
     3747+
     3748+static bfd_boolean
     3749+coff_start_compilation_unit (p, filename)
     3750+     PTR p;
     3751+     const char *filename;
     3752+{
     3753+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     3754+  long i;
     3755+  const char *bn;
     3756+  bfd_boolean found;
     3757+  coff_symbol_type *csymp;
     3758+
     3759+#if COFF_DEBUG
     3760+  printf ("coff_start_compilation_unit(%s)\n", filename);
     3761+#endif
     3762+
     3763+  /* If there is an old compilation unit that has got any local
     3764+     non-debugging symbols left over, send them out now. */
     3765+  if (info->currentfile != NULL && info->currentfile->totsyms != 0)
     3766+    for (i = 0; i < info->currentfile->nsyms; i++)
     3767+      {
     3768+       struct coff_compilation_unit *up = info->currentfile;
     3769+
     3770+       if (up->syms[i] != NULL)
     3771+         {
     3772+           coff_emit_ndebug_sym (info, up->syms[i], TRUE);
     3773+           up->syms[i] = NULL;
     3774+           up->totsyms--;
     3775+         }
     3776+      }
     3777+
     3778+  /* symtab (and thus COFF debugging) symbols can only transfer the
     3779+     basename of the file, so strip the dirname */
     3780+  bn = bu_basename (filename);
     3781+
     3782+  for (i = 0, found = FALSE; i < info->nunits; i++)
     3783+    {
     3784+      if (strcmp (info->units[i].fname, bn) == 0)
     3785+       {
     3786+         info->currentfile = info->units + i;
     3787+         found = TRUE;
     3788+         break;
     3789+       }
     3790+    }
     3791+  if (!found)
     3792+    {
     3793+      fprintf(stderr,
     3794+             _("Warning: file %s not found in symbol table, ignoring\n"),
     3795+             filename);
     3796+      info->currentfile = NULL;
     3797+      return TRUE;
     3798+    }
     3799+
     3800+  /* Synthesize a new internal COFF symbol. */
     3801+  csymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     3802+  if (csymp == NULL)
     3803+    return FALSE;
     3804+
     3805+  /* Note that coff_fix_symbol_name() [coffgen.c] will fix this for
     3806+     us: the symbol name will be replaced by ".file", and the filename
     3807+     will be moved to the aux entries.  We use the long name obtained
     3808+     from the debugging information (that includes the full path) if
     3809+     our COFF format supports long filenames, otherwise we only use
     3810+     the basename of the file. */
     3811+  if (bfd_coff_long_filenames (info->abfd))
     3812+    csymp->symbol.name = filename;
     3813+  else
     3814+    csymp->symbol.name = bn;
     3815+  csymp->symbol.value = 0;
     3816+  csymp->symbol.udata.p = NULL;
     3817+  csymp->native->u.syment.n_sclass = C_FILE;
     3818+  csymp->native->u.syment.n_numaux = 1;        /* force filename into aux entry */
     3819+  coff_record_symbol (info, csymp);
     3820+
     3821+  return TRUE;
     3822+}
     3823+
     3824+/* Start writing out information for a particular source file.  */
     3825+
     3826+static bfd_boolean
     3827+coff_start_source (p, filename)
     3828+     PTR p ATTRIBUTE_UNUSED;
     3829+     const char *filename ATTRIBUTE_UNUSED;
     3830+{
     3831+
     3832+#if COFF_DEBUG
     3833+  printf ("coff_start_source(%s)\n", filename);
     3834+#endif
     3835+
     3836+  /* COFF cannot handle include filenames. */
     3837+
     3838+  return TRUE;
     3839+}
     3840+
     3841+/* Push an empty type.  This shouldn't normally happen.  */
     3842+
     3843+static bfd_boolean
     3844+coff_empty_type (p)
     3845+     PTR p;
     3846+{
     3847+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     3848+  struct coff_type_stack *tst;
     3849+
     3850+#if COFF_DEBUG
     3851+  printf ("coff_empty_type()\n");
     3852+#endif
     3853+
     3854+  coff_push_type (TS_EMPTY);
     3855+
     3856+  return TRUE;
     3857+}
     3858+
     3859+/* Push a void type.  */
     3860+
     3861+static bfd_boolean
     3862+coff_void_type (p)
     3863+     PTR p;
     3864+{
     3865+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     3866+  struct coff_type_stack *tst;
     3867+
     3868+#if COFF_DEBUG
     3869+  printf ("coff_void_type()\n");
     3870+#endif
     3871+
     3872+  coff_push_type (TS_VOID);
     3873+
     3874+  return TRUE;
     3875+}
     3876+
     3877+/* Push an integer type.  */
     3878+
     3879+static bfd_boolean
     3880+coff_int_type (p, size, unsignedp)
     3881+     PTR p;
     3882+     unsigned int size;
     3883+     bfd_boolean unsignedp;
     3884+{
     3885+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     3886+  struct coff_type_stack *tst;
     3887+
     3888+#if COFF_DEBUG
     3889+  printf ("coff_int_type(%d, %d)\n", size, unsignedp);
     3890+#endif
     3891+
     3892+  coff_push_type (TS_INT);
     3893+  tst->u.ts_int.size = size;
     3894+  tst->u.ts_int.isunsigned = unsignedp;
     3895+
     3896+  return TRUE;
     3897+}
     3898+
     3899+/* Push a floating point type.  */
     3900+
     3901+static bfd_boolean
     3902+coff_float_type (p, size)
     3903+     PTR p;
     3904+     unsigned int size;
     3905+{
     3906+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     3907+  struct coff_type_stack *tst;
     3908+
     3909+#if COFF_DEBUG
     3910+  printf ("coff_float_type(%d)\n", size);
     3911+#endif
     3912+
     3913+  coff_push_type (TS_FLOAT);
     3914+  tst->u.ts_float.size = size;
     3915+
     3916+  return TRUE;
     3917+}
     3918+
     3919+/* Push a complex type.  */
     3920+
     3921+static bfd_boolean
     3922+coff_complex_type (p, size)
     3923+     PTR p;
     3924+     unsigned int size ATTRIBUTE_UNUSED;
     3925+{
     3926+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     3927+  struct coff_type_stack *tst;
     3928+
     3929+#if COFF_DEBUG
     3930+  printf ("coff_complex_type(%d)\n", size);
     3931+#endif
     3932+
     3933+  coff_push_type (TS_COMPLEX);
     3934+
     3935+  return TRUE;
     3936+}
     3937+
     3938+/* Push a bfd_boolean type. */
     3939+
     3940+static bfd_boolean
     3941+coff_bool_type (p, size)
     3942+     PTR p;
     3943+     unsigned int size;
     3944+{
     3945+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     3946+  struct coff_type_stack *tst;
     3947+
     3948+#if COFF_DEBUG
     3949+  printf ("coff_bool_type(%d)\n", size);
     3950+#endif
     3951+
     3952+  coff_push_type (TS_INT);
     3953+  tst->u.ts_int.size = size;
     3954+  tst->u.ts_int.isunsigned = TRUE;
     3955+
     3956+  return TRUE;
     3957+}
     3958+
     3959+/* Push an enum type.  */
     3960+
     3961+static bfd_boolean
     3962+coff_enum_type (p, tag, names, vals)
     3963+     PTR p;
     3964+     const char *tag;
     3965+     const char **names;
     3966+     bfd_signed_vma *vals;
     3967+{
     3968+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     3969+  struct coff_type_stack *tst;
     3970+  char buf[20];
     3971+
     3972+#if COFF_DEBUG
     3973+  int idx;
     3974+  printf ("coff_enum_type(%s [", tag);
     3975+  for (idx = 0; names[idx] != NULL; idx++)
     3976+    printf ("%s -> %d, ", names[idx], (int)vals[idx]);
     3977+  printf ("])\n");
     3978+#endif
     3979+
     3980+  coff_push_type (TS_ENUM);
     3981+
     3982+  if (tag == NULL)
     3983+    {
     3984+      sprintf(buf, ".%dfake", info->nenums++);
     3985+      tst->u.ts_enum.tag.malloctag = xstrdup (buf);
     3986+      tst->u.ts_enum.tagismalloced = TRUE;
     3987+    }
     3988+  else
     3989+    tst->u.ts_enum.tag.fixtag = tag;
     3990+  tst->u.ts_enum.names = names;
     3991+  tst->u.ts_enum.vals = vals;
     3992+
     3993+  return TRUE;
     3994+}
     3995+
     3996+/* Push a pointer type.  */
     3997+
     3998+static bfd_boolean
     3999+coff_pointer_type (p)
     4000+     PTR p;
     4001+{
     4002+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4003+  struct coff_type_stack *tst;
     4004+
     4005+#if COFF_DEBUG
     4006+  printf ("coff_pointer_type()\n");
     4007+#endif
     4008+
     4009+  coff_push_type (TS_POINTER);
     4010+
     4011+  return TRUE;
     4012+}
     4013+
     4014+/* Push a function type.  */
     4015+
     4016+static bfd_boolean
     4017+coff_function_type (p, argcount, varargs)
     4018+     PTR p;
     4019+     int argcount;
     4020+     bfd_boolean varargs ATTRIBUTE_UNUSED;
     4021+{
     4022+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4023+  struct coff_type_stack *tst;
     4024+
     4025+#if COFF_DEBUG
     4026+  printf ("coff_function_type(%d, %d)\n", argcount, varargs);
     4027+#endif
     4028+
     4029+  coff_push_type (TS_FUNC);
     4030+
     4031+  /* FIXME should properly discard function arguments */
     4032+  if (argcount > -1)
     4033+    {
     4034+      fprintf (stderr,
     4035+              _("coff_function_type() called with positive argcount\n"));
     4036+      return FALSE;
     4037+    }
     4038+
     4039+  return TRUE;
     4040+}
     4041+
     4042+/* Push a reference type.  */
     4043+
     4044+static bfd_boolean
     4045+coff_reference_type (p)
     4046+     PTR p;
     4047+{
     4048+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4049+
     4050+#if COFF_DEBUG
     4051+  printf ("coff_reference_type()\n");
     4052+#endif
     4053+
     4054+  coff_complain_unsupp (_("reference"));
     4055+
     4056+  return TRUE;
     4057+}
     4058+
     4059+/* Push a range type.  */
     4060+
     4061+static bfd_boolean
     4062+coff_range_type (p, low, high)
     4063+     PTR p;
     4064+     bfd_signed_vma low ATTRIBUTE_UNUSED;
     4065+     bfd_signed_vma high ATTRIBUTE_UNUSED;
     4066+{
     4067+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4068+
     4069+#if COFF_DEBUG
     4070+  printf ("coff_range_type([%d..%d)\n", (int)low, (int)high);
     4071+#endif
     4072+
     4073+  coff_complain_unsupp (_("range"));
     4074+
     4075+  return TRUE;
     4076+}
     4077+
     4078+/* Push an array type.  */
     4079+
     4080+static bfd_boolean
     4081+coff_array_type (p, low, high, stringp)
     4082+     PTR p;
     4083+     bfd_signed_vma low;
     4084+     bfd_signed_vma high;
     4085+     bfd_boolean stringp;
     4086+{
     4087+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4088+  struct coff_type_stack *tst;
     4089+
     4090+#if COFF_DEBUG
     4091+  printf ("coff_array_type([%d..%d], %d)\n",
     4092+         (int)low, (int)high, stringp);
     4093+#endif
     4094+
     4095+  /* Pop the range type, but ignore it.  COFF doesn't use it. */
     4096+  coff_pop_type ();
     4097+
     4098+  /* FIXME  What to do here? */
     4099+  if (stringp)
     4100+    {
     4101+      fprintf(stderr, _("coff_array_type(): stringp == TRUE\n"));
     4102+      return FALSE;
     4103+    }
     4104+
     4105+  coff_push_type (TS_ARRAY);
     4106+  tst->u.ts_array.low = low;
     4107+  tst->u.ts_array.high = high;
     4108+
     4109+  return TRUE;
     4110+}
     4111+
     4112+/* Push a set type.  */
     4113+
     4114+static bfd_boolean
     4115+coff_set_type (p, bitstringp)
     4116+     PTR p;
     4117+     bfd_boolean bitstringp ATTRIBUTE_UNUSED;
     4118+{
     4119+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4120+
     4121+#if COFF_DEBUG
     4122+  printf ("coff_set_type(%d)\n", bitstringp);
     4123+#endif
     4124+
     4125+  coff_complain_unsupp (_("set"));
     4126+
     4127+  return TRUE;
     4128+}
     4129+
     4130+/* Push an offset type.  */
     4131+
     4132+static bfd_boolean
     4133+coff_offset_type (p)
     4134+     PTR p;
     4135+{
     4136+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4137+
     4138+#if COFF_DEBUG
     4139+  printf ("coff_offset_type()\n");
     4140+#endif
     4141+
     4142+  coff_complain_unsupp (_("offset"));
     4143+
     4144+  return TRUE;
     4145+}
     4146+
     4147+/* Push a method type.  */
     4148+
     4149+static bfd_boolean
     4150+coff_method_type (p, domainp, argcount, varargs)
     4151+     PTR p;
     4152+     bfd_boolean domainp ATTRIBUTE_UNUSED;
     4153+     int argcount ATTRIBUTE_UNUSED;
     4154+     bfd_boolean varargs ATTRIBUTE_UNUSED;
     4155+{
     4156+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4157+
     4158+#if COFF_DEBUG
     4159+  printf ("coff_method_type(%d, %d, %d)\n",
     4160+         domainp, argcount, varargs);
     4161+#endif
     4162+
     4163+  coff_complain_unsupp (_("method"));
     4164+
     4165+  return TRUE;
     4166+}
     4167+
     4168+/* Push a const version of a type.  */
     4169+
     4170+static bfd_boolean
     4171+coff_const_type (p)
     4172+     PTR p ATTRIBUTE_UNUSED;
     4173+{
     4174+
     4175+#if COFF_DEBUG
     4176+  printf ("coff_const_type()\n");
     4177+#endif
     4178+
     4179+  /* const modifier is ignored by COFF */
     4180+
     4181+  return TRUE;
     4182+}
     4183+
     4184+/* Push a volatile version of a type.  */
     4185+
     4186+static bfd_boolean
     4187+coff_volatile_type (p)
     4188+     PTR p ATTRIBUTE_UNUSED;
     4189+{
     4190+
     4191+#if COFF_DEBUG
     4192+  printf ("coff_volatile_type()\n");
     4193+#endif
     4194+
     4195+  /* volatile modifier is ignored by COFF */
     4196+
     4197+  return TRUE;
     4198+}
     4199+
     4200+/* Start outputting a struct.  */
     4201+
     4202+static bfd_boolean
     4203+coff_start_struct_type (p, tag, id, structp, size)
     4204+     PTR p;
     4205+     const char *tag;
     4206+     unsigned int id;
     4207+     bfd_boolean structp;
     4208+     unsigned int size;
     4209+{
     4210+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4211+  struct coff_type_stack *tst, *savedts;
     4212+  struct coff_struct_hash_entry *shash;
     4213+  char buf[20];
     4214+  const char *name;
     4215+
     4216+#if COFF_DEBUG
     4217+  printf ("coff_start_struct_type(%s, %d, %d, %d)\n",
     4218+         tag, id, structp, size);
     4219+#endif
     4220+
     4221+  savedts = info->tstack;
     4222+  info->tstack = NULL;
     4223+
     4224+  coff_push_type (TS_STRUCT);
     4225+
     4226+  if (tag == NULL)
     4227+    {
     4228+      sprintf(buf, ".%dfake", id);
     4229+      name = tst->u.ts_struct.tag.malloctag = xstrdup (buf);
     4230+      tst->u.ts_struct.tagismalloced = TRUE;
     4231+    }
     4232+  else
     4233+    name = tst->u.ts_struct.tag.fixtag = tag;
     4234+  tst->u.ts_struct.id = id;
     4235+  tst->u.ts_struct.isstruct = structp;
     4236+  tst->u.ts_struct.size = size;
     4237+  tst->u.ts_struct.savedts = savedts;
     4238+
     4239+  shash = coff_struct_hash_lookup (&info->structs, name, FALSE, FALSE);
     4240+  if (shash != NULL && shash->types != NULL)
     4241+    {
     4242+#if COFF_DEBUG
     4243+      printf ("new %s definition for %s\n",
     4244+             tst->u.ts_struct.isstruct? "struct": "union", name);
     4245+#endif
     4246+      coff_free_struct_info (shash, NULL);
     4247+      shash->types = NULL;
     4248+      shash->emitted = FALSE;
     4249+    }
     4250+  else
     4251+    (void)coff_struct_hash_lookup (&info->structs, name,
     4252+                            TRUE, tst->u.ts_struct.tagismalloced);
     4253+
     4254+  return TRUE;
     4255+}
     4256+
     4257+/* Add a field to a struct.  */
     4258+
     4259+static bfd_boolean
     4260+coff_struct_field (p, name, bitpos, bitsize, visibility)
     4261+     PTR p;
     4262+     const char *name;
     4263+     bfd_vma bitpos;
     4264+     bfd_vma bitsize;
     4265+     enum debug_visibility visibility;
     4266+{
     4267+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4268+  struct coff_type_stack *tst, *otst;
     4269+  struct coff_struct_fields *fp;
     4270+  struct coff_struct_hash_entry *shash;
     4271+  struct coff_enum_hash_entry *ehash;
     4272+  const char *tag;
     4273+
     4274+#if COFF_DEBUG
     4275+  printf ("coff_struct_field(%s, %d, %d, %d)\n",
     4276+         name, (int)bitpos, (int)bitsize, (int)visibility);
     4277+#endif
     4278+
     4279+  /* Find the last element on the type stack. */
     4280+  assert (info->tstack != NULL);
     4281+  for (tst = info->tstack, otst = NULL; tst->next != NULL;)
     4282+    {
     4283+      otst = tst;
     4284+      tst = tst->next;
     4285+    }
     4286+  if (otst != NULL)
     4287+    otst->next = NULL;
     4288+
     4289+  if (tst->tsk != TS_STRUCT)
     4290+    {
     4291+      fprintf (stderr, "coff_struct_field() not within structure definition\n");
     4292+      return FALSE;
     4293+    }
     4294+  tst->u.ts_struct.fields = (struct coff_struct_fields *)
     4295+    xrealloc (tst->u.ts_struct.fields,
     4296+             ++tst->u.ts_struct.nfields * sizeof (struct coff_struct_fields));
     4297+  fp = tst->u.ts_struct.fields + (tst->u.ts_struct.nfields - 1);
     4298+  fp->name = name;
     4299+  fp->bitpos = bitpos;
     4300+  fp->bitsize = bitsize;
     4301+  fp->visibility = visibility;
     4302+  otst = fp->types = info->tstack;
     4303+  while (otst->next != NULL)
     4304+    otst = otst->next;
     4305+  if (otst->tsk == TS_STRUCT && otst->u.ts_struct.shash == NULL)
     4306+    {
     4307+      if (otst->u.ts_struct.tagismalloced)
     4308+       tag = otst->u.ts_struct.tag.malloctag;
     4309+      else
     4310+       tag = otst->u.ts_struct.tag.fixtag;
     4311+      shash = coff_struct_hash_lookup (&info->structs, tag, FALSE, FALSE);
     4312+      assert (shash != NULL);
     4313+      if (!shash->emitted)
     4314+       {
     4315+         if (shash->types == NULL)
     4316+           {
     4317+             shash->types = (struct coff_type_stack *)
     4318+               xmalloc (sizeof (struct coff_type_stack));
     4319+             memcpy (shash->types, otst, sizeof (struct coff_type_stack));
     4320+           }
     4321+         shash->emitted = TRUE;
     4322+         coff_emit_struct (info, otst, shash);
     4323+       }
     4324+    }
     4325+  else if (otst->tsk == TS_ENUM)
     4326+    {
     4327+      if (otst->u.ts_enum.tagismalloced)
     4328+       tag = otst->u.ts_enum.tag.malloctag;
     4329+      else
     4330+       tag = otst->u.ts_enum.tag.fixtag;
     4331+      ehash = coff_enum_hash_lookup (&info->enums, tag, TRUE, FALSE);
     4332+      assert (ehash != NULL);
     4333+      if (!ehash->emitted)
     4334+       {
     4335+         if (ehash->types == NULL)
     4336+           {
     4337+             ehash->types = (struct coff_type_stack *)
     4338+               xmalloc (sizeof (struct coff_type_stack));
     4339+             memcpy (ehash->types, otst, sizeof (struct coff_type_stack));
     4340+           }
     4341+         ehash->emitted = TRUE;
     4342+         coff_emit_enum (info, otst, ehash);
     4343+       }
     4344+    }
     4345+
     4346+  info->tstack = tst;
     4347+
     4348+  return TRUE;
     4349+}
     4350+
     4351+/* Finish up a struct.  */
     4352+
     4353+static bfd_boolean
     4354+coff_end_struct_type (p)
     4355+     PTR p;
     4356+{
     4357+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4358+  struct coff_type_stack *tst, *savedts;
     4359+
     4360+#if COFF_DEBUG
     4361+  printf ("coff_end_struct_type()\n");
     4362+#endif
     4363+
     4364+  /* Our struct definition should be the only type stack element by
     4365+     now. */
     4366+  assert (info->tstack != NULL);
     4367+  tst = info->tstack;
     4368+  if (tst->tsk != TS_STRUCT || tst->next != NULL)
     4369+    {
     4370+      fprintf (stderr, "coff_struct_field() not within structure definition\n");
     4371+      return FALSE;
     4372+    }
     4373+
     4374+  /* Restore saved type stack, and push our now complete struct
     4375+     definition on top. */
     4376+  savedts = tst->u.ts_struct.savedts;
     4377+  tst->u.ts_struct.savedts = info->tstack;
     4378+  info->tstack = savedts;
     4379+  tst->next = info->tstack;
     4380+  info->tstack = tst;
     4381+
     4382+  return TRUE;
     4383+}
     4384+
     4385+/* Start outputting a class.  */
     4386+
     4387+static bfd_boolean
     4388+coff_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
     4389+     PTR p;
     4390+     const char *tag ATTRIBUTE_UNUSED;
     4391+     unsigned int id ATTRIBUTE_UNUSED;
     4392+     bfd_boolean structp ATTRIBUTE_UNUSED;
     4393+     unsigned int size ATTRIBUTE_UNUSED;
     4394+     bfd_boolean vptr ATTRIBUTE_UNUSED;
     4395+     bfd_boolean ownvptr ATTRIBUTE_UNUSED;
     4396+{
     4397+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4398+
     4399+#if COFF_DEBUG
     4400+  printf ("coff_start_class_type(%s, %d, %d, %d, %d, %d)\n",
     4401+         tag, id, structp, size, vptr, ownvptr);
     4402+#endif
     4403+
     4404+  coff_complain_unsupp (_("class"));
     4405+
     4406+  return TRUE;
     4407+}
     4408+
     4409+/* Add a static member to the class on the type stack.  */
     4410+
     4411+static bfd_boolean
     4412+coff_class_static_member (p, name, physname, visibility)
     4413+     PTR p ATTRIBUTE_UNUSED;
     4414+     const char *name ATTRIBUTE_UNUSED;
     4415+     const char *physname ATTRIBUTE_UNUSED;
     4416+     enum debug_visibility visibility ATTRIBUTE_UNUSED;
     4417+{
     4418+
     4419+#if COFF_DEBUG
     4420+  printf ("coff_class_static_member(%s, %s, %d)\n",
     4421+         name, physname, (int)visibility);
     4422+#endif
     4423+
     4424+  return TRUE;
     4425+}
     4426+
     4427+/* Add a base class to the class on the type stack.  */
     4428+
     4429+static bfd_boolean
     4430+coff_class_baseclass (p, bitpos, virtual, visibility)
     4431+     PTR p ATTRIBUTE_UNUSED;
     4432+     bfd_vma bitpos ATTRIBUTE_UNUSED;
     4433+     bfd_boolean virtual ATTRIBUTE_UNUSED;
     4434+     enum debug_visibility visibility ATTRIBUTE_UNUSED;
     4435+{
     4436+
     4437+#if COFF_DEBUG
     4438+  printf ("coff_class_baseclass(%d, %d, %d)\n",
     4439+         (int)bitpos, virtual, (int)visibility);
     4440+#endif
     4441+
     4442+  return TRUE;
     4443+}
     4444+
     4445+/* Start adding a method to the class on the type stack.  */
     4446+
     4447+static bfd_boolean
     4448+coff_class_start_method (p, name)
     4449+     PTR p ATTRIBUTE_UNUSED;
     4450+     const char *name ATTRIBUTE_UNUSED;
     4451+{
     4452+
     4453+#if COFF_DEBUG
     4454+  printf ("coff_class_start_method(%s)\n", name);
     4455+#endif
     4456+
     4457+  return TRUE;
     4458+}
     4459+
     4460+/* Add a variant to the current method.  */
     4461+
     4462+static bfd_boolean
     4463+coff_class_method_variant (p, physname, visibility, constp, volatilep,
     4464+                          voffset, contextp)
     4465+     PTR p ATTRIBUTE_UNUSED;
     4466+     const char *physname ATTRIBUTE_UNUSED;
     4467+     enum debug_visibility visibility ATTRIBUTE_UNUSED;
     4468+     bfd_boolean constp ATTRIBUTE_UNUSED;
     4469+     bfd_boolean volatilep ATTRIBUTE_UNUSED;
     4470+     bfd_vma voffset ATTRIBUTE_UNUSED;
     4471+     bfd_boolean contextp ATTRIBUTE_UNUSED;
     4472+{
     4473+
     4474+#if COFF_DEBUG
     4475+  printf ("coff_class_method_variant(%s, %d, %d, %d, %d, %d)\n",
     4476+         physname, (int)visibility, constp, volatilep,
     4477+         (int)voffset, contextp);
     4478+#endif
     4479+
     4480+  return TRUE;
     4481+}
     4482+
     4483+/* Add a static variant to the current method.  */
     4484+
     4485+static bfd_boolean
     4486+coff_class_static_method_variant (p, physname, visibility, constp, volatilep)
     4487+     PTR p ATTRIBUTE_UNUSED;
     4488+     const char *physname ATTRIBUTE_UNUSED;
     4489+     enum debug_visibility visibility ATTRIBUTE_UNUSED;
     4490+     bfd_boolean constp ATTRIBUTE_UNUSED;
     4491+     bfd_boolean volatilep ATTRIBUTE_UNUSED;
     4492+{
     4493+
     4494+#if COFF_DEBUG
     4495+  printf ("coff_class_static_method_variant(%s, %d, %d, %d)\n",
     4496+         physname, (int)visibility, constp, volatilep);
     4497+#endif
     4498+
     4499+  return TRUE;
     4500+}
     4501+
     4502+/* Finish up a method.  */
     4503+
     4504+static bfd_boolean
     4505+coff_class_end_method (p)
     4506+     PTR p ATTRIBUTE_UNUSED;
     4507+{
     4508+
     4509+#if COFF_DEBUG
     4510+  printf ("coff_class_end_method()\n");
     4511+#endif
     4512+
     4513+  return TRUE;
     4514+}
     4515+
     4516+/* Finish up a class.  */
     4517+
     4518+static bfd_boolean
     4519+coff_end_class_type (p)
     4520+     PTR p ATTRIBUTE_UNUSED;
     4521+{
     4522+
     4523+#if COFF_DEBUG
     4524+  printf ("coff_end_class_type()\n");
     4525+#endif
     4526+
     4527+  return TRUE;
     4528+}
     4529+
     4530+/* Push a typedef which was previously defined.  */
     4531+
     4532+static bfd_boolean
     4533+coff_typedef_type (p, name)
     4534+     PTR p;
     4535+     const char *name;
     4536+{
     4537+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4538+  struct coff_name_type_hash_entry *nthash;
     4539+  struct coff_type_stack *tst, *newchain, *newst, *temp;
     4540+
     4541+#if COFF_DEBUG
     4542+  printf ("coff_typedef_type(%s)\n", name);
     4543+#endif
     4544+
     4545+  nthash = coff_name_type_hash_lookup (&info->types, name, FALSE, FALSE);
     4546+
     4547+  /* nthash should never be NULL, since that would imply that the
     4548+     generic debugging code has asked for a typedef which it has not
     4549+     yet defined.  */
     4550+  assert (nthash != NULL);
     4551+
     4552+  /* Just push the entire type stack snapshot we've got on top of the
     4553+     existing typestack.  See coff_typdef() below for how this
     4554+     works.  We need to copy over each element however, since anybody
     4555+     popping elements off the typestack is supposed to free() each of
     4556+     them. */
     4557+
     4558+  for (tst = nthash->types, temp = newst = newchain = NULL; tst != NULL;)
     4559+    {
     4560+      temp = newst;
     4561+      newst = (struct coff_type_stack *) xmalloc (sizeof (*newst));
     4562+      if (newchain == NULL)
     4563+       newchain = newst;
     4564+      memcpy (newst, tst, sizeof (*newst));
     4565+      if (temp != NULL)
     4566+       temp->next = newst;
     4567+
     4568+      tst = tst->next;
     4569+    }
     4570+  newst->next = info->tstack;
     4571+  info->tstack = newchain;
     4572+
     4573+  return TRUE;
     4574+}
     4575+
     4576+/* Push a struct, union or class tag.  */
     4577+
     4578+static bfd_boolean
     4579+coff_tag_type (p, name, id, kind)
     4580+     PTR p;
     4581+     const char *name;
     4582+     unsigned int id ATTRIBUTE_UNUSED;
     4583+     enum debug_type_kind kind;
     4584+{
     4585+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4586+  struct coff_type_stack *tst, *newchain, *newst, *temp;
     4587+  struct coff_struct_hash_entry *shash;
     4588+  struct coff_enum_hash_entry *ehash;
     4589+  char buf[20];
     4590+  bfd_boolean needcopy = FALSE;
     4591+  bfd_boolean isstruct = TRUE;
     4592+
     4593+#if COFF_DEBUG
     4594+  printf ("coff_tag_type(%s, %d, %d)\n",
     4595+         name, id, kind);
     4596+#endif
     4597+
     4598+  if (name == NULL)
     4599+    {
     4600+      sprintf(buf, ".%dfake", id);
     4601+      needcopy = TRUE;
     4602+    }
     4603+
     4604+  switch (kind)
     4605+    {
     4606+    case DEBUG_KIND_UNION:
     4607+    case DEBUG_KIND_UNION_CLASS:
     4608+      isstruct = FALSE;
     4609+      /* FALLTHROUGH */
     4610+    case DEBUG_KIND_STRUCT:
     4611+    case DEBUG_KIND_CLASS:
     4612+      shash = coff_struct_hash_lookup (&info->structs,
     4613+                                      name == NULL? buf: name, TRUE, needcopy);
     4614+      assert (shash != NULL);
     4615+      tst = shash->types;
     4616+      if (tst == NULL)
     4617+       {
     4618+         /* This is a reference to a tag that has not yet been
     4619+            defined (i. e., a forward reference).  Synthesize a
     4620+            ts_struct entry by now, and mark it for later fixup. */
     4621+         tst = (struct coff_type_stack *) xmalloc (sizeof *tst);
     4622+         memset (tst, 0, sizeof *tst);
     4623+         tst->tsk = TS_STRUCT;
     4624+         tst->u.ts_struct.isstruct = isstruct;
     4625+         tst->u.ts_struct.shash = shash;
     4626+       }
     4627+    docopystack:
     4628+      /* Just push the entire type stack snapshot we've got on top of the
     4629+        existing typestack.  See coff_typdef() below for how this
     4630+        works.  We need to copy over each element however, since anybody
     4631+        popping elements off the typestack is supposed to free() each of
     4632+        them. */
     4633+      for (temp = newst = newchain = NULL; tst != NULL;)
     4634+       {
     4635+         temp = newst;
     4636+         newst = (struct coff_type_stack *) xmalloc (sizeof (*newst));
     4637+         if (newchain == NULL)
     4638+           newchain = newst;
     4639+         memcpy (newst, tst, sizeof (*newst));
     4640+         if (temp != NULL)
     4641+           temp->next = newst;
     4642+
     4643+         tst = tst->next;
     4644+       }
     4645+      if (newst)
     4646+       {
     4647+         newst->next = info->tstack;
     4648+         info->tstack = newchain;
     4649+       }
     4650+      break;
     4651+
     4652+    case DEBUG_KIND_ENUM:
     4653+      ehash = coff_enum_hash_lookup (&info->enums,
     4654+                                    name == NULL? buf: name, TRUE, needcopy);
     4655+      assert (ehash != NULL);
     4656+      tst = ehash->types;
     4657+      if (tst == NULL)
     4658+       {
     4659+         /* This is a reference to a tag that has not yet been
     4660+            defined (i. e., a forward reference).  Synthesize a
     4661+            ts_enum entry by now, and mark it for later fixup. */
     4662+         tst = (struct coff_type_stack *) xmalloc (sizeof *tst);
     4663+         memset (tst, 0, sizeof *tst);
     4664+         tst->tsk = TS_ENUM;
     4665+         tst->u.ts_enum.ehash = ehash;
     4666+       }
     4667+      goto docopystack;
     4668+
     4669+    default:
     4670+      fprintf (stderr, _("illegal kind %d in coff_tag_type()\n"),
     4671+              (int)kind);
     4672+      return FALSE;
     4673+    }
     4674+  return TRUE;
     4675+}
     4676+
     4677+/* Define a typedef.  */
     4678+
     4679+static bfd_boolean
     4680+coff_typdef (p, name)
     4681+     PTR p;
     4682+     const char *name;
     4683+{
     4684+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4685+  struct coff_name_type_hash_entry *nthash;
     4686+
     4687+#if COFF_DEBUG
     4688+  printf ("coff_typdef(%s)\n", name);
     4689+#endif
     4690+
     4691+  /* COFF cannot really handle typedefs.  While there is the option to
     4692+     mark a symbol using the storage class C_TPDEF (so the COFF reader
     4693+     will know that name), there is no way to place a reference to
     4694+     that typedef into the just 16 bits COFF reserves for all of its
     4695+     type information.  Thus, any use of the typedef must always fully
     4696+     dereference the typedef again.  We do this by "snapshotting" the
     4697+     current type stack under the name of our typedef, and later on,
     4698+     when BFD debugging tells us to make use of the typedef (in
     4699+     coff_typedef_type()), we just look it up, and push all we've got
     4700+     completely onto the type stack again. */
     4701+
     4702+  if (info->tstack == NULL)
     4703+    {
     4704+      fprintf (stderr, _("coff_typdef() on an empty type stack\n"));
     4705+      return FALSE;
     4706+    }
     4707+
     4708+  nthash = coff_name_type_hash_lookup (&info->types, name, FALSE, FALSE);
     4709+  if (nthash != NULL)
     4710+    {
     4711+#if COFF_DEBUG
     4712+      printf ("new typedef for %s\n", name);
     4713+#endif
     4714+      coff_free_type_info (nthash, NULL);
     4715+    }
     4716+  else
     4717+    nthash = coff_name_type_hash_lookup (&info->types, name, TRUE, FALSE);
     4718+  if (nthash == NULL)
     4719+    return FALSE;
     4720+  nthash->types = info->tstack;
     4721+
     4722+  /* If the typestack is "sufficiently complex", emit a C_TPDEF symbol
     4723+     for it.  We assume it to be sufficiently complex if there are
     4724+     either at least two derived types, or one derived type where the
     4725+     base type is not a simple scalar one. */
     4726+  if (!nthash->emitted
     4727+      && info->tstack->next != NULL
     4728+      && (info->tstack->next->next != NULL || info->tstack->next->tsk >= TS_ENUM))
     4729+    {
     4730+      struct coff_type_stack *newchain, *otst, *tst, *ntst;
     4731+      coff_symbol_type *csymp;
     4732+
     4733+      nthash->emitted = TRUE;
     4734+
     4735+      for (tst = info->tstack, newchain = otst = NULL;
     4736+          tst != NULL;
     4737+          tst = tst->next)
     4738+       {
     4739+         ntst = (struct coff_type_stack *)
     4740+           xmalloc (sizeof (struct coff_type_stack));
     4741+         memcpy (ntst, tst, sizeof (struct coff_type_stack));
     4742+         if (otst == NULL)
     4743+           newchain = ntst;
     4744+         else
     4745+           otst->next = ntst;
     4746+         otst = ntst;
     4747+       }
     4748+      info->tstack = newchain;
     4749+      if (!coff_make_typed_symbol (info, &csymp, TS_NONE))
     4750+       return FALSE;
     4751+
     4752+      csymp->symbol.name = xstrdup (name);
     4753+      csymp->symbol.flags = BSF_NOT_AT_END;
     4754+      csymp->symbol.section = bfd_com_section_ptr;
     4755+      csymp->native->u.syment.n_sclass = C_TPDEF;
     4756+      csymp->symbol.value = 0;
     4757+
     4758+      coff_record_symbol (info, csymp);
     4759+    }
     4760+  info->tstack = NULL;
     4761+
     4762+  return TRUE;
     4763+}
     4764+
     4765+/* Define a tag.  */
     4766+
     4767+static bfd_boolean
     4768+coff_tag (p, tag)
     4769+     PTR p;
     4770+     const char *tag;
     4771+{
     4772+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4773+  struct coff_type_stack *tst = NULL;
     4774+  struct coff_struct_hash_entry *shash;
     4775+  struct coff_enum_hash_entry *ehash;
     4776+
     4777+
     4778+#if COFF_DEBUG
     4779+  printf ("coff_tag(%s)\n", tag);
     4780+#endif
     4781+
     4782+  if (info->tstack == NULL)
     4783+    {
     4784+      fprintf (stderr, _("coff_tag() called on an empty typestack\n"));
     4785+      return FALSE;
     4786+    }
     4787+
     4788+  switch (info->tstack->tsk)
     4789+    {
     4790+    case TS_STRUCT:
     4791+      shash = coff_struct_hash_lookup (&info->structs, tag, FALSE, FALSE);
     4792+      assert (shash != NULL);
     4793+      shash->types = info->tstack;
     4794+      info->tstack = NULL;
     4795+      break;
     4796+
     4797+    case TS_ENUM:
     4798+      ehash = coff_enum_hash_lookup (&info->enums, tag, FALSE, FALSE);
     4799+      if (ehash != NULL && ehash->types != NULL)
     4800+       {
     4801+#if COFF_DEBUG
     4802+         printf ("new enum definition for %s\n", tag);
     4803+#endif
     4804+         coff_free_enum_info (ehash, NULL);
     4805+       }
     4806+      else
     4807+       ehash = coff_enum_hash_lookup (&info->enums, tag, TRUE, FALSE);
     4808+      if (ehash == NULL)
     4809+       return FALSE;
     4810+      ehash->types = info->tstack;
     4811+      info->tstack = NULL;
     4812+      break;
     4813+
     4814+    default:
     4815+      fprintf (stderr, _("Illegal typestack (%d) in coff_tag()\n"), tst->tsk);
     4816+      return FALSE;
     4817+    }
     4818+
     4819+  return TRUE;
     4820+}
     4821+
     4822+/* Define an integer constant.  */
     4823+
     4824+static bfd_boolean
     4825+coff_int_constant (p, name, val)
     4826+     PTR p;
     4827+     const char *name ATTRIBUTE_UNUSED;
     4828+     bfd_vma val ATTRIBUTE_UNUSED;
     4829+{
     4830+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4831+
     4832+#if COFF_DEBUG
     4833+  printf ("coff_int_constant(%s, %d)\n", name, (int)val);
     4834+#endif
     4835+
     4836+  coff_complain_unsupp (_("int constant"));
     4837+
     4838+  return TRUE;
     4839+}
     4840+
     4841+/* Define a floating point constant.  */
     4842+
     4843+static bfd_boolean
     4844+coff_float_constant (p, name, val)
     4845+     PTR p;
     4846+     const char *name ATTRIBUTE_UNUSED;
     4847+     double val ATTRIBUTE_UNUSED;
     4848+{
     4849+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4850+
     4851+#if COFF_DEBUG
     4852+  printf ("coff_float_constant(%s, %g)\n", name, val);
     4853+#endif
     4854+
     4855+  coff_complain_unsupp (_("float constant"));
     4856+
     4857+  return TRUE;
     4858+}
     4859+
     4860+/* Define a typed constant.  */
     4861+
     4862+static bfd_boolean
     4863+coff_typed_constant (p, name, val)
     4864+     PTR p;
     4865+     const char *name ATTRIBUTE_UNUSED;
     4866+     bfd_vma val ATTRIBUTE_UNUSED;
     4867+{
     4868+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4869+
     4870+#if COFF_DEBUG
     4871+  printf ("coff_typed_constant(%s, %d)\n", name, (int)val);
     4872+#endif
     4873+
     4874+  coff_complain_unsupp (_("typed constant"));
     4875+
     4876+  return TRUE;
     4877+}
     4878+
     4879+/* Record a variable.  */
     4880+
     4881+static bfd_boolean
     4882+coff_variable (p, name, kind, val)
     4883+     PTR p;
     4884+     const char *name;
     4885+     enum debug_var_kind kind;
     4886+     bfd_vma val;
     4887+{
     4888+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4889+  unsigned char class;
     4890+  asymbol *symp = NULL;
     4891+  coff_symbol_type *csymp;
     4892+  bfd_boolean global = FALSE;
     4893+  flagword flags = BSF_LOCAL;
     4894+  bfd_vma vmadiff = 0;
     4895+
     4896+#if COFF_DEBUG
     4897+  printf ("coff_variable(%s, %d, %d)\n",
     4898+         name, (int)kind, (int)val);
     4899+#endif
     4900+
     4901+  switch (kind)
     4902+    {
     4903+    default:
     4904+      abort ();
     4905+
     4906+    case DEBUG_GLOBAL:
     4907+      flags = BSF_GLOBAL;
     4908+      global = TRUE;
     4909+      /* AVR COFF historically used C_EXTDEF for global variables, and
     4910+        C_EXT for global functions.  Since some AVR COFF consumers
     4911+        apparently depend on this, we mimic this behaviour as
     4912+        well. */
     4913+      class = info->flags & COFF_FL_AVR? C_EXTDEF: C_EXT;
     4914+      break;
     4915+
     4916+    case DEBUG_STATIC:
     4917+    case DEBUG_LOCAL_STATIC:
     4918+      class = C_STAT;
     4919+      break;
     4920+
     4921+    case DEBUG_LOCAL:
     4922+      class = C_AUTO;
     4923+      break;
     4924+
     4925+    case DEBUG_REGISTER:
     4926+      class = C_REG;
     4927+      break;
     4928+    }
     4929+
     4930+  if (!coff_make_typed_symbol (info, &csymp, TS_NONE))
     4931+    return FALSE;
     4932+
     4933+  if (class == C_REG && (info->flags & COFF_FL_AVR) != 0)
     4934+    {
     4935+      struct coff_private_symdata *priv = (struct coff_private_symdata *)
     4936+       csymp->symbol.udata.p;
     4937+      val = coff_fixup_avr_register (val, priv->size * 8);
     4938+    }
     4939+
     4940+  csymp->symbol.name = name;
     4941+  csymp->symbol.flags = flags; /* Note: this clears BSF_DEBUGGING. */
     4942+
     4943+  /* Match the debugging symbol against the input symtab symbols.  If
     4944+     we found one, use the section information from it.  Otherwise, we
     4945+     are lost here and just use the absolute section that was
     4946+     predeclared by coff_bfd_make_debug_symbol().  C_REG and C_AUTO
     4947+     symbols (which we do not attempt to lookup in the symtab symbols
     4948+     at all) go into the ABS section anyway. */
     4949+  if (class != C_REG && class != C_AUTO)
     4950+    {
     4951+      symp = coff_find_symbol (info, name, FALSE, global);
     4952+      if (symp)
     4953+       {
     4954+         csymp->symbol.section = symp->section;
     4955+         vmadiff = symp->section->vma;
     4956+       }
     4957+    }
     4958+
     4959+  /* Symbols are relative to section vma. */
     4960+  csymp->symbol.value = val - vmadiff;
     4961+  csymp->native->u.syment.n_sclass = class;
     4962+  coff_record_symbol (info, csymp);
     4963+
     4964+  return TRUE;
     4965+}
     4966+
     4967+/* Start outputting a function.  */
     4968+
     4969+static bfd_boolean
     4970+coff_start_function (p, name, globalp)
     4971+     PTR p;
     4972+     const char *name;
     4973+     bfd_boolean globalp;
     4974+{
     4975+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     4976+  struct coff_type_stack *tst, *savedts;
     4977+
     4978+#if COFF_DEBUG
     4979+  printf ("coff_start_function(%s, %d)\n",
     4980+         name, globalp);
     4981+#endif
     4982+
     4983+  savedts = info->tstack;
     4984+  info->tstack = NULL;
     4985+
     4986+  coff_push_type (TS_FUNC);
     4987+
     4988+  if (info->funname != NULL)
     4989+    {
     4990+      fprintf (stderr,
     4991+              _("coff_start_function() called twice, pending %s, new %s\n"),
     4992+              info->funname, name);
     4993+      return FALSE;
     4994+    }
     4995+  info->funname = name;
     4996+  info->funglobal = globalp;
     4997+  info->flags |= COFF_FL_START_FCN;
     4998+  tst->u.ts_func.savedts = savedts;
     4999+
     5000+  return TRUE;
     5001+}
     5002+
     5003+/* Output a function parameter.  */
     5004+
     5005+static bfd_boolean
     5006+coff_function_parameter (p, name, kind, val)
     5007+     PTR p;
     5008+     const char *name;
     5009+     enum debug_parm_kind kind;
     5010+     bfd_vma val;
     5011+{
     5012+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     5013+  coff_symbol_type *csymp;
     5014+  unsigned char class;
     5015+
     5016+#if COFF_DEBUG
     5017+  printf ("coff_function_parameter(%s, %d, %d)\n",
     5018+         name, (int)kind, (int)val);
     5019+#endif
     5020+
     5021+  switch (kind)
     5022+    {
     5023+    default:
     5024+      abort ();
     5025+
     5026+    case DEBUG_PARM_STACK:
     5027+      class = C_ARG;
     5028+      break;
     5029+
     5030+    case DEBUG_PARM_REG:
     5031+      class = C_REGPARM;
     5032+      break;
     5033+
     5034+    case DEBUG_PARM_REFERENCE:
     5035+    case DEBUG_PARM_REF_REG:
     5036+      fprintf (stderr, _("Reference parameters not available in COFF\n"));
     5037+      return TRUE;
     5038+    }
     5039+
     5040+  if (!coff_make_typed_symbol (info, &csymp, TS_FUNC))
     5041+    return FALSE;
     5042+
     5043+  if (class == C_REGPARM && (info->flags & COFF_FL_AVR) != 0)
     5044+    {
     5045+      struct coff_private_symdata *priv = (struct coff_private_symdata *)
     5046+       csymp->symbol.udata.p;
     5047+      val = coff_fixup_avr_register (val, priv->size * 8);
     5048+    }
     5049+
     5050+  csymp->symbol.name = name;
     5051+  csymp->symbol.value = val;
     5052+  csymp->symbol.flags |= BSF_LOCAL;
     5053+  csymp->native->u.syment.n_sclass = class;
     5054+
     5055+  /* Since function parameters precede the actual function definition,
     5056+     defer their output until the function has been created. */
     5057+  info->fargs = (coff_symbol_type **)
     5058+    xrealloc (info->fargs, ++info->nfargs * sizeof (coff_symbol_type *));
     5059+  info->fargs[info->nfargs - 1] = csymp;
     5060+
     5061+  return TRUE;
     5062+}
     5063+
     5064+/* Start a block.  */
     5065+
     5066+static bfd_boolean
     5067+coff_start_block (p, addr)
     5068+     PTR p;
     5069+     bfd_vma addr;
     5070+{
     5071+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     5072+  struct coff_type_stack *tst, *otst;
     5073+  struct coff_fix_stack *fixp, *ofp;
     5074+  asymbol *symp;
     5075+  coff_symbol_type *csymp;
     5076+  unsigned int i;
     5077+  bfd_boolean is_start_fcn;
     5078+
     5079+#if COFF_DEBUG
     5080+  printf ("coff_start_block(%#x)\n", (int)addr);
     5081+#endif
     5082+
     5083+  is_start_fcn = info->flags & COFF_FL_START_FCN;
     5084+
     5085+  if (is_start_fcn)
     5086+    {
     5087+      /* This is the starting block of a function.  We are going to
     5088+         write three symbols here, one for the function itself, one
     5089+         ".bf" symbol to indicate the begin of the function, and
     5090+         finally one ".bb" for the first block inside the function. */
     5091+      info->flags &= ~COFF_FL_START_FCN;
     5092+
     5093+      /* Our function definition should be the only type stack element
     5094+        by now. */
     5095+      assert (info->tstack != NULL);
     5096+      tst = info->tstack;
     5097+      if (tst->tsk != TS_FUNC || tst->next != NULL)
     5098+       {
     5099+         fprintf (stderr,
     5100+                  _("coff_start_block() not within function definition\n"));
     5101+         return FALSE;
     5102+       }
     5103+
     5104+      /* Restore saved type stack, and push our now complete function
     5105+        definition on top. */
     5106+      info->tstack = tst->u.ts_func.savedts;
     5107+      tst->next = info->tstack;
     5108+      info->tstack = tst;
     5109+
     5110+      if (info->currentfile == NULL)
     5111+       {
     5112+         fprintf (stderr,
     5113+                  _("Warning: ignoring function %s() outside any compilation unit\n"),
     5114+                  info->funname);
     5115+         for (tst = info->tstack, otst = NULL; tst != NULL;)
     5116+           {
     5117+             otst = tst;
     5118+             tst = otst->next;
     5119+             if (otst->tsk == TS_ENUM &&
     5120+                 otst->u.ts_enum.tagismalloced)
     5121+               free (otst->u.ts_enum.tag.malloctag);
     5122+             else if (otst->tsk == TS_STRUCT &&
     5123+                      otst->u.ts_struct.tagismalloced)
     5124+               free (otst->u.ts_struct.tag.malloctag);
     5125+             free (otst);
     5126+           }
     5127+         info->tstack = NULL;
     5128+         info->funname = NULL;
     5129+
     5130+         return TRUE;
     5131+       }
     5132+
     5133+      if (!coff_make_typed_symbol (info, &csymp, TS_NONE))
     5134+       return FALSE;
     5135+
     5136+      csymp->symbol.name = info->funname;
     5137+      csymp->symbol.flags = BSF_FUNCTION |
     5138+       (info->funglobal? BSF_GLOBAL: BSF_LOCAL);
     5139+      symp = coff_find_symbol (info, info->funname, TRUE, info->funglobal);
     5140+      if (symp == NULL)
     5141+       {
     5142+         fprintf (stderr,
     5143+                  _("function %s not found in symbol table, defaulting to \"text\" section\n"),
     5144+                  info->funname);
     5145+         csymp->symbol.section = info->funcsection = info->textsect;
     5146+       }
     5147+      else
     5148+       csymp->symbol.section = info->funcsection = symp->section;
     5149+
     5150+      /* Symbol addresses are relative to section vma. */
     5151+      csymp->symbol.value = addr - info->funcsection->vma;
     5152+      csymp->native->u.syment.n_sclass = info->funglobal? C_EXT: C_STAT;
     5153+      /* Create two initial line number entries.  The first one holds
     5154+        the function symbol, the second one is the trailing record
     5155+        that is required by coffgen.c::coff_write_native_symbol() to
     5156+        have a line number of zero. */
     5157+      csymp->lineno = (alent *) xmalloc (2 * sizeof (alent));
     5158+      memset (csymp->lineno, 0, 2 * sizeof (alent));
     5159+      info->nlnos = 2;
     5160+      info->totlnos++;
     5161+      csymp->lineno[0].u.sym = (asymbol *)csymp;
     5162+      coff_record_symbol (info, csymp);
     5163+      info->funcindex = info->nsyms - 1; /* remember for later */
     5164+      /* Record our endndx field for later fixing. */
     5165+      fixp = (struct coff_fix_stack *) xmalloc (sizeof (struct coff_fix_stack));
     5166+      fixp->native = csymp->native + 1;        /* points to first AUX */
     5167+      fixp->next = NULL;
     5168+      if (info->fixes == NULL)
     5169+       info->fixes = fixp;
     5170+      else
     5171+       {
     5172+         for (ofp = info->fixes; ofp->next != NULL;)
     5173+           ofp = ofp->next;
     5174+         ofp->next = fixp;
     5175+       }
     5176+
     5177+      csymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     5178+      if (csymp == NULL)
     5179+       return FALSE;
     5180+
     5181+      csymp->symbol.name = ".bf";
     5182+      csymp->native->u.syment.n_sclass = C_FCN;
     5183+      csymp->native->u.syment.n_numaux = 1;
     5184+      csymp->symbol.value = addr - info->funcsection->vma;
     5185+      csymp->symbol.section = info->funcsection;
     5186+      csymp->symbol.udata.p = NULL;
     5187+      coff_record_symbol (info, csymp);
     5188+    }
     5189+
     5190+  if (info->funname == NULL)
     5191+    return TRUE;
     5192+
     5193+  csymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     5194+  if (csymp == NULL)
     5195+    return FALSE;
     5196+
     5197+  csymp->symbol.name = ".bb";
     5198+  csymp->native->u.syment.n_sclass = C_BLOCK;
     5199+  csymp->native->u.syment.n_numaux = 1;
     5200+  csymp->symbol.value = addr - info->funcsection->vma;
     5201+  csymp->symbol.section = info->funcsection;
     5202+  csymp->symbol.udata.p = NULL;
     5203+  coff_record_symbol (info, csymp);
     5204+
     5205+  info->flags |= COFF_FL_FIX_BB;
     5206+
     5207+  /* Output any pending function parameters, if any. */
     5208+  if (is_start_fcn && info->nfargs)
     5209+    {
     5210+      for (i = 0; i < info->nfargs; i++)
     5211+       coff_record_symbol (info, info->fargs[i]);
     5212+
     5213+      free (info->fargs);
     5214+      info->fargs = NULL;
     5215+      info->nfargs = 0;
     5216+    }
     5217+
     5218+  return TRUE;
     5219+}
     5220+
     5221+/* End a block.  */
     5222+
     5223+static bfd_boolean
     5224+coff_end_block (p, addr)
     5225+     PTR p;
     5226+     bfd_vma addr;
     5227+{
     5228+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     5229+  coff_symbol_type *csymp;
     5230+  union internal_auxent *aux;
     5231+
     5232+#if COFF_DEBUG
     5233+  printf ("coff_end_block(%#x)\n", (int)addr);
     5234+#endif
     5235+
     5236+  if (info->funname == NULL)
     5237+    return TRUE;
     5238+
     5239+  csymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     5240+  if (csymp == NULL)
     5241+    return FALSE;
     5242+
     5243+  csymp->symbol.name = ".eb";
     5244+  csymp->symbol.value = addr - info->funcsection->vma;
     5245+  csymp->native->u.syment.n_sclass = C_BLOCK;
     5246+  csymp->native->u.syment.n_numaux = 1;
     5247+  csymp->symbol.udata.p = NULL;
     5248+  csymp->symbol.section = info->funcsection;
     5249+  aux = &((csymp->native + 1)->u.auxent);
     5250+  aux->x_sym.x_misc.x_lnsz.x_lnno = info->lastlno;
     5251+  coff_record_symbol (info, csymp);
     5252+
     5253+  info->endaddr = addr;
     5254+
     5255+  return TRUE;
     5256+}
     5257+
     5258+/* End a function.  */
     5259+
     5260+static bfd_boolean
     5261+coff_end_function (p)
     5262+     PTR p;
     5263+{
     5264+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     5265+  coff_symbol_type *csymp;
     5266+  union internal_auxent *aux;
     5267+
     5268+#if COFF_DEBUG
     5269+  printf ("coff_end_function()\n");
     5270+#endif
     5271+
     5272+  if (info->funname == NULL)
     5273+    return TRUE;
     5274+
     5275+  csymp = (coff_symbol_type *) coff_bfd_make_debug_symbol (info->abfd, 0, 0);
     5276+  if (csymp == NULL)
     5277+    return FALSE;
     5278+
     5279+  csymp->symbol.name = ".ef";
     5280+  csymp->symbol.value = info->endaddr - info->funcsection->vma;
     5281+  csymp->native->u.syment.n_sclass = C_FCN;
     5282+  csymp->native->u.syment.n_numaux = 1;
     5283+  csymp->symbol.udata.p = NULL;
     5284+  csymp->symbol.section = info->funcsection;
     5285+  aux = &((csymp->native + 1)->u.auxent);
     5286+  aux->x_sym.x_misc.x_lnsz.x_lnno = info->lastlno;
     5287+
     5288+  coff_record_symbol (info, csymp);
     5289+
     5290+  csymp = (coff_symbol_type *) info->syms[info->funcindex];
     5291+  aux = &((csymp->native + 1)->u.auxent);
     5292+  aux->x_sym.x_misc.x_fsize = info->endaddr - csymp->symbol.value;
     5293+
     5294+  info->flags |= COFF_FL_FIX_ENDNDX;
     5295+  info->funname = NULL;
     5296+
     5297+  return TRUE;
     5298+}
     5299+
     5300+/* Output a line number.  */
     5301+
     5302+static bfd_boolean
     5303+coff_lineno (p, file, lineno, addr)
     5304+     PTR p;
     5305+     const char *file ATTRIBUTE_UNUSED;
     5306+     unsigned long lineno;
     5307+     bfd_vma addr;
     5308+{
     5309+  struct coff_write_handle *info = (struct coff_write_handle *) p;
     5310+  coff_symbol_type *csymp;
     5311+  union internal_auxent *aux;
     5312+  long i;
     5313+
     5314+#if COFF_DEBUG
     5315+  printf ("coff_lineno(%s, %ld, %d)\n",
     5316+         file, lineno, (int)addr);
     5317+#endif
     5318+
     5319+  /* COFF can inherently only handle line numbers inside of functions.
     5320+     If we are not inside a function, punt. */
     5321+  if (info->funname == NULL)
     5322+    return TRUE;
     5323+
     5324+  if (info->nlnos == 2)
     5325+    {
     5326+      /* This is the first line number of this function.  Fix the line
     5327+        number for the .bf symbol immediately following the start of
     5328+        function.  We also have to remember the starting line number
     5329+        of our function since all line number entries are relative to
     5330+        it in COFF.  Since regular line numbers must always be
     5331+        non-zero, we artificially force the function to start one
     5332+        line earlier. */
     5333+      csymp = (coff_symbol_type *) info->syms[info->funcindex + 1];
     5334+      aux = &((csymp->native + 1)->u.auxent);
     5335+      aux->x_sym.x_misc.x_lnsz.x_lnno = lineno;
     5336+      info->funlno = lineno - 1;
     5337+    }
     5338+
     5339+  if (info->flags & COFF_FL_FIX_BB)
     5340+    {
     5341+      /* This is the first line number after one (or more) .bb
     5342+        symbols.  Fix them.  In order to cope with multiple blocks
     5343+        starting at the same line number, we walk back the list of
     5344+        symbols until we find a C_BLOCK one that had already been
     5345+        fixed, or until we find a C_FCN symbol (presumably, the start
     5346+        of our current function). */
     5347+      info->flags &= ~COFF_FL_FIX_BB;
     5348+
     5349+      for (i = info->nsyms - 1; i >= 0; i--)
     5350+       {
     5351+         csymp = (coff_symbol_type *) info->syms[i];
     5352+         if (csymp->native->u.syment.n_sclass == C_FCN)
     5353+           break;
     5354+         if (csymp->native->u.syment.n_sclass == C_BLOCK)
     5355+           {
     5356+             aux = &((csymp->native + 1)->u.auxent);
     5357+             if (aux->x_sym.x_misc.x_lnsz.x_lnno != 0)
     5358+               /* already set up properly */
     5359+               break;
     5360+             aux->x_sym.x_misc.x_lnsz.x_lnno = lineno;
     5361+           }
     5362+       }
     5363+    }
     5364+
     5365+  csymp = (coff_symbol_type *) info->syms[info->funcindex];
     5366+  csymp->lineno = (alent *) xrealloc (csymp->lineno,
     5367+                                     ++info->nlnos * sizeof (alent));
     5368+  memset (csymp->lineno + info->nlnos - 1, 0, sizeof (alent));
     5369+  if (lineno > info->funlno)
     5370+    csymp->lineno[info->nlnos - 2].line_number = lineno - info->funlno;
     5371+  else
     5372+    /* Line number unreasonable.  Can e. g. happen for a line number
     5373+       from an include file, which we cannot process in COFF.  Just
     5374+       set it to the first line, to avoid generating a large unsigned
     5375+       short (~ 65000) line number. */
     5376+    csymp->lineno[info->nlnos - 2].line_number = 1;
     5377+  csymp->lineno[info->nlnos - 2].u.offset = addr;
     5378+
     5379+  info->lastlno = lineno;
     5380+  info->totlnos++;
     5381+
     5382+  return TRUE;
     5383+}
     5384diff -Nruw include/coff/avr.h include/coff/avr.h
     5385--- include/coff/avr.h  1970-01-01 05:30:00.000000000 +0530
     5386+++ include/coff/avr.h  2010-02-10 17:35:58.362724600 +0530
     5387@@ -0,0 +1,110 @@
     5388+/* coff information for Atmel AVR.
     5389+   
     5390+   Copyright 2001 Free Software Foundation, Inc.
     5391+
     5392+   This program is free software; you can redistribute it and/or modify
     5393+   it under the terms of the GNU General Public License as published by
     5394+   the Free Software Foundation; either version 2 of the License, or
     5395+   (at your option) any later version.
     5396+   
     5397+   This program is distributed in the hope that it will be useful,
     5398+   but WITHOUT ANY WARRANTY; without even the implied warranty of
     5399+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     5400+   GNU General Public License for more details.
     5401+   
     5402+   You should have received a copy of the GNU General Public License
     5403+   along with this program; if not, write to the Free Software
     5404+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
     5405+
     5406+/* This file was hacked from i860.h */
     5407+
     5408+#define L_LNNO_SIZE 2
     5409+#include "coff/external.h"
     5410+
     5411+/* Bits for f_flags:
     5412+       F_RELFLG        relocation info stripped from file
     5413+       F_EXEC          file is executable (no unresolved external references)
     5414+       F_LNNO          line numbers stripped from file
     5415+       F_LSYMS         local symbols stripped from file  */
     5416+
     5417+#define F_RELFLG       (0x0001)
     5418+#define F_EXEC         (0x0002)
     5419+#define F_LNNO         (0x0004)
     5420+#define F_LSYMS                (0x0008)
     5421+/* Upper nibble of flags always needs to be set.  This used to be
     5422+ * undocumented, recent information from Atmel says that bit 7 used to
     5423+ * differentiate between an old vendor-specific deviation of the
     5424+ * format and the current format. */
     5425+#define F_JUNK         (0x00f0)
     5426+#define F_UNUSED       (0xff00)
     5427+
     5428+#define        AVRMAGIC        0xa12
     5429+
     5430+#undef AOUTSZ
     5431+#ifdef AVR_EXT_COFF
     5432+
     5433+/* AVR "extended" COFF format.  This uses the optional header ("a.out"
     5434+   header) to inform the consumer about some additional features that
     5435+   are supported. */
     5436+#define COFF_LONG_FILENAMES yes        /* long filenames supported in consecutive aux entries */
     5437+#define AOUTSZ         28      /* size of optional header in "extended" COFF */
     5438+
     5439+/* Flags in the optional header; they are stored in the vstamp field. */
     5440+#define F_FULLPATHS    0x0001  /* long filenames supported */
     5441+#define F_STRUCTINFO   0x0002  /* structure information contained */
     5442+#define F_PTRINFO      0x0004  /* inter-segment pointers supported */
     5443+
     5444+#else /* old AVR COFF */
     5445+
     5446+#define AOUTSZ         0       /* no a.out for AVR */
     5447+#endif
     5448+
     5449+/* #define AVRAOUTMAGIC        0x406 */ /* "general" magic number of optional header */
     5450+/*
     5451+ * The following magic number causes AVR Studio 4.x to recognize
     5452+ * avr-gcc/GNU binutils produced AVR extended COFF files.  By now,
     5453+ * the only special treatment for them is that the contents of .data
     5454+ * will be appended after .text in the simulator flash.
     5455+ *
     5456+ * 0x9cc has been chosen since it resembles "gcc". ;-)
     5457+ */
     5458+#define AVRAOUTMAGIC   0x9cc   /* "gcc" magic number */
     5459+
     5460+/* By matching not only the magic number, but also the size of the
     5461+   optional a.out header, we can differentiate between both
     5462+   formats. */
     5463+#define AVRBADMAG(x)   ((x).f_magic != AVRMAGIC || (x).f_opthdr != AOUTSZ)
     5464+
     5465+/* AVR COFF has several anomalities in the way the handle the derived
     5466+   type information, and AUX entries, mainly because they apparently
     5467+   didn't bother to learn how COFF is supposed to work before they
     5468+   started.  We fix many of them at the export/import boundary, so all
     5469+   the internal generic COFF handling will work mostly as designed. */
     5470+
     5471+/* NB: these functions are only defined in bfd/coff-avr.c, but also
     5472+   used in coff-ext-avr.c, so the latter can only be configured if the
     5473+   former is also present.  This is certainly always the case
     5474+   anyway. */
     5475+extern void avr_coff_adjust_sym_in_post
     5476+  PARAMS((bfd *, PTR, PTR));
     5477+
     5478+extern void avr_coff_adjust_sym_out_post
     5479+  PARAMS((bfd *, PTR, PTR));
     5480+
     5481+#define COFF_ADJUST_SYM_IN_POST(ABFD, EXT, INT) \
     5482+       avr_coff_adjust_sym_in_post (ABFD, EXT, INT)
     5483+
     5484+#define COFF_ADJUST_SYM_OUT_POST(ABFD, INT, EXT) \
     5485+       avr_coff_adjust_sym_out_post (ABFD, INT, EXT)
     5486+
     5487+/********************** RELOCATION DIRECTIVES **********************/
     5488+
     5489+struct external_reloc
     5490+{
     5491+  char r_vaddr[4];
     5492+  char r_symndx[4];
     5493+  char r_type[2];
     5494+};
     5495+
     5496+#define RELOC struct external_reloc
     5497+#define RELSZ 10
     5498diff -Nruw include/coff/internal.h include/coff/internal.h
     5499--- include/coff/internal.h     2009-09-02 12:51:39.000000000 +0530
     5500+++ include/coff/internal.h     2010-02-10 17:35:58.378349600 +0530
     5501@@ -646,6 +646,8 @@
     5502 
     5503 };
     5504 
     5505+#define NAUXENTS 10            /* number of pre-allocated aux entries */
  • files/patch-newdevices

    ++
    + /********************** RELOCATION DIRECTIVES **********************/
    + 
    + struct internal_reloc
    diff -ruN avr-binutils.orig/files/patch-newdevices avr-binutils/files/patch-newdevices
    old new  
     1diff -ruw ggas/config/tc-avr.c gas/config/tc-avr.c
     2--- ggas/config/tc-avr.c        2009-09-09 13:43:29.000000000 +0530
     3+++ gas/config/tc-avr.c 2010-02-12 20:42:30.742688700 +0530
     4@@ -133,9 +133,12 @@
     5   {"atmega32u2", AVR_ISA_AVR35,   bfd_mach_avr35},
     6   {"atmega8",    AVR_ISA_M8,      bfd_mach_avr4},
     7   {"atmega48",   AVR_ISA_AVR4,    bfd_mach_avr4},
     8+  {"atmega48a",  AVR_ISA_AVR4,    bfd_mach_avr4},
     9   {"atmega48p",  AVR_ISA_AVR4,    bfd_mach_avr4},
     10   {"atmega88",   AVR_ISA_AVR4,    bfd_mach_avr4},
     11+  {"atmega88a",  AVR_ISA_AVR4,    bfd_mach_avr4},
     12   {"atmega88p",  AVR_ISA_AVR4,    bfd_mach_avr4},
     13+  {"atmega88pa", AVR_ISA_AVR4,    bfd_mach_avr4},
     14   {"atmega8515", AVR_ISA_M8,      bfd_mach_avr4},
     15   {"atmega8535", AVR_ISA_M8,      bfd_mach_avr4},
     16   {"atmega8hva", AVR_ISA_AVR4,    bfd_mach_avr4},
     17@@ -150,40 +153,63 @@
     18   {"at90pwm3b",  AVR_ISA_AVR4,    bfd_mach_avr4},
     19   {"at90pwm81",  AVR_ISA_AVR4,    bfd_mach_avr4},
     20   {"atmega16",   AVR_ISA_AVR5,    bfd_mach_avr5},
     21+  {"atmega16a",  AVR_ISA_AVR5,    bfd_mach_avr5},
     22   {"atmega161",  AVR_ISA_M161,    bfd_mach_avr5},
     23   {"atmega162",  AVR_ISA_AVR5,    bfd_mach_avr5},
     24   {"atmega163",  AVR_ISA_M161,    bfd_mach_avr5},
     25+  {"atmega164a", AVR_ISA_AVR5,    bfd_mach_avr5},
     26   {"atmega164p", AVR_ISA_AVR5,    bfd_mach_avr5},
     27   {"atmega165",  AVR_ISA_AVR5,    bfd_mach_avr5},
     28   {"atmega165p", AVR_ISA_AVR5,    bfd_mach_avr5},
     29   {"atmega168",  AVR_ISA_AVR5,    bfd_mach_avr5},
     30+  {"atmega168a", AVR_ISA_AVR5,    bfd_mach_avr5},
     31   {"atmega168p", AVR_ISA_AVR5,    bfd_mach_avr5},
     32   {"atmega169",  AVR_ISA_AVR5,    bfd_mach_avr5},
     33+  {"atmega169a", AVR_ISA_AVR5,    bfd_mach_avr5},
     34   {"atmega169p", AVR_ISA_AVR5,    bfd_mach_avr5},
     35+  {"atmega169pa",AVR_ISA_AVR5,    bfd_mach_avr5},
     36+  {"atmega16hva",AVR_ISA_AVR5,    bfd_mach_avr5},
     37+  {"atmega16hvb",AVR_ISA_AVR5,    bfd_mach_avr5},
     38   {"atmega16c1", AVR_ISA_AVR5,    bfd_mach_avr5},
     39   {"atmega32",   AVR_ISA_AVR5,    bfd_mach_avr5},
     40   {"atmega323",  AVR_ISA_AVR5,    bfd_mach_avr5},
     41+  {"atmega324a", AVR_ISA_AVR5,    bfd_mach_avr5},
     42   {"atmega324p", AVR_ISA_AVR5,    bfd_mach_avr5},
     43+  {"atmega324pa",AVR_ISA_AVR5,    bfd_mach_avr5},
     44   {"atmega325",  AVR_ISA_AVR5,    bfd_mach_avr5},
     45   {"atmega325p", AVR_ISA_AVR5,    bfd_mach_avr5},
     46   {"atmega3250", AVR_ISA_AVR5,    bfd_mach_avr5},
     47   {"atmega3250p",AVR_ISA_AVR5,    bfd_mach_avr5},
     48+  {"atmega328",  AVR_ISA_AVR5,    bfd_mach_avr5},
     49   {"atmega328p", AVR_ISA_AVR5,    bfd_mach_avr5},
     50   {"atmega329",  AVR_ISA_AVR5,    bfd_mach_avr5},
     51   {"atmega329p", AVR_ISA_AVR5,    bfd_mach_avr5},
     52+  {"atmega329pa",AVR_ISA_AVR5,    bfd_mach_avr5},
     53   {"atmega3290", AVR_ISA_AVR5,    bfd_mach_avr5},
     54   {"atmega3290p",AVR_ISA_AVR5,    bfd_mach_avr5},
     55+  {"atmega32hvb",AVR_ISA_AVR5,    bfd_mach_avr5},
     56   {"atmega406",  AVR_ISA_AVR5,    bfd_mach_avr5},
     57   {"atmega64",   AVR_ISA_AVR5,    bfd_mach_avr5},
     58   {"atmega640",  AVR_ISA_AVR5,    bfd_mach_avr5},
     59   {"atmega644",  AVR_ISA_AVR5,    bfd_mach_avr5},
     60+  {"atmega644a", AVR_ISA_AVR5,    bfd_mach_avr5},
     61   {"atmega644p", AVR_ISA_AVR5,    bfd_mach_avr5},
     62   {"atmega644pa",AVR_ISA_AVR5,    bfd_mach_avr5},
     63   {"atmega645",  AVR_ISA_AVR5,    bfd_mach_avr5},
     64+  {"atmega645a", AVR_ISA_AVR5,    bfd_mach_avr5},
     65+  {"atmega645p", AVR_ISA_AVR5,    bfd_mach_avr5},
     66   {"atmega649",  AVR_ISA_AVR5,    bfd_mach_avr5},
     67+  {"atmega649p", AVR_ISA_AVR5,    bfd_mach_avr5},
     68+  {"atmega649a", AVR_ISA_AVR5,    bfd_mach_avr5},
     69   {"atmega6450", AVR_ISA_AVR5,    bfd_mach_avr5},
     70+  {"atmega6450a",AVR_ISA_AVR5,    bfd_mach_avr5},
     71+  {"atmega6450p",AVR_ISA_AVR5,    bfd_mach_avr5},
     72   {"atmega6490", AVR_ISA_AVR5,    bfd_mach_avr5},
     73+  {"atmega6490a",AVR_ISA_AVR5,    bfd_mach_avr5},
     74+  {"atmega6490p",AVR_ISA_AVR5,    bfd_mach_avr5},
     75+  {"atmega64hve",AVR_ISA_AVR5,    bfd_mach_avr5},
     76   {"atmega16hva",AVR_ISA_AVR5,    bfd_mach_avr5},
     77+  {"atmega16hva2",AVR_ISA_AVR5,    bfd_mach_avr5},
     78   {"atmega16hvb",AVR_ISA_AVR5,    bfd_mach_avr5},
     79   {"atmega32hvb",AVR_ISA_AVR5,    bfd_mach_avr5},
     80   {"at90can32" , AVR_ISA_AVR5,    bfd_mach_avr5},
     81diff -ruw ggas/doc/c-avr.texi gas/doc/c-avr.texi
     82--- ggas/doc/c-avr.texi 2009-09-02 12:54:21.000000000 +0530
     83+++ gas/doc/c-avr.texi  2010-02-12 21:31:02.132717100 +0530
     84@@ -43,9 +43,10 @@
     85 
     86 Instruction set avr25 is for the classic AVR core with up to 8K program memory
     87 space plus the MOVW instruction (MCU types: attiny13, attiny13a, attiny2313,
     88-attiny2313a, attiny24, attiny24a, attiny4313, attiny44, attiny44a, attiny84,
     89-attiny25, attiny45, attiny85, attiny261, attiny261a, attiny461, attiny861,
     90-attiny861a, attiny87, attiny43u, attiny48, attiny88, at86rf401, ata6289).
     91+attiny2313a, attiny24, attiny24a, attiny4313, attiny43u, attiny44, attiny44a,
     92+attiny84, attiny25, attiny45, attiny85, attiny261, attiny261a, attiny461,
     93+attiny461a, attiny861, attiny861a, attiny87, attiny43u, attiny48, attiny88,
     94+at86rf401, ata6289).
     95 
     96 Instruction set avr3 is for the classic AVR core with up to 128K program
     97 memory space (MCU types: at43usb355, at76c711).
     98@@ -58,20 +59,25 @@
     99 atmega16u2, atmega32u2).
     100 
     101 Instruction set avr4 is for the enhanced AVR core with up to 8K program
     102-memory space (MCU types: atmega48, atmega48p,atmega8, atmega88, atmega88p,
     103-atmega8515, atmega8535, atmega8hva, atmega4hvd, atmega8hvd, at90pwm1,
     104-at90pwm2, at90pwm2b, at90pwm3, at90pwm3b, at90pwm81, atmega8m1, atmega8c1).
     105+memory space (MCU types: atmega48, atmega48a, atmega48p,atmega8, atmega88,
     106+atmega88a, atmega88p, atmega88pa, atmega8515, atmega8535, atmega8hva,
     107+atmega4hvd, atmega8hvd, at90pwm1,at90pwm2, at90pwm2b, at90pwm3, at90pwm3b,
     108+at90pwm81, atmega8m1, atmega8c1).
     109 
     110 Instruction set avr5 is for the enhanced AVR core with up to 128K program
     111-memory space (MCU types: atmega16, atmega161, atmega162, atmega163, atmega164p,
     112-atmega165, atmega165p, atmega168, atmega168p, atmega169, atmega169p, atmega16c1,
     113-atmega32, atmega323, atmega324p, atmega325, atmega325p, atmega3250, atmega3250p,
     114-atmega328p, atmega329, atmega329p, atmega3290, atmega3290p, atmega406, atmega64,
     115-atmega640, atmega644, atmega644p, atmega644pa, atmega645, atmega6450, atmega649,
     116-atmega6490, atmega16hva, atmega16hvb, atmega32hvb, at90can32, at90can64,
     117-at90pwm216, at90pwm316, atmega32c1, atmega64c1, atmega16m1, atmega32m1,
     118-atmega64m1, atmega16u4, atmega32u4, atmega32u6, at90usb646, at90usb647, at94k,
     119-at90scr100).
     120+memory space (MCU types: atmega16, atmega16a, atmega161, atmega162, atmega163,
     121+atmega164a, atmega164p, atmega165, atmega165a, atmega165p, atmega168,
     122+atmega168a, atmega168p, atmega169, atmega169p, atmega169pa, atmega16c1,
     123+atmega32, atmega323, atmega324a, atmega324p, atmega324pa, atmega325,
     124+atmega325p, atmega3250, atmega3250p, atmega328, atmega328p, atmega329,
     125+atmega329p, atmega329pa, atmega3290, atmega3290p, atmega406, atmega64,
     126+atmega640, atmega644, atmega644a, atmega644p, atmega644pa, atmega645,
     127+atmega645a, atmega645p, atmega6450, atmega6450a, atmega6450p, atmega649,
     128+atmega649a, atmega649p, atmega6490, atmega6490a, atmega6490p, atmega64hve,
     129+atmega16hva, atmega16hva2, atmega16hvb, atmega32hvb, at90can32, at90can64,
     130+at90pwm216, at90pwm316, atmega16u4, atmega32c1, atmega64c1, atmega64m1,
     131+atmega16m1, atmega32m1, atmega64m1, atmega16u4, atmega32u4, atmega32u6,
     132+at90usb646, at90usb647, at94k, at90scr100).
     133 
     134 Instruction set avr51 is for the enhanced AVR core with exactly 128K program
     135 memory space (MCU types: atmega128, atmega1280, atmega1281, atmega1284p,
  • files/patch-newsections

    diff -ruN avr-binutils.orig/files/patch-newsections avr-binutils/files/patch-newsections
    old new  
     1diff -ruw ld/scripttempl/avr.sc ld/scripttempl/avr.sc
     2--- ld/scripttempl/avr.sc       2009-10-09 18:42:35.000000000 +0530
     3+++ ld/scripttempl/avr.sc       2010-02-12 20:09:24.070812400 +0530
     4@@ -7,6 +7,9 @@
     5   text   (rx)   : ORIGIN = 0, LENGTH = $TEXT_LENGTH
     6   data   (rw!x) : ORIGIN = $DATA_ORIGIN, LENGTH = $DATA_LENGTH
     7   eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 64K
     8+  fuse      (rw!x) : ORIGIN = 0x820000, LENGTH = 1K
     9+  lock      (rw!x) : ORIGIN = 0x830000, LENGTH = 1K
     10+  signature (rw!x) : ORIGIN = 0x840000, LENGTH = 1K
     11 }
     12 
     13 SECTIONS
     14@@ -196,6 +199,24 @@
     15     ${RELOCATING+ __eeprom_end = . ; }
     16   } ${RELOCATING+ > eeprom}
     17 
     18+  .fuse ${RELOCATING-0}:
     19+  {
     20+    KEEP(*(.fuse))
     21+    KEEP(*(.lfuse))
     22+    KEEP(*(.hfuse))
     23+    KEEP(*(.efuse))
     24+  } ${RELOCATING+ > fuse}
     25+
     26+  .lock ${RELOCATING-0}:
     27+  {
     28+    KEEP(*(.lock*))
     29+  } ${RELOCATING+ > lock}
     30+
     31+  .signature ${RELOCATING-0}:
     32+  {
     33+    KEEP(*(.signature*))
     34+  } ${RELOCATING+ > signature}
     35+
     36   /* Stabs debugging sections.  */
     37   .stab 0 : { *(.stab) }
     38   .stabstr 0 : { *(.stabstr) }
  • files/patch-xmega

    diff -ruN avr-binutils.orig/files/patch-xmega avr-binutils/files/patch-xmega
    old new  
     1diff -Nur ../binutils-2.20.orig/bfd/archures.c ./bfd/archures.c
     2--- ../binutils-2.20.orig/bfd/archures.c        2009-09-10 13:47:11.000000000 +0200
     3+++ ./bfd/archures.c    2010-03-04 11:34:08.000000000 +0100
     4@@ -368,6 +368,13 @@
     5 .#define bfd_mach_avr5         5
     6 .#define bfd_mach_avr51                51
     7 .#define bfd_mach_avr6         6
     8+.#define bfd_mach_avrxmega1 101
     9+.#define bfd_mach_avrxmega2 102
     10+.#define bfd_mach_avrxmega3 103
     11+.#define bfd_mach_avrxmega4 104
     12+.#define bfd_mach_avrxmega5 105
     13+.#define bfd_mach_avrxmega6 106
     14+.#define bfd_mach_avrxmega7 107
     15 .  bfd_arch_bfin,        {* ADI Blackfin *}
     16 .#define bfd_mach_bfin          1
     17 .  bfd_arch_cr16,       {* National Semiconductor CompactRISC (ie CR16). *}
     18diff -Nur ../binutils-2.20.orig/bfd/bfd-in2.h ./bfd/bfd-in2.h
     19--- ../binutils-2.20.orig/bfd/bfd-in2.h 2009-09-10 13:47:11.000000000 +0200
     20+++ ./bfd/bfd-in2.h     2010-03-04 11:34:08.000000000 +0100
     21@@ -2035,6 +2035,13 @@
     22 #define bfd_mach_avr5          5
     23 #define bfd_mach_avr51         51
     24 #define bfd_mach_avr6          6
     25+#define bfd_mach_avrxmega1 101
     26+#define bfd_mach_avrxmega2 102
     27+#define bfd_mach_avrxmega3 103
     28+#define bfd_mach_avrxmega4 104
     29+#define bfd_mach_avrxmega5 105
     30+#define bfd_mach_avrxmega6 106
     31+#define bfd_mach_avrxmega7 107
     32   bfd_arch_bfin,        /* ADI Blackfin */
     33 #define bfd_mach_bfin          1
     34   bfd_arch_cr16,       /* National Semiconductor CompactRISC (ie CR16). */
     35diff -Nur ../binutils-2.20.orig/bfd/cpu-avr.c ./bfd/cpu-avr.c
     36--- ../binutils-2.20.orig/bfd/cpu-avr.c 2009-09-02 09:18:36.000000000 +0200
     37+++ ./bfd/cpu-avr.c     2010-03-04 11:34:08.000000000 +0100
     38@@ -133,7 +133,29 @@
     39   N (22, bfd_mach_avr51, "avr:51", FALSE, & arch_info_struct[9]),
     40 
     41   /* 3-Byte PC.  */
     42-  N (22, bfd_mach_avr6, "avr:6", FALSE, NULL)
     43+  N (22, bfd_mach_avr6, "avr:6", FALSE, & arch_info_struct[10]),
     44
     45+  /* Xmega 1 */
     46+  N (24, bfd_mach_avrxmega1, "avr:101", FALSE, & arch_info_struct[11]),
     47+
     48+  /* Xmega 2 */
     49+  N (24, bfd_mach_avrxmega2, "avr:102", FALSE, & arch_info_struct[12]),
     50
     51+  /* Xmega 3 */
     52+  N (24, bfd_mach_avrxmega3, "avr:103", FALSE, & arch_info_struct[13]),
     53
     54+  /* Xmega 4 */
     55+  N (24, bfd_mach_avrxmega4, "avr:104", FALSE, & arch_info_struct[14]),
     56
     57+  /* Xmega 5 */
     58+  N (24, bfd_mach_avrxmega5, "avr:105", FALSE, & arch_info_struct[15]),
     59
     60+  /* Xmega 6 */
     61+  N (24, bfd_mach_avrxmega6, "avr:106", FALSE, & arch_info_struct[16]),
     62
     63+  /* Xmega 7 */
     64+  N (24, bfd_mach_avrxmega7, "avr:107", FALSE, NULL)
     65
     66 };
     67 
     68 const bfd_arch_info_type bfd_avr_arch =
     69diff -Nur ../binutils-2.20.orig/bfd/elf32-avr.c ./bfd/elf32-avr.c
     70--- ../binutils-2.20.orig/bfd/elf32-avr.c       2009-09-02 09:18:36.000000000 +0200
     71+++ ./bfd/elf32-avr.c   2010-03-04 11:34:08.000000000 +0100
     72@@ -1328,6 +1328,34 @@
     73     case bfd_mach_avr6:
     74       val = E_AVR_MACH_AVR6;
     75       break;
     76+
     77+    case bfd_mach_avrxmega1:
     78+      val = E_AVR_MACH_XMEGA1;
     79+      break;
     80+
     81+    case bfd_mach_avrxmega2:
     82+      val = E_AVR_MACH_XMEGA2;
     83+      break;
     84+
     85+    case bfd_mach_avrxmega3:
     86+      val = E_AVR_MACH_XMEGA3;
     87+      break;
     88+
     89+    case bfd_mach_avrxmega4:
     90+      val = E_AVR_MACH_XMEGA4;
     91+      break;
     92+
     93+    case bfd_mach_avrxmega5:
     94+      val = E_AVR_MACH_XMEGA5;
     95+      break;
     96+
     97+    case bfd_mach_avrxmega6:
     98+      val = E_AVR_MACH_XMEGA6;
     99+      break;
     100+
     101+    case bfd_mach_avrxmega7:
     102+      val = E_AVR_MACH_XMEGA7;
     103+      break;
     104     }
     105 
     106   elf_elfheader (abfd)->e_machine = EM_AVR;
     107@@ -1390,6 +1418,34 @@
     108        case E_AVR_MACH_AVR6:
     109          e_set = bfd_mach_avr6;
     110          break;
     111+
     112+       case E_AVR_MACH_XMEGA1:
     113+         e_set = bfd_mach_avrxmega1;
     114+         break;
     115+
     116+       case E_AVR_MACH_XMEGA2:
     117+         e_set = bfd_mach_avrxmega2;
     118+         break;
     119+
     120+       case E_AVR_MACH_XMEGA3:
     121+         e_set = bfd_mach_avrxmega3;
     122+         break;
     123+
     124+       case E_AVR_MACH_XMEGA4:
     125+         e_set = bfd_mach_avrxmega4;
     126+         break;
     127+
     128+       case E_AVR_MACH_XMEGA5:
     129+         e_set = bfd_mach_avrxmega5;
     130+         break;
     131+
     132+       case E_AVR_MACH_XMEGA6:
     133+         e_set = bfd_mach_avrxmega6;
     134+         break;
     135+
     136+       case E_AVR_MACH_XMEGA7:
     137+         e_set = bfd_mach_avrxmega7;
     138+         break;
     139        }
     140     }
     141   return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
     142diff -Nur ../binutils-2.20.orig/gas/config/tc-avr.c ./gas/config/tc-avr.c
     143--- ../binutils-2.20.orig/gas/config/tc-avr.c   2010-03-04 11:19:26.000000000 +0100
     144+++ ./gas/config/tc-avr.c       2010-03-04 11:34:09.000000000 +0100
     145@@ -27,20 +27,21 @@
     146 
     147 struct avr_opcodes_s
     148 {
     149-  char *        name;
     150-  char *        constraints;
     151-  int           insn_size;             /* In words.  */
     152-  int           isa;
     153+  char *name;
     154+  char *constraints;
     155+  char *opcode;
     156+  int insn_size;               /* In words.  */
     157+  int isa;
     158   unsigned int  bin_opcode;
     159 };
     160 
     161 #define AVR_INSN(NAME, CONSTR, OPCODE, SIZE, ISA, BIN) \
     162-{#NAME, CONSTR, SIZE, ISA, BIN},
     163+{#NAME, CONSTR, OPCODE, SIZE, ISA, BIN},
     164 
     165 struct avr_opcodes_s avr_opcodes[] =
     166 {
     167   #include "opcode/avr.h"
     168-  {NULL, NULL, 0, 0, 0}
     169+  {NULL, NULL, NULL, 0, 0, 0}
     170 };
     171 
     172 const char comment_chars[] = ";";
     173@@ -79,6 +80,13 @@
     174   {"avr5",       AVR_ISA_AVR51,   bfd_mach_avr5},
     175   {"avr51",      AVR_ISA_AVR51,   bfd_mach_avr51},
     176   {"avr6",       AVR_ISA_AVR6,    bfd_mach_avr6},
     177+  {"avrxmega1",  AVR_ISA_XMEGA,   bfd_mach_avrxmega1},
     178+  {"avrxmega2",  AVR_ISA_XMEGA,   bfd_mach_avrxmega2},
     179+  {"avrxmega3",  AVR_ISA_XMEGA,   bfd_mach_avrxmega3},
     180+  {"avrxmega4",  AVR_ISA_XMEGA,   bfd_mach_avrxmega4},
     181+  {"avrxmega5",  AVR_ISA_XMEGA,   bfd_mach_avrxmega5},
     182+  {"avrxmega6",  AVR_ISA_XMEGA,   bfd_mach_avrxmega6},
     183+  {"avrxmega7",  AVR_ISA_XMEGA,   bfd_mach_avrxmega7},
     184   {"at90s1200",  AVR_ISA_1200,    bfd_mach_avr1},
     185   {"attiny11",   AVR_ISA_AVR1,    bfd_mach_avr1},
     186   {"attiny12",   AVR_ISA_AVR1,    bfd_mach_avr1},
     187@@ -241,6 +249,21 @@
     188   {"m3001b",     AVR_ISA_AVR51,   bfd_mach_avr51},
     189   {"atmega2560", AVR_ISA_AVR6,    bfd_mach_avr6},
     190   {"atmega2561", AVR_ISA_AVR6,    bfd_mach_avr6},
     191+  {"atxmega16a4", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
     192+  {"atxmega16d4", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
     193+  {"atxmega32d4", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
     194+  {"atxmega32a4", AVR_ISA_XMEGA,  bfd_mach_avrxmega3},
     195+  {"atxmega64a3", AVR_ISA_XMEGA,  bfd_mach_avrxmega4},
     196+  {"atxmega64d3", AVR_ISA_XMEGA,  bfd_mach_avrxmega4},
     197+  {"atxmega64a1", AVR_ISA_XMEGA,  bfd_mach_avrxmega5},
     198+  {"atxmega128a3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
     199+  {"atxmega128d3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
     200+  {"atxmega192a3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
     201+  {"atxmega192d3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
     202+  {"atxmega256a3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
     203+  {"atxmega256a3b",AVR_ISA_XMEGA, bfd_mach_avrxmega6},
     204+  {"atxmega256d3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
     205+  {"atxmega128a1", AVR_ISA_XMEGA, bfd_mach_avrxmega7},
     206   {NULL, 0, 0}
     207 };
     208 
     209@@ -418,6 +441,11 @@
     210        "                   avr5  - enhanced AVR core with up to 64K program memory\n"
     211        "                   avr51 - enhanced AVR core with up to 128K program memory\n"
     212        "                   avr6  - enhanced AVR core with up to 256K program memory\n"
     213+       "                   avrxmega3 - XMEGA, > 8K, <= 64K FLASH, > 64K RAM\n"
     214+       "                   avrxmega4 - XMEGA, > 64K, <= 128K FLASH, <= 64K RAM\n"
     215+       "                   avrxmega5 - XMEGA, > 64K, <= 128K FLASH, > 64K RAM\n"
     216+       "                   avrxmega6 - XMEGA, > 128K, <= 256K FLASH, <= 64K RAM\n"
     217+       "                   avrxmega7 - XMEGA, > 128K, <= 256K FLASH, > 64K RAM\n"
     218        "                   or immediate microcontroller name.\n"));
     219   fprintf (stream,
     220       _("  -mall-opcodes    accept all AVR opcodes, even if not supported by MCU\n"
     221@@ -845,7 +873,12 @@
     222       if (*str == '+')
     223        {
     224          ++str;
     225-         op_mask |= 1;
     226+          char *s;
     227+          for (s = opcode->opcode; *s; ++s)
     228+            {
     229+              if (*s == '+')
     230+                op_mask |= (1 << (15 - (s - opcode->opcode)));
     231+            }
     232        }
     233 
     234       /* attiny26 can do "lpm" and "lpm r,Z" but not "lpm r,Z+".  */
     235@@ -962,6 +995,16 @@
     236       }
     237       break;
     238 
     239+    case 'E':
     240+      {
     241+       unsigned int x;
     242+
     243+       x = avr_get_constant (str, 15);
     244+       str = input_line_pointer;
     245+       op_mask |= (x << 4);
     246+      }
     247+      break;
     248+   
     249     case '?':
     250       break;
     251 
     252diff -Nur ../binutils-2.20.orig/gas/doc/c-avr.texi ./gas/doc/c-avr.texi
     253--- ../binutils-2.20.orig/gas/doc/c-avr.texi    2010-03-04 11:19:26.000000000 +0100
     254+++ ./gas/doc/c-avr.texi        2010-03-04 11:34:09.000000000 +0100
     255@@ -86,6 +86,27 @@
     256 Instruction set avr6 is for the enhanced AVR core with a 3-byte PC (MCU types:
     257 atmega2560, atmega2561).
     258 
     259+Instruction set avrxmega2 is for the XMEGA AVR core with 8K to 64K program
     260+memory space and less than 64K data space (MCU types: atxmega16a4, atxmega16d4,
     261+atxmega32d4).
     262+
     263+Instruction set avrxmega3 is for the XMEGA AVR core with 8K to 64K program
     264+memory space and greater than 64K data space (MCU types: atxmega32a4).
     265+
     266+Instruction set avrxmega4 is for the XMEGA AVR core with up to 64K program
     267+memory space and less than 64K data space (MCU types: atxmega64a3, atxmega64d3).
     268+
     269+Instruction set avrxmega5 is for the XMEGA AVR core with up to 64K program
     270+memory space and greater than 64K data space (MCU types: atxmega64a1).
     271+
     272+Instruction set avrxmega6 is for the XMEGA AVR core with up to 256K program
     273+memory space and less than 64K data space (MCU types: atxmega128a3,
     274+atxmega128d3, atxmega192a3, atxmega192d3, atxmega256a3, atxmega256a3b,
     275+atxmega192d3).
     276+
     277+Instruction set avrxmega7 is for the XMEGA AVR core with up to 256K program
     278+memory space and greater than 64K data space (MCU types: atxmega128a1).
     279+
     280 @cindex @code{-mall-opcodes} command line option, AVR
     281 @item -mall-opcodes
     282 Accept all AVR opcodes, even if not supported by @code{-mmcu}.
     283diff -Nur ../binutils-2.20.orig/include/elf/avr.h ./include/elf/avr.h
     284--- ../binutils-2.20.orig/include/elf/avr.h     2008-08-09 07:35:13.000000000 +0200
     285+++ ./include/elf/avr.h 2010-03-04 11:34:09.000000000 +0100
     286@@ -40,6 +40,13 @@
     287 #define E_AVR_MACH_AVR5 5
     288 #define E_AVR_MACH_AVR51 51
     289 #define E_AVR_MACH_AVR6 6
     290+#define E_AVR_MACH_XMEGA1 101
     291+#define E_AVR_MACH_XMEGA2 102
     292+#define E_AVR_MACH_XMEGA3 103
     293+#define E_AVR_MACH_XMEGA4 104
     294+#define E_AVR_MACH_XMEGA5 105
     295+#define E_AVR_MACH_XMEGA6 106
     296+#define E_AVR_MACH_XMEGA7 107
     297 
     298 /* Relocations.  */
     299 START_RELOC_NUMBERS (elf_avr_reloc_type)
     300diff -Nur ../binutils-2.20.orig/include/opcode/avr.h ./include/opcode/avr.h
     301--- ../binutils-2.20.orig/include/opcode/avr.h  2008-08-09 07:35:13.000000000 +0200
     302+++ ./include/opcode/avr.h      2010-03-04 11:34:09.000000000 +0100
     303@@ -30,6 +30,8 @@
     304 #define AVR_ISA_BRK   0x0400 /* device has BREAK (on-chip debug) */
     305 #define AVR_ISA_EIND  0x0800 /* device has >128K program memory (none yet) */
     306 #define AVR_ISA_MOVW  0x1000 /* device has MOVW */
     307+#define AVR_ISA_SPMX  0x2000 /* device has SPM Z[+] */
     308+#define AVR_ISA_DES   0x4000 /* device has DES */
     309 
     310 #define AVR_ISA_TINY1 (AVR_ISA_1200 | AVR_ISA_LPM)
     311 #define AVR_ISA_2xxx  (AVR_ISA_TINY1 | AVR_ISA_SRAM)
     312@@ -48,6 +50,8 @@
     313 #define AVR_ISA_94K   (AVR_ISA_M603 | AVR_ISA_MUL | AVR_ISA_MOVW | AVR_ISA_LPMX)
     314 #define AVR_ISA_M323  (AVR_ISA_M161 | AVR_ISA_BRK)
     315 #define AVR_ISA_M128  (AVR_ISA_M323 | AVR_ISA_ELPM | AVR_ISA_ELPMX)
     316+#define AVR_ISA_M256  (AVR_ISA_M128 | AVR_ISA_EIND)
     317+#define AVR_ISA_XMEGA (AVR_ISA_M256 | AVR_ISA_SPMX | AVR_ISA_DES)
     318 
     319 #define AVR_ISA_AVR1   AVR_ISA_TINY1
     320 #define AVR_ISA_AVR2   AVR_ISA_2xxx
     321@@ -108,6 +112,7 @@
     322    L - signed pc relative offset from -2048 to 2047
     323    h - absolute code address (call, jmp)
     324    S - immediate value from 0 to 7 (S = s << 4)
     325+   E - immediate value from 0 to 15, shifted left by 4 (des)
     326    ? - use this opcode entry if no parameters, else use next opcode entry
     327 
     328    Order is important - some binary opcodes have more than one name,
     329@@ -168,7 +173,8 @@
     330 AVR_INSN (sleep,"",    "1001010110001000", 1, AVR_ISA_1200, 0x9588)
     331 AVR_INSN (break,"",    "1001010110011000", 1, AVR_ISA_BRK,  0x9598)
     332 AVR_INSN (wdr,  "",    "1001010110101000", 1, AVR_ISA_1200, 0x95a8)
     333-AVR_INSN (spm,  "",    "1001010111101000", 1, AVR_ISA_SPM,  0x95e8)
     334+AVR_INSN (spm,  "?",   "1001010111101000", 1, AVR_ISA_SPM,  0x95e8)
     335+AVR_INSN (spm,  "z",   "10010101111+1000", 1, AVR_ISA_SPMX, 0x95e8)
     336 
     337 AVR_INSN (adc,  "r,r", "000111rdddddrrrr", 1, AVR_ISA_1200, 0x1c00)
     338 AVR_INSN (add,  "r,r", "000011rdddddrrrr", 1, AVR_ISA_1200, 0x0c00)
     339@@ -282,3 +288,6 @@
     340 AVR_INSN (eicall, "",  "1001010100011001", 1, AVR_ISA_EIND, 0x9519)
     341 AVR_INSN (eijmp, "",   "1001010000011001", 1, AVR_ISA_EIND, 0x9419)
     342 
     343+/* DES instruction for encryption and decryption */
     344+AVR_INSN (des,  "E",   "10010100EEEE1011", 1, AVR_ISA_DES,  0x940B)
     345+
     346diff -Nur ../binutils-2.20.orig/ld/Makefile.am ./ld/Makefile.am
     347--- ../binutils-2.20.orig/ld/Makefile.am        2009-09-01 22:56:51.000000000 +0200
     348+++ ./ld/Makefile.am    2010-03-04 11:34:09.000000000 +0100
     349@@ -148,6 +148,13 @@
     350        eavr5.o \
     351        eavr51.o \
     352        eavr6.o \
     353+       eavrxmega1.o \
     354+       eavrxmega2.o \
     355+       eavrxmega3.o \
     356+       eavrxmega4.o \
     357+       eavrxmega5.o \
     358+       eavrxmega6.o \
     359+       eavrxmega7.o \
     360        ecoff_i860.o \
     361        ecoff_sparc.o \
     362        eelf32_spu.o \
     363@@ -727,6 +734,34 @@
     364   $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     365   ${GEN_DEPENDS}
     366        ${GENSCRIPTS} avr6 "$(tdir_avr2)"
     367+eavrxmega1.c: $(srcdir)/emulparams/avrxmega1.sh \
     368+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     369+  ${GEN_DEPENDS}
     370+       ${GENSCRIPTS} avrxmega1 "$(tdir_avr2)"
     371+eavrxmega2.c: $(srcdir)/emulparams/avrxmega2.sh \
     372+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     373+  ${GEN_DEPENDS}
     374+       ${GENSCRIPTS} avrxmega2 "$(tdir_avr2)"
     375+eavrxmega3.c: $(srcdir)/emulparams/avrxmega3.sh \
     376+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     377+  ${GEN_DEPENDS}
     378+       ${GENSCRIPTS} avrxmega3 "$(tdir_avr2)"
     379+eavrxmega4.c: $(srcdir)/emulparams/avrxmega4.sh \
     380+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     381+  ${GEN_DEPENDS}
     382+       ${GENSCRIPTS} avrxmega4 "$(tdir_avr2)"
     383+eavrxmega5.c: $(srcdir)/emulparams/avrxmega5.sh \
     384+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     385+  ${GEN_DEPENDS}
     386+       ${GENSCRIPTS} avrxmega5 "$(tdir_avr2)"
     387+eavrxmega6.c: $(srcdir)/emulparams/avrxmega6.sh \
     388+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     389+  ${GEN_DEPENDS}
     390+       ${GENSCRIPTS} avrxmega6 "$(tdir_avr2)"
     391+eavrxmega7.c: $(srcdir)/emulparams/avrxmega7.sh \
     392+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     393+  ${GEN_DEPENDS}
     394+       ${GENSCRIPTS} avrxmega7 "$(tdir_avr2)"
     395 ecoff_i860.c: $(srcdir)/emulparams/coff_i860.sh \
     396   $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/i860coff.sc ${GEN_DEPENDS}
     397        ${GENSCRIPTS} coff_i860 "$(tdir_coff_i860)"
     398diff -Nur ../binutils-2.20.orig/ld/Makefile.in ./ld/Makefile.in
     399--- ../binutils-2.20.orig/ld/Makefile.in        2009-09-07 14:10:24.000000000 +0200
     400+++ ./ld/Makefile.in    2010-03-04 11:34:09.000000000 +0100
     401@@ -434,6 +434,13 @@
     402        eavr5.o \
     403        eavr51.o \
     404        eavr6.o \
     405+       eavrxmega1.o \
     406+       eavrxmega2.o \
     407+       eavrxmega3.o \
     408+       eavrxmega4.o \
     409+       eavrxmega5.o \
     410+       eavrxmega6.o \
     411+       eavrxmega7.o \
     412        ecoff_i860.o \
     413        ecoff_sparc.o \
     414        eelf32_spu.o \
     415@@ -2068,6 +2075,34 @@
     416   $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     417   ${GEN_DEPENDS}
     418        ${GENSCRIPTS} avr6 "$(tdir_avr2)"
     419+eavrxmega1.c: $(srcdir)/emulparams/avrxmega1.sh \
     420+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     421+  ${GEN_DEPENDS}
     422+       ${GENSCRIPTS} avrxmega1 "$(tdir_avr2)"
     423+eavrxmega2.c: $(srcdir)/emulparams/avrxmega2.sh \
     424+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     425+  ${GEN_DEPENDS}
     426+       ${GENSCRIPTS} avrxmega2 "$(tdir_avr2)"
     427+eavrxmega3.c: $(srcdir)/emulparams/avrxmega3.sh \
     428+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     429+  ${GEN_DEPENDS}
     430+       ${GENSCRIPTS} avrxmega3 "$(tdir_avr2)"
     431+eavrxmega4.c: $(srcdir)/emulparams/avrxmega4.sh \
     432+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     433+  ${GEN_DEPENDS}
     434+       ${GENSCRIPTS} avrxmega4 "$(tdir_avr2)"
     435+eavrxmega5.c: $(srcdir)/emulparams/avrxmega5.sh \
     436+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     437+  ${GEN_DEPENDS}
     438+       ${GENSCRIPTS} avrxmega5 "$(tdir_avr2)"
     439+eavrxmega6.c: $(srcdir)/emulparams/avrxmega6.sh \
     440+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     441+  ${GEN_DEPENDS}
     442+       ${GENSCRIPTS} avrxmega6 "$(tdir_avr2)"
     443+eavrxmega7.c: $(srcdir)/emulparams/avrxmega7.sh \
     444+  $(srcdir)/emultempl/avrelf.em $(ELF_DEPS) $(srcdir)/scripttempl/avr.sc \
     445+  ${GEN_DEPENDS}
     446+       ${GENSCRIPTS} avrxmega7 "$(tdir_avr2)"
     447 ecoff_i860.c: $(srcdir)/emulparams/coff_i860.sh \
     448   $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/i860coff.sc ${GEN_DEPENDS}
     449        ${GENSCRIPTS} coff_i860 "$(tdir_coff_i860)"
     450diff -Nur ../binutils-2.20.orig/ld/configure.tgt ./ld/configure.tgt
     451--- ../binutils-2.20.orig/ld/configure.tgt      2009-08-06 19:38:03.000000000 +0200
     452+++ ./ld/configure.tgt  2010-03-04 11:34:09.000000000 +0100
     453@@ -110,7 +110,7 @@
     454 xscale-*-elf)          targ_emul=armelf
     455                        ;;
     456 avr-*-*)               targ_emul=avr2
     457-                       targ_extra_emuls="avr1 avr25 avr3 avr31 avr35 avr4 avr5 avr51 avr6"
     458+                       targ_extra_emuls="avr1 avr25 avr3 avr31 avr35 avr4 avr5 avr51 avr6 avrxmega1 avrxmega2 avrxmega3 avrxmega4 avrxmega5 avrxmega6 avrxmega7"
     459                        ;;
     460 bfin-*-elf)            targ_emul=elf32bfin;
     461                        targ_extra_emuls="elf32bfinfd"
     462diff -Nur ../binutils-2.20.orig/ld/emulparams/avrxmega1.sh ./ld/emulparams/avrxmega1.sh
     463--- ../binutils-2.20.orig/ld/emulparams/avrxmega1.sh    1970-01-01 01:00:00.000000000 +0100
     464+++ ./ld/emulparams/avrxmega1.sh        2010-03-04 11:34:09.000000000 +0100
     465@@ -0,0 +1,12 @@
     466+ARCH=avr:101
     467+MACHINE=
     468+SCRIPT_NAME=avr
     469+OUTPUT_FORMAT="elf32-avr"
     470+MAXPAGESIZE=1
     471+EMBEDDED=yes
     472+TEMPLATE_NAME=elf32
     473+
     474+TEXT_LENGTH=1024K
     475+DATA_ORIGIN=0x802000
     476+DATA_LENGTH=0xffa0
     477+EXTRA_EM_FILE=avrelf
     478diff -Nur ../binutils-2.20.orig/ld/emulparams/avrxmega2.sh ./ld/emulparams/avrxmega2.sh
     479--- ../binutils-2.20.orig/ld/emulparams/avrxmega2.sh    1970-01-01 01:00:00.000000000 +0100
     480+++ ./ld/emulparams/avrxmega2.sh        2010-03-04 11:34:09.000000000 +0100
     481@@ -0,0 +1,12 @@
     482+ARCH=avr:102
     483+MACHINE=
     484+SCRIPT_NAME=avr
     485+OUTPUT_FORMAT="elf32-avr"
     486+MAXPAGESIZE=1
     487+EMBEDDED=yes
     488+TEMPLATE_NAME=elf32
     489+
     490+TEXT_LENGTH=1024K
     491+DATA_ORIGIN=0x802000
     492+DATA_LENGTH=0xffa0
     493+EXTRA_EM_FILE=avrelf
     494diff -Nur ../binutils-2.20.orig/ld/emulparams/avrxmega3.sh ./ld/emulparams/avrxmega3.sh
     495--- ../binutils-2.20.orig/ld/emulparams/avrxmega3.sh    1970-01-01 01:00:00.000000000 +0100
     496+++ ./ld/emulparams/avrxmega3.sh        2010-03-04 11:34:09.000000000 +0100
     497@@ -0,0 +1,12 @@
     498+ARCH=avr:103
     499+MACHINE=
     500+SCRIPT_NAME=avr
     501+OUTPUT_FORMAT="elf32-avr"
     502+MAXPAGESIZE=1
     503+EMBEDDED=yes
     504+TEMPLATE_NAME=elf32
     505+
     506+TEXT_LENGTH=1024K
     507+DATA_ORIGIN=0x802000
     508+DATA_LENGTH=0xffa0
     509+EXTRA_EM_FILE=avrelf
     510diff -Nur ../binutils-2.20.orig/ld/emulparams/avrxmega4.sh ./ld/emulparams/avrxmega4.sh
     511--- ../binutils-2.20.orig/ld/emulparams/avrxmega4.sh    1970-01-01 01:00:00.000000000 +0100
     512+++ ./ld/emulparams/avrxmega4.sh        2010-03-04 11:34:09.000000000 +0100
     513@@ -0,0 +1,12 @@
     514+ARCH=avr:104
     515+MACHINE=
     516+SCRIPT_NAME=avr
     517+OUTPUT_FORMAT="elf32-avr"
     518+MAXPAGESIZE=1
     519+EMBEDDED=yes
     520+TEMPLATE_NAME=elf32
     521+
     522+TEXT_LENGTH=1024K
     523+DATA_ORIGIN=0x802000
     524+DATA_LENGTH=0xffa0
     525+EXTRA_EM_FILE=avrelf
     526diff -Nur ../binutils-2.20.orig/ld/emulparams/avrxmega5.sh ./ld/emulparams/avrxmega5.sh
     527--- ../binutils-2.20.orig/ld/emulparams/avrxmega5.sh    1970-01-01 01:00:00.000000000 +0100
     528+++ ./ld/emulparams/avrxmega5.sh        2010-03-04 11:34:09.000000000 +0100
     529@@ -0,0 +1,12 @@
     530+ARCH=avr:105
     531+MACHINE=
     532+SCRIPT_NAME=avr
     533+OUTPUT_FORMAT="elf32-avr"
     534+MAXPAGESIZE=1
     535+EMBEDDED=yes
     536+TEMPLATE_NAME=elf32
     537+
     538+TEXT_LENGTH=1024K
     539+DATA_ORIGIN=0x802000
     540+DATA_LENGTH=0xffa0
     541+EXTRA_EM_FILE=avrelf
     542diff -Nur ../binutils-2.20.orig/ld/emulparams/avrxmega6.sh ./ld/emulparams/avrxmega6.sh
     543--- ../binutils-2.20.orig/ld/emulparams/avrxmega6.sh    1970-01-01 01:00:00.000000000 +0100
     544+++ ./ld/emulparams/avrxmega6.sh        2010-03-04 11:34:09.000000000 +0100
     545@@ -0,0 +1,12 @@
     546+ARCH=avr:106
     547+MACHINE=
     548+SCRIPT_NAME=avr
     549+OUTPUT_FORMAT="elf32-avr"
     550+MAXPAGESIZE=1
     551+EMBEDDED=yes
     552+TEMPLATE_NAME=elf32
     553+
     554+TEXT_LENGTH=1024K
     555+DATA_ORIGIN=0x802000
     556+DATA_LENGTH=0xffa0
     557+EXTRA_EM_FILE=avrelf
     558diff -Nur ../binutils-2.20.orig/ld/emulparams/avrxmega7.sh ./ld/emulparams/avrxmega7.sh
     559--- ../binutils-2.20.orig/ld/emulparams/avrxmega7.sh    1970-01-01 01:00:00.000000000 +0100
     560+++ ./ld/emulparams/avrxmega7.sh        2010-03-04 11:34:09.000000000 +0100
     561@@ -0,0 +1,12 @@
     562+ARCH=avr:107
     563+MACHINE=
     564+SCRIPT_NAME=avr
     565+OUTPUT_FORMAT="elf32-avr"
     566+MAXPAGESIZE=1
     567+EMBEDDED=yes
     568+TEMPLATE_NAME=elf32
     569+
     570+TEXT_LENGTH=1024K
     571+DATA_ORIGIN=0x802000
     572+DATA_LENGTH=0xffa0
     573+EXTRA_EM_FILE=avrelf
     574diff -Nur ../binutils-2.20.orig/ld/emultempl/avrelf.em ./ld/emultempl/avrelf.em
     575--- ../binutils-2.20.orig/ld/emultempl/avrelf.em        2009-09-02 09:25:35.000000000 +0200
     576+++ ./ld/emultempl/avrelf.em    2010-03-04 11:34:09.000000000 +0100
     577@@ -71,8 +71,10 @@
     578 
     579   gld${EMULATION_NAME}_before_allocation ();
     580 
     581-  /* We only need stubs for the avr6 family.  */
     582-  if (strcmp ("${EMULATION_NAME}","avr6"))
     583+  /* We only need stubs for avr6, avrxmega6, and avrxmega7. */
     584+  if (strcmp ("${EMULATION_NAME}","avr6")
     585+      && strcmp ("${EMULATION_NAME}","avrxmega6")
     586+      && strcmp ("${EMULATION_NAME}","avrxmega7") )
     587     avr_no_stubs = TRUE;
     588 
     589   avr_elf_set_global_bfd_parameters ();
     590diff -Nur ../binutils-2.20.orig/opcodes/avr-dis.c ./opcodes/avr-dis.c
     591--- ../binutils-2.20.orig/opcodes/avr-dis.c     2008-11-06 13:03:24.000000000 +0100
     592+++ ./opcodes/avr-dis.c 2010-03-04 11:34:09.000000000 +0100
     593@@ -50,7 +50,7 @@
     594 
     595 static int
     596 avr_operand (unsigned int insn, unsigned int insn2, unsigned int pc, int constraint,
     597-             char *buf, char *comment, int regs, int *sym, bfd_vma *sym_addr)
     598+             char *opcode_str, char *buf, char *comment, int regs, int *sym, bfd_vma *sym_addr)
     599 {
     600   int ok = 1;
     601   *sym = 0;
     602@@ -118,8 +118,18 @@
     603 
     604     case 'z':
     605       *buf++ = 'Z';
     606-      if (insn & 0x1)
     607-       *buf++ = '+';
     608+
     609+      /* Check for post-increment. */
     610+      char *s;
     611+      for (s = opcode_str; *s; ++s)
     612+        {
     613+          if (*s == '+')
     614+            {
     615+              *buf++ = '+';
     616+              break;
     617+            }
     618+        }
     619+
     620       *buf = '\0';
     621       if (AVR_UNDEF_P (insn))
     622        sprintf (comment, _("undefined"));
     623@@ -226,6 +236,10 @@
     624        sprintf (comment, "%d", x);
     625       }
     626       break;
     627+
     628+    case 'E':
     629+      sprintf (buf, "%d", (insn >> 4) & 15);
     630+      break;
     631       
     632     case '?':
     633       *buf = '\0';
     634@@ -331,7 +345,8 @@
     635 
     636   if (opcode->name)
     637     {
     638-      char *op = opcode->constraints;
     639+      char *constraints = opcode->constraints;
     640+      char *opcode_str = opcode->opcode;
     641 
     642       insn2 = 0;
     643       ok = 1;
     644@@ -342,14 +357,14 @@
     645          cmd_len = 4;
     646        }
     647 
     648-      if (*op && *op != '?')
     649+      if (*constraints && *constraints != '?')
     650        {
     651-         int regs = REGISTER_P (*op);
     652+         int regs = REGISTER_P (*constraints);
     653 
     654-         ok = avr_operand (insn, insn2, addr, *op, op1, comment1, 0, &sym_op1, &sym_addr1);
     655+         ok = avr_operand (insn, insn2, addr, *constraints, opcode_str, op1, comment1, 0, &sym_op1, &sym_addr1);
     656 
     657-         if (ok && *(++op) == ',')
     658-           ok = avr_operand (insn, insn2, addr, *(++op), op2,
     659+         if (ok && *(++constraints) == ',')
     660+           ok = avr_operand (insn, insn2, addr, *(++constraints), opcode_str, op2,
     661                              *comment1 ? comment2 : comment1, regs, &sym_op2, &sym_addr2);
     662        }
     663     }