home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / gnu / binutils-1.8.x-src.lha / src / diffs / binutils-1.8.x.diffs
Text File  |  1994-02-05  |  90KB  |  3,363 lines
  1. diff -rc --new-file binutils-1.8.x-fsf/Makefile binutils-1.8.x-amiga/Makefile
  2. *** binutils-1.8.x-fsf/Makefile    Wed Nov 27 22:48:58 1991
  3. --- binutils-1.8.x-amiga/Makefile    Sat Feb  5 12:33:24 1994
  4. ***************
  5. *** 19,50 ****
  6.   # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  7.   
  8.   
  9. ! GNUCC = gcc -O
  10. ! #CC = gcc -O
  11.   bindir=/usr/local/bin
  12.   
  13.   # for BSD systems
  14.   #CFLAGS = -g
  15.   # Don't add robotussin; it won't compile on BSD or GNU systems.
  16.   # objdump is not here because it (at least used to) not compile
  17.   # on most systems (trouble with N_DATADDR).  I've fixed some of
  18.   # those problems, though.
  19. ! PROGS = $(archpfx)gprof $(archpfx)ld $(archpfx)size \
  20. !         $(archpfx)nm $(archpfx)strip $(archpfx)ar $(archpfx)ranlib
  21.   
  22.   # for USG systems using COFF_ENCAPSULATE
  23.   # also, you will want to make the target libc.a (but it takes a long time)
  24.   # Note that you should leave a copy of `ar' in this directory
  25.   # after you install it, since `ranlib' will try to run it from here.
  26. ! CFLAGS = -DWYSE -DUSG -DCOFF_ENCAPSULATE -DPORTAR -DNON_NATIVE -DPIGNAL_MISSING
  27. ! PROGS = ld size nm strip ar robotussin objdump ranlib gprof
  28. ! SIGNAME = signame.o
  29.   # On ALTOS systems, add -DALTOS to CFLAGS.
  30.   
  31.   #it's better to move a copy of alloca into your libc than to risk getting some
  32.   #incompatiable functions from -lPW (like index()), but if you
  33.   #want to be lazy, uncomment this line
  34. ! ALLOCALIBS = -lPW
  35.   
  36.   # For HP-UX systems
  37.   # Don't add robotussin; use hpxt instead.
  38. --- 19,57 ----
  39.   # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  40.   
  41.   
  42. ! GNUCC = gcc -O2
  43.   bindir=/usr/local/bin
  44.   
  45. + # for AmigaDOS systems
  46. + CFLAGS = -resident
  47. + # Don't include gprof.
  48. + PROGS = $(archpfx)ld $(archpfx)size \
  49. +         $(archpfx)nm $(archpfx)strip $(archpfx)ar $(archpfx)ranlib
  50. + CC = gcc -O2
  51. + bindir=/gnu/bin
  52. + 
  53.   # for BSD systems
  54.   #CFLAGS = -g
  55.   # Don't add robotussin; it won't compile on BSD or GNU systems.
  56.   # objdump is not here because it (at least used to) not compile
  57.   # on most systems (trouble with N_DATADDR).  I've fixed some of
  58.   # those problems, though.
  59. ! #PROGS = $(archpfx)gprof $(archpfx)ld $(archpfx)size \
  60. ! #        $(archpfx)nm $(archpfx)strip $(archpfx)ar $(archpfx)ranlib
  61.   
  62.   # for USG systems using COFF_ENCAPSULATE
  63.   # also, you will want to make the target libc.a (but it takes a long time)
  64.   # Note that you should leave a copy of `ar' in this directory
  65.   # after you install it, since `ranlib' will try to run it from here.
  66. ! #CFLAGS = -g -DUSG -DCOFF_ENCAPSULATE -DPORTAR -DNON_NATIVE -DPIGNAL_MISSING
  67. ! #PROGS = ld size nm strip ar robotussin objdump ranlib gprof
  68. ! #SIGNAME = signame.o
  69.   # On ALTOS systems, add -DALTOS to CFLAGS.
  70.   
  71.   #it's better to move a copy of alloca into your libc than to risk getting some
  72.   #incompatiable functions from -lPW (like index()), but if you
  73.   #want to be lazy, uncomment this line
  74. ! #ALLOCALIBS = -lPW
  75.   
  76.   # For HP-UX systems
  77.   # Don't add robotussin; use hpxt instead.
  78. ***************
  79. *** 83,89 ****
  80.   # C++ demangler
  81.   CPLUS_DEM = $(archpfx)cplus-dem.o
  82.   
  83. ! LIBS=$(MALLOC) $(ALLOCALIBS) $(SIGNAME)
  84.   
  85.   all: $(PROGS)
  86.   
  87. --- 90,96 ----
  88.   # C++ demangler
  89.   CPLUS_DEM = $(archpfx)cplus-dem.o
  90.   
  91. ! LIBS=$(ALLOCALIBS) $(SIGNAME)
  92.   
  93.   all: $(PROGS)
  94.   
  95. ***************
  96. *** 114,120 ****
  97.   $(archpfx)ranlib: $(archpfx)ranlib.o $(GNU_GETOPT_LONG)
  98.       $(CC) $(CFLAGS) -o $(archpfx)ranlib $(archpfx)ranlib.o $(GNU_GETOPT_LONG) $(LIBS)
  99.   $(archpfx)ranlib.o: ranlib.c
  100. !     $(CC) -c $(CFLAGS) -DAR_PROG=\"/usr/local/gnu/binutils/ar\" ranlib.c $(OUTPUT_OPTION)
  101.   
  102.   $(archpfx)objdump: $(archpfx)objdump.o $(GNU_GETOPT_LONG) a.out.gnu.h
  103.       $(CC) $(CFLAGS) -o $(archpfx)objdump $(archpfx)objdump.o \
  104. --- 121,127 ----
  105.   $(archpfx)ranlib: $(archpfx)ranlib.o $(GNU_GETOPT_LONG)
  106.       $(CC) $(CFLAGS) -o $(archpfx)ranlib $(archpfx)ranlib.o $(GNU_GETOPT_LONG) $(LIBS)
  107.   $(archpfx)ranlib.o: ranlib.c
  108. !     $(CC) -c $(CFLAGS) -DAR_PROG=\"$(bindir)/ar\" ranlib.c $(OUTPUT_OPTION)
  109.   
  110.   $(archpfx)objdump: $(archpfx)objdump.o $(GNU_GETOPT_LONG) a.out.gnu.h
  111.       $(CC) $(CFLAGS) -o $(archpfx)objdump $(archpfx)objdump.o \
  112. ***************
  113. *** 145,150 ****
  114.   .PHONY: install
  115.   install: $(PROGS)
  116.       for file in $(PROGS); do \
  117. !     cp $$file $(bindir)/$${file}.new; \
  118. !     mv $(bindir)/$${file}.new $(bindir)/$$file; \
  119.       done
  120. --- 152,158 ----
  121.   .PHONY: install
  122.   install: $(PROGS)
  123.       for file in $(PROGS); do \
  124. !     cp $${file} $(bindir)/$${file}.new; \
  125. !     mv $(bindir)/$${file} $(bindir)/$${file}.bak; \
  126. !     mv $(bindir)/$${file}.new $(bindir)/$${file}; \
  127.       done
  128. diff -rc --new-file binutils-1.8.x-fsf/ar.c binutils-1.8.x-amiga/ar.c
  129. *** binutils-1.8.x-fsf/ar.c    Wed Jun 13 05:47:50 1990
  130. --- binutils-1.8.x-amiga/ar.c    Sat Feb  5 13:17:48 1994
  131. ***************
  132. *** 992,1002 ****
  133. --- 992,1012 ----
  134.   #endif
  135.     close (outdesc);
  136.   
  137. + #ifndef amigados
  138.     if (!appendflag)
  139.       if (rename (tempname, archive))
  140.         pfatal_with_name (tempname);
  141.   
  142.     close_archive ();
  143. + #else
  144. +   /* we *have* to close the file before we rename it, because otherwise
  145. +    * AmigaDOS will just abort with OBJECT_IN_USE_ERROR */
  146. +   close_archive ();
  147. + 
  148. +   if (!appendflag)
  149. +     if (rename (tempname, archive))
  150. +       pfatal_with_name (tempname);
  151. + #endif
  152.   }
  153.   
  154.   void
  155. ***************
  156. *** 1957,1962 ****
  157. --- 1967,1973 ----
  158.        unsigned int size;
  159.   {
  160.     extern char *malloc ();
  161. + 
  162.     char *result = malloc (size);
  163.     if (result == 0)
  164.       fatal ("virtual memory exhausted", 0);
  165. ***************
  166. *** 1969,1974 ****
  167. --- 1980,1986 ----
  168.        unsigned int size;
  169.   {
  170.     extern char *realloc ();
  171. + 
  172.     char *result = realloc (ptr, size);
  173.     if (result == 0)
  174.       fatal ("virtual memory exhausted");
  175. diff -rc --new-file binutils-1.8.x-fsf/cplus-dem.c binutils-1.8.x-amiga/cplus-dem.c
  176. *** binutils-1.8.x-fsf/cplus-dem.c    Wed Jun 13 05:42:34 1990
  177. --- binutils-1.8.x-amiga/cplus-dem.c    Wed Sep 22 12:45:32 1993
  178. ***************
  179. *** 48,54 ****
  180.   #include <ctype.h>
  181.   
  182.   #if !defined(sequent) && !defined(NeXT)
  183. ! #include <memory.h>
  184.   #else
  185.   #define memcpy(s1, s2, n) strncpy(s1, s2, n) 
  186.   #define memcmp(s1, s2, n) strncmp(s1, s2, n)
  187. --- 48,54 ----
  188.   #include <ctype.h>
  189.   
  190.   #if !defined(sequent) && !defined(NeXT)
  191. ! /* #include <memory.h> */
  192.   #else
  193.   #define memcpy(s1, s2, n) strncpy(s1, s2, n) 
  194.   #define memcmp(s1, s2, n) strncmp(s1, s2, n)
  195. diff -rc --new-file binutils-1.8.x-fsf/ld.c binutils-1.8.x-amiga/ld.c
  196. *** binutils-1.8.x-fsf/ld.c    Wed Nov 27 22:04:14 1991
  197. --- binutils-1.8.x-amiga/ld.c    Sat Feb  5 13:32:51 1994
  198. ***************
  199. *** 16,22 ****
  200.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  201.   
  202.   /* Written by Richard Stallman with some help from Eric Albert.
  203. !    Set, indirect, and warning symbol features added by Randy Smith.  */
  204.   
  205.   #include <ar.h>
  206.   #include <stdio.h>
  207. --- 16,29 ----
  208.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  209.   
  210.   /* Written by Richard Stallman with some help from Eric Albert.
  211. !    Set, indirect, and warning symbol features added by Randy Smith.
  212. !    Support for generation of Amiga load files added by Markus Wild. */
  213. ! 
  214. ! #ifdef amigados
  215. ! #ifndef STANDARD_SEARCH_DIRS
  216. ! #define STANDARD_SEARCH_DIRS "local:lib","local:os-lib","gnu:lib","gnu:os-lib"
  217. ! #endif
  218. ! #endif
  219.   
  220.   #include <ar.h>
  221.   #include <stdio.h>
  222. ***************
  223. *** 30,35 ****
  224. --- 37,44 ----
  225.   #ifndef sony_news
  226.   #include <fcntl.h>
  227.   #endif
  228. + /* JPB, 7 Jun 1992: MAXNAMLEN required for long name hack. */
  229. + #include <dirent.h>
  230.   
  231.   #if !defined(A_OUT) && !defined(MACH_O)
  232.   #define A_OUT
  233. ***************
  234. *** 43,48 ****
  235. --- 52,84 ----
  236.   #endif
  237.   #endif
  238.   
  239. + #ifdef MCH_AMIGA
  240. + #define HUNK_INSTEAD_OF_A_OUT
  241. + int number_of_code_hunk,
  242. +     number_of_data_hunk,
  243. +     number_of_bss_hunk,
  244. +     number_of_debug_hunk,
  245. +     current_hunk = 0,
  246. +     offset_of_debug_hunk,
  247. +     amiga_symbols_only,
  248. +     databss_together = 0,
  249. +     numdatadata_relocs = 0,
  250. +     output_datadata_relocs = 0,
  251. +     datadata_relocs_offset = 0;
  252. + #define LONGSIZE(l) ((((l) + 3) & ~3) >> 2)
  253. + /* this is the private format of the debug-hunk: */
  254. +    struct debug_hunk {
  255. +      unsigned long  id;  /* Filesystem-imposed: HUNK_DEBUG (0x3f1) */
  256. +      unsigned long  len; /* "" : length in longs -> LONGSIZE(real_lenght) */
  257. +      /* the following part is somehow a truncated exec-struct: */
  258. +      unsigned long  magic; /* should be ZMAGIC (just for fun:-)), to be recognised
  259. +                 * by the other tools as this special frame */
  260. +      unsigned long  syms;  /* size of symbol-table */
  261. +      unsigned long  strs;  /* size of string table */
  262. +      /* here follows the actual data */
  263. +    } dh;
  264. + #endif
  265. + 
  266.   #ifdef MACH_O
  267.   #ifndef A_OUT
  268.   #include <nlist.h>
  269. ***************
  270. *** 104,110 ****
  271.   /* Name this program was invoked by.  */
  272.   
  273.   char *progname;
  274. ! 
  275.   /* System dependencies */
  276.   
  277.   /* Define this if names etext, edata and end should not start with `_'.  */
  278. --- 140,146 ----
  279.   /* Name this program was invoked by.  */
  280.   
  281.   char *progname;
  282. ! 
  283.   /* System dependencies */
  284.   
  285.   /* Define this if names etext, edata and end should not start with `_'.  */
  286. ***************
  287. *** 190,195 ****
  288. --- 226,247 ----
  289.   #endif /* mc68000.  */
  290.   #endif /* Sun.  */
  291.   
  292. + #ifdef amigados
  293. + /* same trick as with sun[23] */
  294. + /* Set the machine type according to the machine type of the .o files.
  295. +    If they are all sun2 (68010), then the type of the executable is sun2.
  296. +    If any is sun3 (68020), then the type of the executable is sun3.
  297. +    This is consistent with the Sun loader and more useful than having
  298. +    it depend on which machine you are on when you run ld.  */
  299. + static int amiga_machtype = MID_SUN010;
  300. + #define INITIALIZE_HEADER outheader.a_machtype = amiga_machtype
  301. + #define READ_HEADER_HOOK(machtype) \
  302. +   if (machtype == MID_SUN020)        \
  303. +     {                     \
  304. +       amiga_machtype = MID_SUN020;   \
  305. +     }
  306. + #endif
  307. + 
  308.   #ifdef ALTOS
  309.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  310.   #endif
  311. ***************
  312. *** 368,373 ****
  313. --- 420,426 ----
  314.   #define RELOC_MEMORY_ADD_P(r)    1
  315.   #undef RELOC_ADD_EXTRA
  316.   #define RELOC_PCREL_P(r)        ((r)->r_pcrel)
  317. + #define RELOC_BASEREL_P(r)        ((r)->r_baserel)
  318.   #define RELOC_VALUE_RIGHTSHIFT(r)    0
  319.   #define RELOC_TARGET_SIZE(r)        ((r)->r_length)
  320.   #define RELOC_TARGET_BITPOS(r)    0
  321. ***************
  322. *** 384,390 ****
  323.   #define LPREFIX 'L'
  324.   #endif
  325.   
  326. ! 
  327.   /* Special global symbol types understood by GNU LD.  */
  328.   
  329.   /* The following type indicates the definition of a symbol as being
  330. --- 437,443 ----
  331.   #define LPREFIX 'L'
  332.   #endif
  333.   
  334. ! 
  335.   /* Special global symbol types understood by GNU LD.  */
  336.   
  337.   /* The following type indicates the definition of a symbol as being
  338. ***************
  339. *** 531,537 ****
  340.   #endif
  341.   
  342.   #endif /* not __GNU_STAB__ */
  343. ! 
  344.   /* Symbol table */
  345.   
  346.   /* Global symbol data is recorded in these structures,
  347. --- 584,590 ----
  348.   #endif
  349.   
  350.   #endif /* not __GNU_STAB__ */
  351. ! 
  352.   /* Symbol table */
  353.   
  354.   /* Global symbol data is recorded in these structures,
  355. ***************
  356. *** 684,690 ****
  357.   symbol *edata_symbol_alt;
  358.   symbol *etext_symbol_alt;
  359.   symbol *end_symbol_alt;
  360. ! 
  361.   /* Kinds of files potentially understood by the linker. */
  362.   
  363.   enum file_type { IS_UNKNOWN, IS_ARCHIVE, IS_A_OUT, IS_MACH_O };
  364. --- 737,751 ----
  365.   symbol *edata_symbol_alt;
  366.   symbol *etext_symbol_alt;
  367.   symbol *end_symbol_alt;
  368. ! 
  369. ! #ifdef amigados
  370. ! symbol *sdata_symbol;    /* the symbol __sdata */
  371. ! symbol *text_size_symbol;
  372. ! symbol *data_size_symbol;
  373. ! symbol *bss_size_symbol;
  374. ! symbol *datadata_reloc_symbol = 0;
  375. ! #endif
  376. ! 
  377.   /* Kinds of files potentially understood by the linker. */
  378.   
  379.   enum file_type { IS_UNKNOWN, IS_ARCHIVE, IS_A_OUT, IS_MACH_O };
  380. ***************
  381. *** 820,826 ****
  382.   
  383.   /* Length of that vector.  */
  384.   int number_of_files;
  385. ! 
  386.   /* When loading the text and data, we can avoid doing a close
  387.      and another open between members of the same library.
  388.   
  389. --- 881,887 ----
  390.   
  391.   /* Length of that vector.  */
  392.   int number_of_files;
  393. ! 
  394.   /* When loading the text and data, we can avoid doing a close
  395.      and another open between members of the same library.
  396.   
  397. ***************
  398. *** 867,875 ****
  399. --- 928,941 ----
  400.   #define DEFAULT_OUTPUT_STYLE OUTPUT_DEMAND_PAGED
  401.   #endif
  402.   
  403. + #if 0
  404.   /* Descriptor for writing that file with `mywrite'.  */
  405.   
  406.   int outdesc;
  407. + #endif
  408. + 
  409. + /* use outstream instead of outdesc thru the whole file, it's MUCH faster.. */
  410. + FILE *outstream = (FILE *) 0;
  411.   
  412.   /* The following are computed by `digest_symbols'.  */
  413.   
  414. ***************
  415. *** 929,935 ****
  416.     int symbol_name_string_index;
  417.     int library_member_offset;
  418.   };
  419. ! 
  420.   /* Record most of the command options.  */
  421.   
  422.   /* Address we assume the text section will be loaded at.
  423. --- 995,1001 ----
  424.     int symbol_name_string_index;
  425.     int library_member_offset;
  426.   };
  427. ! 
  428.   /* Record most of the command options.  */
  429.   
  430.   /* Address we assume the text section will be loaded at.
  431. ***************
  432. *** 993,998 ****
  433. --- 1059,1068 ----
  434.   /* Length of the vector `search_dirs'.  */
  435.   int n_search_dirs;
  436.   
  437. + /* Vector of flavors to search for. */
  438. + char **flavors;
  439. + int n_flavors;
  440. + 
  441.   /* Non zero means to create the output executable.
  442.      Cleared by nonfatal errors.  */
  443.   int make_executable;
  444. ***************
  445. *** 1007,1017 ****
  446. --- 1077,1092 ----
  447.   struct glosym **cmdline_references;
  448.   int cl_refs_allocated;
  449.   
  450. + /* JPB, 7 Jun 1992: Global variable needed for long name hack. */
  451. + static int ar_hdr_size;
  452. + 
  453.   #ifndef bcopy
  454.   void bcopy (), bzero ();
  455.   #endif
  456. + #ifndef __STDC__
  457.   char *malloc (), *realloc ();
  458.   void free ();
  459. + #endif
  460.   
  461.   char *xmalloc ();
  462.   char *xrealloc ();
  463. ***************
  464. *** 1034,1039 ****
  465. --- 1109,1129 ----
  466.   void write_output ();
  467.   void write_header ();
  468.   void write_text ();
  469. + #ifdef HUNK_INSTEAD_OF_A_OUT
  470. + void write_datadata_relocs ();
  471. + void write_hunk_header ();
  472. + void conditionally_rewrite_headers ();
  473. + void write_bss ();
  474. + void init_reloc_hunk ();
  475. + void add_to_reloc_hunk ();
  476. + void write_reloc_hunk ();
  477. + void init_symbol_hunks ();
  478. + void add_to_symbol_hunk ();
  479. + void write_symbol_hunk ();
  480. + void look_for_symbols ();
  481. + void look_for_file_symbols ();
  482. + void relocate_set_vectors ();
  483. + #endif
  484.   void read_file_relocation ();
  485.   void write_data ();
  486.   void write_rel ();
  487. ***************
  488. *** 1045,1051 ****
  489.   char *concat ();
  490.   char *get_file_name ();
  491.   symbol *getsym (), *getsym_soft ();
  492. ! 
  493.   int
  494.   main (argc, argv)
  495.        char **argv;
  496. --- 1135,1142 ----
  497.   char *concat ();
  498.   char *get_file_name ();
  499.   symbol *getsym (), *getsym_soft ();
  500. ! int compare_longs (), compare_strings ();
  501. ! 
  502.   int
  503.   main (argc, argv)
  504.        char **argv;
  505. ***************
  506. *** 1090,1095 ****
  507. --- 1181,1189 ----
  508.     make_executable = 1;
  509.     force_executable = 0;
  510.     set_element_prefixes = 0;
  511. + #ifdef HUNK_INSTEAD_OF_A_OUT
  512. +   amiga_symbols_only = 1;
  513. + #endif
  514.   
  515.     /* Initialize the cumulative counts of symbols.  */
  516.   
  517. ***************
  518. *** 1148,1158 ****
  519.   
  520.     exit (!make_executable);
  521.   }
  522. ! 
  523.   void add_cmdline_ref ();
  524.   
  525.   static struct option longopts[] =
  526.   {
  527.     {"d", 0, 0, 'd'},
  528.     {"dc", 0, 0, 'd'},        /* For Sun compatibility. */
  529.     {"dp", 0, 0, 'd'},        /* For Sun compatibility. */
  530. --- 1242,1259 ----
  531.   
  532.     exit (!make_executable);
  533.   }
  534. ! 
  535.   void add_cmdline_ref ();
  536.   
  537.   static struct option longopts[] =
  538.   {
  539. + #ifdef HUNK_INSTEAD_OF_A_OUT
  540. +   {"amiga-debug-hunk", 0, 0, 'a'},
  541. +   {"databss-together", 0, 0, 'b'},
  542. +   {"datadata-reloc", 0, 0, 'c'},
  543. +   {"msmall-code", 0, 0, 129},        /* ignore.. */
  544. +   {"flavor", 1, 0, 'f'},
  545. + #endif
  546.     {"d", 0, 0, 'd'},
  547.     {"dc", 0, 0, 'd'},        /* For Sun compatibility. */
  548.     {"dp", 0, 0, 'd'},        /* For Sun compatibility. */
  549. ***************
  550. *** 1224,1229 ****
  551. --- 1325,1344 ----
  552.         number_of_files++;
  553.         break;
  554.   
  555. + #ifdef HUNK_INSTEAD_OF_A_OUT
  556. +     case 'a':
  557. +       amiga_symbols_only = 0;
  558. +       break;
  559. + 
  560. +     case 'b':
  561. +       databss_together = 1;
  562. +       break;
  563. + 
  564. +     case 'c':
  565. +       output_datadata_relocs = 1;
  566. +       break;
  567. + #endif
  568. + 
  569.       case 'd':
  570.         force_common_definition = 1;
  571.         break;
  572. ***************
  573. *** 1236,1241 ****
  574. --- 1351,1362 ----
  575.         add_cmdline_ref (entry_symbol);
  576.         break;
  577.   
  578. +     case 'f':
  579. +       n_flavors++;
  580. +       flavors = (char **) xrealloc (flavors, n_flavors * sizeof (char *));
  581. +       flavors[n_flavors - 1] = optarg;
  582. +       break;
  583. + 
  584.       case 'l':
  585.         number_of_files++;
  586.         break;
  587. ***************
  588. *** 1363,1368 ****
  589. --- 1484,1494 ----
  590.       }
  591.       }
  592.   
  593. +   if (n_flavors > 1)
  594. +     {
  595. +       qsort (flavors, n_flavors, sizeof (char *), compare_strings);
  596. +     }
  597. + 
  598.     if (!number_of_files)
  599.       usage ("no input files", 0);
  600.   
  601. ***************
  602. *** 1433,1439 ****
  603.            n * sizeof (char *));
  604.       }
  605.   }
  606. ! 
  607.   
  608.   void
  609.   add_cmdline_ref (sp)
  610. --- 1559,1565 ----
  611.            n * sizeof (char *));
  612.       }
  613.   }
  614. ! 
  615.   
  616.   void
  617.   add_cmdline_ref (sp)
  618. ***************
  619. *** 1478,1484 ****
  620.       }
  621.     return 0;
  622.   }
  623. ! 
  624.   /* Convenient functions for operating on one or all files being
  625.      loaded.  */
  626.   void print_file_name ();
  627. --- 1604,1610 ----
  628.       }
  629.     return 0;
  630.   }
  631. ! 
  632.   /* Convenient functions for operating on one or all files being
  633.      loaded.  */
  634.   void print_file_name ();
  635. ***************
  636. *** 1602,1609 ****
  637.   
  638.         for (i = 0; i < n_search_dirs; i++)
  639.       {
  640. !       register char *string
  641. !         = concat (search_dirs[i], "/", entry->filename);
  642.         desc = open (string, O_RDONLY, 0);
  643.         if (desc > 0)
  644.           {
  645. --- 1728,1746 ----
  646.   
  647.         for (i = 0; i < n_search_dirs; i++)
  648.       {
  649. !       register char *string;
  650. ! 
  651. !       string = search_dirs[i];
  652. !       if (n_flavors > 0)
  653. !         {
  654. !           int count;
  655. !           for (count = 0; count < n_flavors; count++)
  656. !         {
  657. !           string = concat (string, "/", flavors[count]);
  658. !         }
  659. !         }
  660. !       string = concat (string, "/", entry->filename);
  661. !       if (trace_files) fprintf (stderr, "Look for %s\n", string);
  662.         desc = open (string, O_RDONLY, 0);
  663.         if (desc > 0)
  664.           {
  665. ***************
  666. *** 1678,1684 ****
  667.       }
  668.     return result;
  669.   }
  670. ! 
  671.   /* Medium-level input routines for rel files.  */
  672.   
  673.   /* Determine whether the given ENTRY is an archive, a BSD a.out file,
  674. --- 1815,1821 ----
  675.       }
  676.     return result;
  677.   }
  678. ! 
  679.   /* Medium-level input routines for rel files.  */
  680.   
  681.   /* Determine whether the given ENTRY is an archive, a BSD a.out file,
  682. ***************
  683. *** 2044,2050 ****
  684.     if (entry->strs_size != read (desc, entry->strings, entry->strs_size))
  685.       fatal_with_file ("premature end of file in strings of ", entry);
  686.   }
  687. ! 
  688.   /* Read in the symbols of all input files.  */
  689.   
  690.   void read_file_symbols (), read_entry_symbols (), read_entry_strings ();
  691. --- 2181,2187 ----
  692.     if (entry->strs_size != read (desc, entry->strings, entry->strs_size))
  693.       fatal_with_file ("premature end of file in strings of ", entry);
  694.   }
  695. ! 
  696.   /* Read in the symbols of all input files.  */
  697.   
  698.   void read_file_symbols (), read_entry_symbols (), read_entry_strings ();
  699. ***************
  700. *** 2097,2103 ****
  701.   
  702.     file_close ();
  703.   }
  704. ! 
  705.   /* Enter the external symbol defs and refs of ENTRY in the hash table.  */
  706.   
  707.   void
  708. --- 2234,2240 ----
  709.   
  710.     file_close ();
  711.   }
  712. ! 
  713.   /* Enter the external symbol defs and refs of ENTRY in the hash table.  */
  714.   
  715.   void
  716. ***************
  717. *** 2375,2381 ****
  718.     return 0;
  719.   }
  720.   
  721. ! 
  722.   /* Searching libraries */
  723.   
  724.   struct file_entry *decode_library_subfile ();
  725. --- 2512,2518 ----
  726.     return 0;
  727.   }
  728.   
  729. ! 
  730.   /* Searching libraries */
  731.   
  732.   struct file_entry *decode_library_subfile ();
  733. ***************
  734. *** 2452,2459 ****
  735. --- 2589,2621 ----
  736.          && hdr1.ar_name[namelen] != '/';
  737.          namelen++);
  738.   
  739. + /* JPB, 7 Jun 1992: Support for long file names. Set the global variable
  740. +                     ar_hdr_size to the real length of the header.
  741. +                     The code for extracting the long name is pretty much stolen
  742. +                     from the BSD ar (archive.c, version 5.7).
  743. +                     This is a *really* ugly hack!
  744. + */
  745. + #if 1
  746. +   ar_hdr_size = sizeof(struct ar_hdr);
  747. +   if (!bcmp(hdr1.ar_name,AR_EFMT1,sizeof(AR_EFMT1) -1))
  748. +   {
  749. +     namelen = atoi(hdr1.ar_name + sizeof(AR_EFMT1) -1);
  750. +     if (namelen <= 0 || namelen > MAXNAMLEN)
  751. +       fatal_with_file("malformatted long name of archive member in ",library_entry);
  752. +     ar_hdr_size += namelen;
  753. +     name = (char *) xmalloc (namelen+1);
  754. +     if (read(desc,name,namelen) != namelen)
  755. +       fatal_with_file("malformatted long name of archive member in ",library_entry);
  756. +   }
  757. +   else
  758. +   {
  759. +     name = (char *) xmalloc (namelen+1);
  760. +     strncpy (name, hdr1.ar_name, namelen);
  761. +   }
  762. + #else
  763.     name = (char *) xmalloc (namelen+1);
  764.     strncpy (name, hdr1.ar_name, namelen);
  765. + #endif
  766.     name[namelen] = 0;
  767.   
  768.     subentry->filename = name;
  769. ***************
  770. *** 2461,2467 ****
  771. --- 2623,2633 ----
  772.     subentry->symbols = 0;
  773.     subentry->strings = 0;
  774.     subentry->subfiles = 0;
  775. + #if 1
  776. +   subentry->starting_offset = subfile_offset + ar_hdr_size;
  777. + #else
  778.     subentry->starting_offset = subfile_offset + sizeof hdr1;
  779. + #endif
  780.     subentry->superfile = library_entry;
  781.     subentry->library_flag = 0;
  782.     subentry->header_read_flag = 0;
  783. ***************
  784. *** 2473,2479 ****
  785.   
  786.     return subentry;
  787.   }
  788. ! 
  789.   int subfile_wanted_p ();
  790.   
  791.   /* Search a library that has a __.SYMDEF member.
  792. --- 2639,2645 ----
  793.   
  794.     return subentry;
  795.   }
  796. ! 
  797.   int subfile_wanted_p ();
  798.   
  799.   /* Search a library that has a __.SYMDEF member.
  800. ***************
  801. *** 2622,2628 ****
  802.   
  803.     free (symdef_data);
  804.   }
  805. ! 
  806.   
  807.   /* Handle a subentry for a file with no __.SYMDEF. */
  808.   
  809. --- 2788,2794 ----
  810.   
  811.     free (symdef_data);
  812.   }
  813. ! 
  814.   
  815.   /* Handle a subentry for a file with no __.SYMDEF. */
  816.   
  817. ***************
  818. *** 2675,2685 ****
  819.         if (!subentry) return;
  820.   
  821.         process_subentry (desc, subentry, entry, &prev);
  822.         this_subfile_offset += member_length + sizeof (struct ar_hdr);
  823.         if (this_subfile_offset & 1) this_subfile_offset++;
  824.       }
  825.   }
  826. ! 
  827.   /* ENTRY is an entry for a library member.
  828.      Its symbols have been read into core, but not entered.
  829.      Return nonzero if we ought to load this member.  */
  830. --- 2841,2859 ----
  831.         if (!subentry) return;
  832.   
  833.         process_subentry (desc, subentry, entry, &prev);
  834. + #if 1
  835. + /* JPB, 7 Jun 1992: Can't count on sizeof(ar_hdr) to be the size of the entire
  836. +                     header: Long names extends the header. This is a *really*
  837. +                     ugly hack, using a global variable! */
  838. + 
  839. +       this_subfile_offset += member_length + ar_hdr_size;
  840. + #else
  841.         this_subfile_offset += member_length + sizeof (struct ar_hdr);
  842. + #endif
  843.         if (this_subfile_offset & 1) this_subfile_offset++;
  844.       }
  845.   }
  846. ! 
  847.   /* ENTRY is an entry for a library member.
  848.      Its symbols have been read into core, but not entered.
  849.      Return nonzero if we ought to load this member.  */
  850. ***************
  851. *** 2777,2783 ****
  852.   
  853.     return 0;
  854.   }
  855. ! 
  856.   void consider_file_section_lengths (), relocate_file_addresses ();
  857.   
  858.   /* Having entered all the global symbols and found the sizes of sections
  859. --- 2951,2957 ----
  860.   
  861.     return 0;
  862.   }
  863. ! 
  864.   void consider_file_section_lengths (), relocate_file_addresses ();
  865.   
  866.   /* Having entered all the global symbols and found the sizes of sections
  867. ***************
  868. *** 2800,2806 ****
  869. --- 2974,2984 ----
  870.   
  871.     initialize_text_start ();
  872.   
  873. + #ifdef HUNK_INSTEAD_OF_A_OUT
  874. +   text_size = 0;
  875. + #else
  876.     text_size = text_header_size;
  877. + #endif
  878.   
  879.     /* Compute total size of sections */
  880.   
  881. ***************
  882. *** 2809,2825 ****
  883. --- 2987,3023 ----
  884.     /* If necessary, pad text section to full page in the file.
  885.        Include the padding in the text segment size.  */
  886.   
  887. + #ifndef HUNK_INSTEAD_OF_A_OUT
  888.     if (output_style == OUTPUT_READONLY_TEXT || output_style == OUTPUT_DEMAND_PAGED)
  889.       {
  890.         text_pad = ((text_size + page_size - 1) & (- page_size)) - text_size;
  891.         text_size += text_pad;
  892.       }
  893. + #endif
  894. + 
  895. + #ifdef HUNK_INSTEAD_OF_A_OUT
  896. +   /* they go into text if they are required */
  897. +   if (output_datadata_relocs && numdatadata_relocs)
  898. +     {
  899. +       if (datadata_reloc_symbol)
  900. +         datadata_reloc_symbol->value = text_size;
  901. +       
  902. +       /* 1 long for the size, then the vector */
  903. +       text_size += (1 + numdatadata_relocs) * 4;
  904. +     }
  905. + #endif
  906.   
  907.     /* Now that the text_size is known, initialize the data start address;
  908.        this depends on text_size as well as the output file format.  */
  909.   
  910.     initialize_data_start ();
  911.   
  912. + #ifdef HUNK_INSTEAD_OF_A_OUT
  913. +   data_pad = 0;
  914. + #endif
  915. + 
  916. + 
  917. + #ifndef HUNK_INSTEAD_OF_A_OUT
  918.     /* Make sure bss starts out aligned as much as anyone can want.  */
  919.     {
  920.       int new_data_size = (data_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  921. ***************
  922. *** 2827,2832 ****
  923. --- 3025,3031 ----
  924.       data_pad += new_data_size - data_size;
  925.       data_size = new_data_size;
  926.     }
  927. + #endif
  928.   
  929.     /* Set up the set element vector */
  930.   
  931. ***************
  932. *** 2836,2843 ****
  933. --- 3035,3049 ----
  934.            for each symbol for the length word at the beginning of the
  935.        vector, plus a word for each symbol for a zero at the end of
  936.        the vector (for incremental linking).  */
  937. + #if 0
  938. +       /* I think this is the other way round !? ### mw */
  939. + 
  940.         set_sect_size
  941.       = (2 * set_symbol_count + set_vector_count) * sizeof (unsigned long);
  942. + #else
  943. +       set_sect_size
  944. +     = (2 * set_vector_count + set_symbol_count) * sizeof (unsigned long);
  945. + #endif
  946.         set_sect_start = data_start + data_size;
  947.         data_size += set_sect_size;
  948.         set_vectors = (unsigned long *) xmalloc (set_sect_size);
  949. ***************
  950. *** 2931,2937 ****
  951. --- 3137,3149 ----
  952.                     + (align - 1)) & (- align))
  953.                     - data_size - data_start);
  954.   
  955. + #ifdef HUNK_INSTEAD_OF_A_OUT
  956. +           sp->value = bss_size;
  957. +           if (databss_together)
  958. +             sp->value += data_start + data_size;
  959. + #else
  960.             sp->value = data_start + data_size + bss_size;
  961. + #endif
  962.             sp->defined = N_BSS | N_EXT;
  963.             bss_size += com;
  964.             if (write_map)
  965. ***************
  966. *** 2994,2999 ****
  967. --- 3206,3224 ----
  968.         etext_symbol_alt->value = etext_value;
  969.     }
  970.   
  971. + #ifdef amigados
  972. +   {
  973. +     if (sdata_symbol)
  974. +       sdata_symbol->value = data_start;
  975. +     if (text_size_symbol)
  976. +       text_size_symbol->value = text_size;
  977. +     if (data_size_symbol)
  978. +       data_size_symbol->value = data_size;
  979. +     if (bss_size_symbol)
  980. +       bss_size_symbol->value  = bss_size;
  981. +   }
  982. + #endif
  983. + 
  984.     {
  985.       int edata_value = data_start + data_size;
  986.       if (edata_symbol)
  987. ***************
  988. *** 3013,3021 ****
  989. --- 3238,3248 ----
  990.       if (specified_data_size && specified_data_size > data_size)
  991.         data_pad_additional = specified_data_size - data_size;
  992.   
  993. + #ifndef HUNK_INSTEAD_OF_A_OUT
  994.       if (output_style == OUTPUT_DEMAND_PAGED)
  995.         data_pad_additional =
  996.       ((data_pad_additional + data_size + page_size - 1) & (- page_size)) - data_size;
  997. + #endif
  998.   
  999.       bss_size -= data_pad_additional;
  1000.       if (bss_size < 0) bss_size = 0;
  1001. ***************
  1002. *** 3024,3031 ****
  1003.   
  1004.       data_pad += data_pad_additional;
  1005.     }
  1006.   }
  1007. ! 
  1008.   /* Accumulate the section sizes of input file ENTRY
  1009.      into the section sizes of the output file.  */
  1010.   
  1011. --- 3251,3290 ----
  1012.   
  1013.       data_pad += data_pad_additional;
  1014.     }
  1015. + 
  1016. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1017. +   /* if there is some code, assign it next hunk_number */
  1018. +   if (text_size)
  1019. +      number_of_code_hunk = current_hunk++;
  1020. +   else
  1021. +      number_of_code_hunk = -1;
  1022. + 
  1023. +   if (data_size)
  1024. +      number_of_data_hunk = current_hunk++;
  1025. +   else
  1026. +      number_of_data_hunk = -1;
  1027. + 
  1028. +   if (bss_size)
  1029. +      number_of_bss_hunk  = current_hunk++;
  1030. +   else
  1031. +      number_of_bss_hunk  = -1;
  1032. + 
  1033. +   if (databss_together)
  1034. +     {
  1035. +       if (data_size && bss_size)
  1036. +     {
  1037. +       current_hunk --;
  1038. +       number_of_bss_hunk = number_of_data_hunk;
  1039. +     }
  1040. +     }
  1041. + 
  1042. +   if (strip_symbols != STRIP_ALL && !amiga_symbols_only)
  1043. +      number_of_debug_hunk = current_hunk++;
  1044. +   else
  1045. +      number_of_debug_hunk = -1;
  1046. + #endif
  1047.   }
  1048. ! 
  1049.   /* Accumulate the section sizes of input file ENTRY
  1050.      into the section sizes of the output file.  */
  1051.   
  1052. ***************
  1053. *** 3046,3051 ****
  1054. --- 3305,3334 ----
  1055.   
  1056.     text_reloc_size += entry->text_reloc_size;
  1057.     data_reloc_size += entry->data_reloc_size;
  1058. + 
  1059. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1060. +   if (! output_datadata_relocs)
  1061. +     return;
  1062. + 
  1063. +   /* have to guess at how many datadata-relocs we might have. This number
  1064. +      is larger than the real thing, because I have to include the references
  1065. +      to UNDF symbols as well. */
  1066. +   {
  1067. +     struct relocation_info *r, *re, *reloc;
  1068. +     int desc = file_open (entry);
  1069. + 
  1070. +     reloc = (struct relocation_info *) alloca (entry->data_reloc_size);
  1071. +     lseek (desc, entry->starting_offset + entry->data_reloc_offset, L_SET);
  1072. +     if (entry->data_reloc_size != read (desc, reloc, entry->data_reloc_size))
  1073. +       fatal_with_file ("premature eof in data relocation of ", entry);
  1074. +     
  1075. +     for (r = reloc, re = reloc + entry->data_reloc_size/sizeof(*re); r < re; r++)
  1076. +       if (RELOC_EXTERN_P (r) || ((RELOC_TYPE (r) & N_TYPE) != N_TEXT))
  1077. +     numdatadata_relocs ++;
  1078. + 
  1079. +     file_close ();
  1080. +   }
  1081. + #endif
  1082.   }
  1083.   
  1084.   /* Determine where the sections of ENTRY go into the output file,
  1085. ***************
  1086. *** 3062,3068 ****
  1087.        for the portion of data_pad which overlaps with bss.  If they had
  1088.        been, we would get the wrong results here.  */
  1089.     entry->data_start_address += data_start;
  1090. !   entry->bss_start_address += data_start + data_size;
  1091.   
  1092.     {
  1093.       register struct nlist *p;
  1094. --- 3345,3356 ----
  1095.        for the portion of data_pad which overlaps with bss.  If they had
  1096.        been, we would get the wrong results here.  */
  1097.     entry->data_start_address += data_start;
  1098. ! 
  1099. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1100. !   if (databss_together)
  1101. ! #endif
  1102. !     entry->bss_start_address += data_start + data_size;
  1103. ! 
  1104.   
  1105.     {
  1106.       register struct nlist *p;
  1107. ***************
  1108. *** 3080,3087 ****
  1109.         case N_SETT:
  1110.           p->n_value += entry->text_start_address - entry->orig_text_address;
  1111.           break;
  1112. -       case N_DATA:
  1113.         case N_SETV:
  1114.         case N_SETD:
  1115.           /* Data segment symbol.  Subtract the address of the
  1116.              data segment in the input file, and add the address
  1117. --- 3368,3375 ----
  1118.         case N_SETT:
  1119.           p->n_value += entry->text_start_address - entry->orig_text_address;
  1120.           break;
  1121.         case N_SETV:
  1122. +       case N_DATA:
  1123.         case N_SETD:
  1124.           /* Data segment symbol.  Subtract the address of the
  1125.              data segment in the input file, and add the address
  1126. ***************
  1127. *** 3098,3104 ****
  1128.         }
  1129.     }
  1130.   }
  1131. ! 
  1132.   void describe_file_sections (), list_file_locals ();
  1133.   
  1134.   /* Print a complete or partial map of the output file.  */
  1135. --- 3386,3392 ----
  1136.         }
  1137.     }
  1138.   }
  1139. ! 
  1140.   void describe_file_sections (), list_file_locals ();
  1141.   
  1142.   /* Print a complete or partial map of the output file.  */
  1143. ***************
  1144. *** 3174,3180 ****
  1145.     entry->strings = 0;        /* All done with them.  */
  1146.   }
  1147.   
  1148. ! 
  1149.   /* Static vars for do_warnings and subroutines of it */
  1150.   int list_unresolved_refs;    /* List unresolved refs */
  1151.   int list_warning_symbols;    /* List warning syms */
  1152. --- 3462,3468 ----
  1153.     entry->strings = 0;        /* All done with them.  */
  1154.   }
  1155.   
  1156. ! 
  1157.   /* Static vars for do_warnings and subroutines of it */
  1158.   int list_unresolved_refs;    /* List unresolved refs */
  1159.   int list_warning_symbols;    /* List warning syms */
  1160. ***************
  1161. *** 3192,3198 ****
  1162.     struct nlist *sym;
  1163.   };
  1164.   
  1165. - void qsort ();
  1166.   /*
  1167.    * Helper routines for do_file_warnings.
  1168.    */
  1169. --- 3480,3485 ----
  1170. ***************
  1171. *** 3672,3678 ****
  1172.     free (data_scan);
  1173.     entry->strings = 0;        /* Since it will dissapear anyway.  */
  1174.   }
  1175. ! 
  1176.   do_warnings (outfile)
  1177.        FILE *outfile;
  1178.   {
  1179. --- 3959,3965 ----
  1180.     free (data_scan);
  1181.     entry->strings = 0;        /* Since it will dissapear anyway.  */
  1182.   }
  1183. ! 
  1184.   do_warnings (outfile)
  1185.        FILE *outfile;
  1186.   {
  1187. ***************
  1188. *** 3691,3697 ****
  1189.     if (list_unresolved_refs || list_multiple_defs)
  1190.       make_executable = 0;
  1191.   }
  1192. ! 
  1193.   #ifdef A_OUT
  1194.   
  1195.   /* Stuff pertaining to creating a.out files. */
  1196. --- 3978,3984 ----
  1197.     if (list_unresolved_refs || list_multiple_defs)
  1198.       make_executable = 0;
  1199.   }
  1200. ! 
  1201.   #ifdef A_OUT
  1202.   
  1203.   /* Stuff pertaining to creating a.out files. */
  1204. ***************
  1205. *** 3712,3717 ****
  1206. --- 3999,4009 ----
  1207.   {
  1208.     int magic;
  1209.   
  1210. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1211. +   text_start = 0;
  1212. +   return;
  1213. + #endif
  1214. + 
  1215.     switch (output_style)
  1216.       {
  1217.       case OUTPUT_RELOCATABLE:
  1218. ***************
  1219. *** 3770,3775 ****
  1220. --- 4062,4072 ----
  1221.   void
  1222.   initialize_a_out_data_start ()
  1223.   {
  1224. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1225. +   data_start = 0;
  1226. +   return;
  1227. + #endif
  1228. + 
  1229.     outheader.a_text = text_size;
  1230.   #ifdef sequent
  1231.     outheader.a_text += N_ADDRADJ (outheader);
  1232. ***************
  1233. *** 3923,3947 ****
  1234.   void
  1235.   write_a_out_header ()
  1236.   {
  1237. !   lseek (outdesc, 0L, 0);
  1238.   
  1239.   #ifdef COFF_ENCAPSULATE
  1240.     if (need_coff_header)
  1241. !     mywrite (&coffheader, sizeof coffheader, 1, outdesc);
  1242.   #endif
  1243.   
  1244. !   mywrite (&outheader, sizeof (struct exec), 1, outdesc);
  1245.   
  1246.     /* Output whatever padding is required in the executable file
  1247.        between the header and the start of the text.  */
  1248.   
  1249.   #ifndef COFF_ENCAPSULATE
  1250. !   padfile (N_TXTOFF (outheader) - sizeof outheader, outdesc);
  1251.   #endif
  1252.   }
  1253.   
  1254.   #endif
  1255. ! 
  1256.   #ifdef MACH_O
  1257.   
  1258.   /* Stuff pertaining to creating Mach-O files. */
  1259. --- 4220,4244 ----
  1260.   void
  1261.   write_a_out_header ()
  1262.   {
  1263. !   fseek (outstream, 0L, 0);
  1264.   
  1265.   #ifdef COFF_ENCAPSULATE
  1266.     if (need_coff_header)
  1267. !     mywrite (&coffheader, sizeof coffheader, 1, outstream);
  1268.   #endif
  1269.   
  1270. !   mywrite (&outheader, sizeof (struct exec), 1, outstream);
  1271.   
  1272.     /* Output whatever padding is required in the executable file
  1273.        between the header and the start of the text.  */
  1274.   
  1275.   #ifndef COFF_ENCAPSULATE
  1276. !   padfile (N_TXTOFF (outheader) - sizeof outheader, outstream);
  1277.   #endif
  1278.   }
  1279.   
  1280.   #endif
  1281. ! 
  1282.   #ifdef MACH_O
  1283.   
  1284.   /* Stuff pertaining to creating Mach-O files. */
  1285. ***************
  1286. *** 4145,4151 ****
  1287.   #endif
  1288.     thread_state state;
  1289.   
  1290. !   lseek (outdesc, 0L, 0);
  1291.   
  1292.   
  1293.     header.magic = MH_MAGIC;
  1294. --- 4442,4448 ----
  1295.   #endif
  1296.     thread_state state;
  1297.   
  1298. !   fseek (outstream, 0L, 0);
  1299.   
  1300.   
  1301.     header.magic = MH_MAGIC;
  1302. ***************
  1303. *** 4251,4257 ****
  1304.   #ifdef LC_SYMSEG
  1305.         m_object.symseg = symseg;
  1306.   #endif
  1307. !       mywrite((char *) &m_object, 1, sizeof m_object, outdesc);
  1308.         break;
  1309.   
  1310.       default:
  1311. --- 4548,4554 ----
  1312.   #ifdef LC_SYMSEG
  1313.         m_object.symseg = symseg;
  1314.   #endif
  1315. !       mywrite((char *) &m_object, 1, sizeof m_object, outstream);
  1316.         break;
  1317.   
  1318.       default:
  1319. ***************
  1320. *** 4305,4311 ****
  1321.   #ifdef LC_SYMSEG
  1322.         m_exec.symseg = symseg;
  1323.   #endif
  1324. !       mywrite((char *) &m_exec, 1, sizeof m_exec, outdesc);
  1325.         break;
  1326.       }
  1327.   }
  1328. --- 4602,4608 ----
  1329.   #ifdef LC_SYMSEG
  1330.         m_exec.symseg = symseg;
  1331.   #endif
  1332. !       mywrite((char *) &m_exec, 1, sizeof m_exec, outstream);
  1333.         break;
  1334.       }
  1335.   }
  1336. ***************
  1337. *** 4386,4392 ****
  1338.   }
  1339.   
  1340.   #endif
  1341. ! 
  1342.   /* The following functions are simple switches according to the
  1343.      output style.  */
  1344.   
  1345. --- 4683,4689 ----
  1346.   }
  1347.   
  1348.   #endif
  1349. ! 
  1350.   /* The following functions are simple switches according to the
  1351.      output style.  */
  1352.   
  1353. ***************
  1354. *** 4484,4489 ****
  1355. --- 4781,4790 ----
  1356.   void
  1357.   write_header ()
  1358.   {
  1359. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1360. +   conditionally_rewrite_headers ();
  1361. +   return;
  1362. + #else
  1363.   #ifdef A_OUT
  1364.     if (output_file_type == IS_A_OUT)
  1365.       {
  1366. ***************
  1367. *** 4498,4506 ****
  1368.         return;
  1369.       }
  1370.   #endif
  1371.     fatal ("unknown output file type (enum file_type)", (char *) 0);
  1372.   }
  1373. ! 
  1374.   /* Write the output file */
  1375.   
  1376.   void
  1377. --- 4799,4808 ----
  1378.         return;
  1379.       }
  1380.   #endif
  1381. + #endif
  1382.     fatal ("unknown output file type (enum file_type)", (char *) 0);
  1383.   }
  1384. ! 
  1385.   /* Write the output file */
  1386.   
  1387.   void
  1388. ***************
  1389. *** 4519,4540 ****
  1390.        the way Unix ld works; I'm going to consider it a feature.  */
  1391.     (void) unlink (output_filename);
  1392.     
  1393. !   outdesc = open (output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  1394. !   if (outdesc < 0) perror_name (output_filename);
  1395.   
  1396. !   if (fstat (outdesc, &statbuf) < 0)
  1397.       perror_name (output_filename);
  1398.   
  1399.     filemode = statbuf.st_mode;
  1400.   
  1401.     chmod (output_filename, filemode & ~0111);
  1402.   
  1403.     /* Calculate the offsets of the various pieces of the output file.  */
  1404.     compute_section_offsets ();
  1405.   
  1406.     /* Output the text and data segments, relocating as we go.  */
  1407.     write_text ();
  1408.     write_data ();
  1409.   
  1410.     /* Output the merged relocation info, if requested with `-r'.  */
  1411.     if (output_style == OUTPUT_RELOCATABLE)
  1412. --- 4821,4888 ----
  1413.        the way Unix ld works; I'm going to consider it a feature.  */
  1414.     (void) unlink (output_filename);
  1415.     
  1416. !   outstream = fopen (output_filename, "w");
  1417. !   if (outstream == 0) perror_name (output_filename);
  1418.   
  1419. ! #ifndef MCH_AMIGA
  1420. !   if (fstat (fileno (outstream), &statbuf) < 0)
  1421.       perror_name (output_filename);
  1422.   
  1423.     filemode = statbuf.st_mode;
  1424.   
  1425. +   /* this wouldn't work anyway, "file in use, error"... */
  1426.     chmod (output_filename, filemode & ~0111);
  1427. + #endif
  1428. + 
  1429. +   /* on the Amiga, the following call DOES set the symbol offset, but
  1430. +    * it does it wrong, we'll be able to do it right, as soon as all the
  1431. +    * other data has been written.. */
  1432.   
  1433.     /* Calculate the offsets of the various pieces of the output file.  */
  1434.     compute_section_offsets ();
  1435.   
  1436. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1437. +   /* get ready to collect information where all symbols
  1438. +    * go. Since this has to be done only once, we'll later be able to 
  1439. +    * output the right symbol-hunk after the right (code/data/bss-)hunk. */
  1440. +   init_symbol_hunks ();
  1441. +   look_for_symbols ();
  1442. + #endif
  1443. + 
  1444.     /* Output the text and data segments, relocating as we go.  */
  1445.     write_text ();
  1446.     write_data ();
  1447. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1448. +   if (datadata_relocs_offset)
  1449. +     write_datadata_relocs ();
  1450. + 
  1451. +   write_bss ();
  1452. +   if (number_of_debug_hunk != -1)
  1453. +     {
  1454. +       /* ok, lets output the start of the debug hunk */
  1455. +       fseek (outstream, 0L, SEEK_END);
  1456. +       offset_of_debug_hunk = ftell (outstream);
  1457. + 
  1458. +       dh.id = 0x3f1;     /* HUNK_DEBUG */
  1459. +       dh.len = 0;        /* we'll fill this in later */
  1460. +       dh.magic = ZMAGIC; /* when wishes came true... */
  1461. +       dh.syms = outheader.a_syms;
  1462. +       mywrite(&dh, sizeof dh, 1, outstream);
  1463. + 
  1464. +       output_syms_offset   = ftell (outstream);
  1465. +       output_strs_offset   = output_syms_offset + dh.syms;
  1466. + 
  1467. +       /* since we later will seek forward and backward to fill in each files
  1468. +        * symbol- and string-table, we have to create the needed space, that
  1469. +        * will be seeked over, since on an empty file, lseek(fd, 10, 0) will 
  1470. +        * position to byte 10 on Unix, but will just generate an error under
  1471. +        * AmigaDOS and stay at position 0. */
  1472. + 
  1473. +       /* this will just write garbage, but thats enough:-)) */
  1474. +       mywrite(&output_strs_offset, dh.syms+4, 1, outstream);
  1475. +       fseek (outstream, output_syms_offset, 0);
  1476. +     }
  1477. + #endif
  1478.   
  1479.     /* Output the merged relocation info, if requested with `-r'.  */
  1480.     if (output_style == OUTPUT_RELOCATABLE)
  1481. ***************
  1482. *** 4547,4568 ****
  1483.        are finalized.  */
  1484.     compute_more_section_offsets ();
  1485.   
  1486.     /* Copy any GDB symbol segments from input files.  */
  1487.     write_symsegs ();
  1488.   
  1489.     /* Now that everything is known about the output file, write its header.  */
  1490.     write_header ();
  1491.   
  1492. !   close (outdesc);
  1493.   
  1494.     mask = umask (0);
  1495.     umask (mask);
  1496.   
  1497.     if (chmod (output_filename, filemode | (0111 & ~mask)) == -1)
  1498.       perror_name (output_filename);
  1499.   }
  1500. ! 
  1501.   void modify_location (), perform_relocation (), copy_text (), copy_data ();
  1502.   
  1503.   /* Relocate the text segment of each input file
  1504.      and write to the output file.  */
  1505. --- 4895,4928 ----
  1506.        are finalized.  */
  1507.     compute_more_section_offsets ();
  1508.   
  1509. + #ifndef HUNK_INSTEAD_OF_A_OUT
  1510. +   /* I don't support GDB-symbol segments, they aren't used anymore by
  1511. +    * the newer versions of gdb, BUT of course, if somebody needs them..
  1512. +    * that's exactly why I introduced the "dh.strs" Parameter, so that
  1513. +    * you could - as in Unix - append these segments at the end of the file */
  1514. + 
  1515.     /* Copy any GDB symbol segments from input files.  */
  1516.     write_symsegs ();
  1517. + #endif
  1518.   
  1519.     /* Now that everything is known about the output file, write its header.  */
  1520.     write_header ();
  1521.   
  1522. !   fclose (outstream);
  1523.   
  1524. + #ifndef HUNK_INSTEAD_OF_A_OUT
  1525.     mask = umask (0);
  1526.     umask (mask);
  1527.   
  1528.     if (chmod (output_filename, filemode | (0111 & ~mask)) == -1)
  1529.       perror_name (output_filename);
  1530. + #endif
  1531.   }
  1532. ! 
  1533.   void modify_location (), perform_relocation (), copy_text (), copy_data ();
  1534. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1535. + void write_hunk_header();
  1536. + #endif
  1537.   
  1538.   /* Relocate the text segment of each input file
  1539.      and write to the output file.  */
  1540. ***************
  1541. *** 4573,4587 ****
  1542.     if (trace_files)
  1543.       fprintf (stderr, "Copying and relocating text:\n\n");
  1544.   
  1545. !   lseek (outdesc, output_text_offset + text_header_size, 0);
  1546.   
  1547.     each_full_file (copy_text, 0);
  1548.     file_close ();
  1549.   
  1550.     if (trace_files)
  1551.       fprintf (stderr, "\n");
  1552.   
  1553. !   padfile (text_pad, outdesc);
  1554.   }
  1555.   
  1556.   /* Read in all of the relocation information */
  1557. --- 4933,4987 ----
  1558.     if (trace_files)
  1559.       fprintf (stderr, "Copying and relocating text:\n\n");
  1560.   
  1561. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1562. !   /* this is a definitive write, we don't need to rewrite this out, since
  1563. !    * the yet undefined sizes of the reloc-hunks don't go into the 
  1564. !    * header-hunk */
  1565. !   write_hunk_header(outstream);
  1566. !   init_reloc_hunk();
  1567. ! 
  1568. !   /* and if there's no code-hunk, we can return here.. no sense in
  1569. !    * complicately doing just nothing... */
  1570. !   if (number_of_code_hunk == -1) return;
  1571. ! 
  1572. !   /* else start the code-hunk */
  1573. !   {
  1574. !      long code_header[2];
  1575. !      code_header[0] = 0x3e9;
  1576. !      code_header[1] = LONGSIZE(text_size);
  1577. !      mywrite(code_header, 1, sizeof code_header, outstream);
  1578. !   }
  1579. ! #else
  1580. !   fseek (outstream, output_text_offset + text_header_size, 0);
  1581. ! #endif
  1582.   
  1583.     each_full_file (copy_text, 0);
  1584. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1585. +   if (output_datadata_relocs && numdatadata_relocs)
  1586. +     {
  1587. +       int i, zero = 0;
  1588. +       /* include the size-field, -> <= . The `real' values come later */
  1589. +       datadata_relocs_offset = ftell (outstream);
  1590. +       for (i = 0; i <= numdatadata_relocs; i ++)
  1591. +         mywrite (&zero, 1, sizeof (long), outstream);
  1592. +     }
  1593. + #endif
  1594. + 
  1595.     file_close ();
  1596.   
  1597.     if (trace_files)
  1598.       fprintf (stderr, "\n");
  1599.   
  1600. !   padfile (text_pad, outstream);
  1601. ! 
  1602. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1603. !   write_reloc_hunk();
  1604. !   write_symbol_hunk(number_of_code_hunk);
  1605. !   {
  1606. !     long hunk_end = 0x3f2;
  1607. !     mywrite(&hunk_end, 1, sizeof(long), outstream);
  1608. !   }
  1609. ! #endif
  1610.   }
  1611.   
  1612.   /* Read in all of the relocation information */
  1613. ***************
  1614. *** 4686,4700 ****
  1615.       fatal_with_file ("premature eof in text section of ", entry);
  1616.   
  1617.     /* Relocate the text according to the text relocation.  */
  1618. - 
  1619.     perform_relocation (bytes, entry->text_start_address - entry->orig_text_address,
  1620.                 entry->text_size, reloc, entry->text_reloc_size, entry);
  1621.   
  1622.     /* Write the relocated text to the output file.  */
  1623.   
  1624. !   mywrite (bytes, 1, entry->text_size, outdesc);
  1625.   }
  1626. ! 
  1627.   /* Relocate the data segment of each input file
  1628.      and write to the output file.  */
  1629.   
  1630. --- 5086,5099 ----
  1631.       fatal_with_file ("premature eof in text section of ", entry);
  1632.   
  1633.     /* Relocate the text according to the text relocation.  */
  1634.     perform_relocation (bytes, entry->text_start_address - entry->orig_text_address,
  1635.                 entry->text_size, reloc, entry->text_reloc_size, entry);
  1636.   
  1637.     /* Write the relocated text to the output file.  */
  1638.   
  1639. !   mywrite (bytes, 1, entry->text_size, outstream);
  1640.   }
  1641. ! 
  1642.   /* Relocate the data segment of each input file
  1643.      and write to the output file.  */
  1644.   
  1645. ***************
  1646. *** 4704,4710 ****
  1647.     if (trace_files)
  1648.       fprintf (stderr, "Copying and relocating data:\n\n");
  1649.   
  1650. !   lseek (outdesc, output_data_offset, 0);
  1651.   
  1652.     each_full_file (copy_data, 0);
  1653.     file_close ();
  1654. --- 5103,5126 ----
  1655.     if (trace_files)
  1656.       fprintf (stderr, "Copying and relocating data:\n\n");
  1657.   
  1658. ! #ifndef HUNK_INSTEAD_OF_A_OUT
  1659. !   fseek (outstream, output_data_offset, 0);
  1660. ! #else
  1661. !   /* just have to hope that the file is positioned correctly.. */
  1662. !   init_reloc_hunk();
  1663. !   /* start a data-hunk, if there is data to be output */
  1664. !   if (number_of_data_hunk == -1) return;
  1665. ! 
  1666. !   {
  1667. !     long data_header[2];
  1668. !     data_header[0] = 0x3ea;
  1669. !     if (databss_together)
  1670. !       data_header[1] = LONGSIZE(data_size + bss_size);
  1671. !     else
  1672. !       data_header[1] = LONGSIZE(data_size);
  1673. !     mywrite(data_header, 1, sizeof data_header, outstream);
  1674. !   }
  1675. ! #endif
  1676.   
  1677.     each_full_file (copy_data, 0);
  1678.     file_close ();
  1679. ***************
  1680. *** 4713,4725 ****
  1681.        description of length of the set vector section.  */
  1682.   
  1683.     if (set_vector_count)
  1684. !     mywrite (set_vectors, 2 * set_symbol_count + set_vector_count,
  1685. !          sizeof (unsigned long), outdesc);
  1686.   
  1687.     if (trace_files)
  1688.       fprintf (stderr, "\n");
  1689.   
  1690. !   padfile (data_pad, outdesc);
  1691.   }
  1692.   
  1693.   /* Read the data segment contents of ENTRY, relocate them,
  1694. --- 5129,5172 ----
  1695.        description of length of the set vector section.  */
  1696.   
  1697.     if (set_vector_count)
  1698. !     {
  1699. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1700. !      /* this and mywrite later: inverted set_symbol_count and 
  1701. !       * set_vector_count, guess they were mixed up before   ### mw */
  1702. ! 
  1703. !       relocate_set_vectors (set_vectors,
  1704. !                 2 * set_vector_count + set_symbol_count);
  1705. ! #endif
  1706. ! #if 0
  1707. !       mywrite (set_vectors, 2 * set_symbol_count + set_vector_count,
  1708. !            sizeof (unsigned long), outstream);
  1709. ! #else
  1710. !       mywrite (set_vectors, 2 * set_vector_count + set_symbol_count,
  1711. !            sizeof (unsigned long), outstream);
  1712. ! #endif
  1713. !     }
  1714.   
  1715.     if (trace_files)
  1716.       fprintf (stderr, "\n");
  1717.   
  1718. !   padfile (data_pad, outstream);
  1719. ! 
  1720. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1721. !   if (databss_together && bss_size)
  1722. !     {
  1723. !       /* dump zeros */
  1724. !       int i, zero = 0;
  1725. !       for (i = 0; i < LONGSIZE(bss_size); i++)
  1726. !     mywrite (&zero, 1, sizeof (long), outstream);
  1727. !     }
  1728. ! 
  1729. !   write_reloc_hunk();
  1730. !   write_symbol_hunk(number_of_data_hunk);
  1731. !   {
  1732. !     long hunk_end = 0x3f2;
  1733. !     mywrite(&hunk_end, 1, sizeof(long), outstream);
  1734. !   }
  1735. ! #endif
  1736.   }
  1737.   
  1738.   /* Read the data segment contents of ENTRY, relocate them,
  1739. ***************
  1740. *** 4765,4776 ****
  1741.     if (entry->data_size != read (desc, bytes, entry->data_size))
  1742.       fatal_with_file ("premature eof in data section of ", entry);
  1743.   
  1744. !   perform_relocation (bytes, entry->data_start_address - entry->orig_data_address,
  1745. !               entry->data_size, reloc, entry->data_reloc_size, entry);
  1746.   
  1747. !   mywrite (bytes, 1, entry->data_size, outdesc);
  1748.   }
  1749. ! 
  1750.   /* Relocate ENTRY's text or data section contents.
  1751.      DATA is the address of the contents, in core.
  1752.      DATA_SIZE is the length of the contents.
  1753. --- 5212,5227 ----
  1754.     if (entry->data_size != read (desc, bytes, entry->data_size))
  1755.       fatal_with_file ("premature eof in data section of ", entry);
  1756.   
  1757. !   perform_relocation (bytes, entry->data_start_address 
  1758. ! #ifndef HUNK_INSTEAD_OF_A_OUT
  1759. !                         - entry->orig_data_address
  1760. ! #endif
  1761. !                                     ,
  1762. !                 entry->data_size, reloc, entry->data_reloc_size, entry);
  1763.   
  1764. !   mywrite (bytes, 1, entry->data_size, outstream);
  1765.   }
  1766. ! 
  1767.   /* Relocate ENTRY's text or data section contents.
  1768.      DATA is the address of the contents, in core.
  1769.      DATA_SIZE is the length of the contents.
  1770. ***************
  1771. *** 4796,4806 ****
  1772. --- 5247,5266 ----
  1773.     int data_relocation = entry->data_start_address - entry->orig_data_address;
  1774.     int bss_relocation = entry->bss_start_address - entry->orig_bss_address;
  1775.   
  1776. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1777. +   int this_hunk;
  1778. + #endif
  1779. + 
  1780.     for (; p < end; p++)
  1781.       {
  1782.         register int relocation = 0;
  1783.         register int addr = RELOC_ADDRESS(p);
  1784.         register unsigned int mask = 0;
  1785. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1786. +       int ext_abs;
  1787. +       
  1788. +       ext_abs = 0;
  1789. + #endif
  1790.   
  1791.         if (addr >= data_size)
  1792.       fatal_with_file ("relocation address out of range in ", entry);
  1793. ***************
  1794. *** 4827,4848 ****
  1795.           relocation = 0;
  1796.         else
  1797.           relocation = sp->value;
  1798.       }
  1799.         else switch (RELOC_TYPE(p))
  1800.       {
  1801.       case N_TEXT:
  1802.       case N_TEXT | N_EXT:
  1803. !       relocation = text_relocation;
  1804.         break;
  1805.   
  1806.       case N_DATA:
  1807.       case N_DATA | N_EXT:
  1808. !       relocation = data_relocation;
  1809.         break;
  1810.   
  1811.       case N_BSS:
  1812.       case N_BSS | N_EXT:
  1813. !       relocation = bss_relocation;
  1814.         break;
  1815.   
  1816.       case N_ABS:
  1817. --- 5287,5366 ----
  1818.           relocation = 0;
  1819.         else
  1820.           relocation = sp->value;
  1821. + 
  1822. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1823. +       if ((sp->defined & ~N_EXT) == N_ABS)
  1824. +         /* sort of a kludge.. the only external symbol (not pcrelative)
  1825. +              * we can really resolve.. */
  1826. +         ext_abs = 1;
  1827. +       else if ((sp->defined & ~N_EXT) == N_TEXT ||
  1828. +           (sp->defined & ~N_EXT) == N_SETT)
  1829. +         {
  1830. +           this_hunk = number_of_code_hunk;
  1831. +           if (RELOC_BASEREL_P (p))
  1832. +             {
  1833. +               fprintf (stderr, "symn = $%x, extern = %d, addr = $%lx.\n",
  1834. +                          p->r_symbolnum, p->r_extern, p->r_address);
  1835. +           fatal_with_file ("base relative text relocation in ", entry);
  1836. +         }
  1837. +         }
  1838. +       else if ((sp->defined & ~N_EXT) == N_DATA ||
  1839. +                (sp->defined & ~N_EXT) == N_SETD ||
  1840. +            (sp->defined & ~N_EXT) == N_SETV)
  1841. +         {
  1842. +           this_hunk = number_of_data_hunk;
  1843. +         }
  1844. +       else if ((sp->defined & ~N_EXT) == N_BSS ||
  1845. +            (sp->defined & ~N_EXT) == N_UNDF ||
  1846. +                (sp->defined & ~N_EXT) == N_SETB)
  1847. +         {
  1848. +           this_hunk = number_of_bss_hunk;
  1849. +         }
  1850. +       else    
  1851. +         fatal_with_file ("external symbol with unknown type $%x in ", entry, sp->defined);
  1852. + #endif
  1853.       }
  1854.         else switch (RELOC_TYPE(p))
  1855.       {
  1856.       case N_TEXT:
  1857.       case N_TEXT | N_EXT:
  1858. !       if (RELOC_BASEREL_P (p))
  1859. !         {
  1860. !           fprintf (stderr, "symn = $%x, extern = %d, addr = $%lx.\n",
  1861. !                      p->r_symbolnum, p->r_extern, p->r_address);
  1862. !           fatal_with_file ("base relative text relocation in ", entry);
  1863. !         }
  1864. !       else
  1865. !         relocation = text_relocation;
  1866. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1867. !       this_hunk = number_of_code_hunk;
  1868. ! #endif
  1869.         break;
  1870.   
  1871.       case N_DATA:
  1872.       case N_DATA | N_EXT:
  1873. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1874. !       if (RELOC_BASEREL_P (p))
  1875. !         relocation = entry->data_start_address;
  1876. !       else
  1877. ! #endif
  1878. !         relocation = data_relocation;
  1879. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1880. !       this_hunk = number_of_data_hunk;
  1881. ! #endif
  1882.         break;
  1883.   
  1884.       case N_BSS:
  1885.       case N_BSS | N_EXT:
  1886. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1887. !       if (RELOC_BASEREL_P (p))
  1888. !         relocation = entry->bss_start_address - entry->data_size;
  1889. !       else
  1890. ! #endif
  1891. !         relocation = bss_relocation;
  1892. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1893. !       this_hunk = number_of_bss_hunk;
  1894. ! #endif
  1895.         break;
  1896.   
  1897.       case N_ABS:
  1898. ***************
  1899. *** 4854,4862 ****
  1900. --- 5372,5405 ----
  1901.         fatal_with_file ("nonexternal relocation code invalid in ", entry);
  1902.       }
  1903.   
  1904. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1905. +       /* in this case, ONLY relocate those pc-relative 32bit jumps, that
  1906. +        * gas generates, since they are position independent, this gives
  1907. +        * a HUGE.. 'if' inside of '#ifdef' oh well... */
  1908. +       if (RELOC_PCREL_P(p) || RELOC_BASEREL_P(p) || ext_abs) {
  1909. +       
  1910. +       /* VERY BIG KLUDGE AHEAD! Since this amiga hunk format is really
  1911. +        * limited, 8bit and 16bit references are always defined to be
  1912. +        * pc-relative (according to the AmigaDOS RM 2nd ed). BUT if such
  1913. +        * a symbol is resolved by an absolute symbol then it's not considered
  1914. +        * to be pc-relative any more. This is nowhere documented, but you
  1915. +        * couldn't get
  1916. +        *   jsr _LVOOpen(a6)
  1917. +        * to work if you wouldn't do it this way. */
  1918. +        if (ext_abs) RELOC_PCREL_P(p) = 0;
  1919. +       
  1920. + #endif
  1921.         if (RELOC_PCREL_P(p))
  1922.       relocation -= pc_relocation;
  1923.   
  1924. +       /* if base relative, subtract 64k/2, so we get a larger range */
  1925. +       if (RELOC_BASEREL_P(p))
  1926. +     {
  1927. +       if (! databss_together)
  1928. +         fatal_with_file ("Reloc is base relative. Specify -databss-together in ", entry);
  1929. +       relocation -= 0x7ffe;
  1930. +     }
  1931. + 
  1932.   #ifdef RELOC_ADD_EXTRA
  1933.         relocation += RELOC_ADD_EXTRA(p);
  1934.         if (output_style == OUTPUT_RELOCATABLE)
  1935. ***************
  1936. *** 4895,4901 ****
  1937.         /* Shift everything up to where it's going to be used */
  1938.         relocation <<= RELOC_TARGET_BITPOS(p);
  1939.         mask <<= RELOC_TARGET_BITPOS(p);
  1940. - 
  1941.         switch (RELOC_TARGET_SIZE(p))
  1942.       {
  1943.       case 0:
  1944. --- 5438,5443 ----
  1945. ***************
  1946. *** 4903,4920 ****
  1947. --- 5445,5483 ----
  1948.           relocation -= mask & *(char *) (data + addr);
  1949.         else if (RELOC_MEMORY_ADD_P(p))
  1950.           relocation += mask & *(char *) (data + addr);
  1951. +       if (relocation < -128 || relocation > 127)
  1952. +         fatal_with_file ("Byte reloc overflow in ", entry);
  1953. + 
  1954.         *(char *) (data + addr) &= ~mask;
  1955.         *(char *) (data + addr) |= relocation;
  1956.         break;
  1957.   
  1958.       case 1:
  1959. +       {
  1960. +       int r=relocation;
  1961. + 
  1962.         if (RELOC_MEMORY_SUB_P(p))
  1963.           relocation -= mask & *(short *) (data + addr);
  1964.         else if (RELOC_MEMORY_ADD_P(p))
  1965.           relocation += mask & *(short *) (data + addr);
  1966. + 
  1967. +       if (relocation < -32768 || relocation > 32767)
  1968. +         {
  1969. +           fprintf (stderr, "relocation = $%lx, bsr = %d, pcr = %d, r= $%lx\n",
  1970. +                      relocation, RELOC_BASEREL_P(p), RELOC_PCREL_P (p), r);
  1971. +           fprintf (stderr, "textr = $%x, datar = $%x, bssr = $%x\n",
  1972. +                      text_relocation, data_relocation, bss_relocation);
  1973. +           fprintf (stderr, "symn = $%x, extern = %d, addr = $%lx.\n",
  1974. +                      p->r_symbolnum, p->r_extern, p->r_address);
  1975. +           fprintf (stderr, "data_size = %d, bss_size = %d.\n",
  1976. +                data_size, bss_size);
  1977. +           fatal_with_file ("Word reloc overflow in ", entry);
  1978. +         }
  1979. + 
  1980.         *(short *) (data + addr) &= ~mask;
  1981.         *(short *) (data + addr) |= relocation;
  1982.         break;
  1983. +       }
  1984.   
  1985.       case 2:
  1986.   #ifdef CROSS_LINKER
  1987. ***************
  1988. *** 4937,4942 ****
  1989. --- 5500,5506 ----
  1990.           relocation -= mask & *(long *) (data + addr);
  1991.         else if (RELOC_MEMORY_ADD_P(p))
  1992.           relocation += mask & *(long *) (data + addr);
  1993. + 
  1994.         *(long *) (data + addr) &= ~mask;
  1995.         *(long *) (data + addr) |= relocation;
  1996.   #endif /* not CROSS_LINKER */
  1997. ***************
  1998. *** 4945,4953 ****
  1999.       default:
  2000.         fatal_with_file ("Unimplemented relocation field length in ", entry);
  2001.       }
  2002.       }
  2003.   }
  2004. ! 
  2005.   /* For OUTPUT_RELOCATABLE only: write out the relocation,
  2006.      relocating the addresses-to-be-relocated.  */
  2007.   
  2008. --- 5509,5535 ----
  2009.       default:
  2010.         fatal_with_file ("Unimplemented relocation field length in ", entry);
  2011.       }
  2012. + 
  2013. + #ifdef HUNK_INSTEAD_OF_A_OUT
  2014. +     /* now finish this huge 'if' .. */
  2015. +     }
  2016. +     else
  2017. +       {
  2018. +         /* this only deals with 32bit relocs, the Amiga-loader
  2019. +          * doesn't support 1 or 2 byte relocs, they are only defined
  2020. +          * inside program-units (commonly known as object-files:-)) */
  2021. + 
  2022. +         if (RELOC_TARGET_SIZE(p) != 2)
  2023. +           fatal_with_file ("unsupported reloc-size in ", entry);
  2024. + 
  2025. +         *(long *) (data + addr) += relocation;
  2026. +         addr += pc_relocation;
  2027. +             add_to_reloc_hunk(this_hunk, addr);
  2028. +       }
  2029. + #endif
  2030.       }
  2031.   }
  2032. ! 
  2033.   /* For OUTPUT_RELOCATABLE only: write out the relocation,
  2034.      relocating the addresses-to-be-relocated.  */
  2035.   
  2036. ***************
  2037. *** 4995,5007 ****
  2038.   
  2039.     /* Write out the relocations of all files, remembered from copy_text.  */
  2040.   
  2041. !   lseek (outdesc, output_trel_offset, 0);
  2042.     each_full_file (coptxtrel, 0);
  2043.   
  2044.     if (trace_files)
  2045.       fprintf (stderr, "\nWriting data relocation:\n\n");
  2046.   
  2047. !   lseek (outdesc, output_drel_offset, 0);
  2048.     each_full_file (copdatrel, 0);
  2049.   
  2050.     if (trace_files)
  2051. --- 5577,5589 ----
  2052.   
  2053.     /* Write out the relocations of all files, remembered from copy_text.  */
  2054.   
  2055. !   fseek (outstream, output_trel_offset, 0);
  2056.     each_full_file (coptxtrel, 0);
  2057.   
  2058.     if (trace_files)
  2059.       fprintf (stderr, "\nWriting data relocation:\n\n");
  2060.   
  2061. !   fseek (outstream, output_drel_offset, 0);
  2062.     each_full_file (copdatrel, 0);
  2063.   
  2064.     if (trace_files)
  2065. ***************
  2066. *** 5076,5082 ****
  2067.                   entry->text_reloc_size / sizeof (struct relocation_info));
  2068.   #endif
  2069.   
  2070. !   mywrite (entry->textrel, 1, entry->text_reloc_size, outdesc);
  2071.   }
  2072.   
  2073.   void
  2074. --- 5658,5664 ----
  2075.                   entry->text_reloc_size / sizeof (struct relocation_info));
  2076.   #endif
  2077.   
  2078. !   mywrite (entry->textrel, 1, entry->text_reloc_size, outstream);
  2079.   }
  2080.   
  2081.   void
  2082. ***************
  2083. *** 5155,5163 ****
  2084.                   entry->data_reloc_size / sizeof (struct relocation_info));
  2085.   #endif
  2086.   
  2087. !   mywrite (entry->datarel, 1, entry->data_reloc_size, outdesc);
  2088.   }
  2089. ! 
  2090.   void write_file_syms ();
  2091.   void write_string_table ();
  2092.   
  2093. --- 5737,5745 ----
  2094.                   entry->data_reloc_size / sizeof (struct relocation_info));
  2095.   #endif
  2096.   
  2097. !   mywrite (entry->datarel, 1, entry->data_reloc_size, outstream);
  2098.   }
  2099. ! 
  2100.   void write_file_syms ();
  2101.   void write_string_table ();
  2102.   
  2103. ***************
  2104. *** 5192,5199 ****
  2105.     return index;
  2106.   }
  2107.   
  2108. - FILE *outstream = (FILE *) 0;
  2109. - 
  2110.   /* Write the contents of `strtab_vector' into the string table.
  2111.      This is done once for each file's local&debugger symbols
  2112.      and once for the global symbols.  */
  2113. --- 5774,5779 ----
  2114. ***************
  2115. *** 5203,5212 ****
  2116.   {
  2117.     register int i;
  2118.   
  2119. !   lseek (outdesc, output_strs_offset + output_strs_size, 0);
  2120.   
  2121.     if (!outstream)
  2122.       outstream = fdopen (outdesc, "w");
  2123.   
  2124.     for (i = 0; i < strtab_index; i++)
  2125.       {
  2126. --- 5783,5794 ----
  2127.   {
  2128.     register int i;
  2129.   
  2130. !   fseek (outstream, output_strs_offset + output_strs_size, 0);
  2131.   
  2132. + #if 0
  2133.     if (!outstream)
  2134.       outstream = fdopen (outdesc, "w");
  2135. + #endif
  2136.   
  2137.     for (i = 0; i < strtab_index; i++)
  2138.       {
  2139. ***************
  2140. *** 5220,5226 ****
  2141.     if (ferror (outstream))
  2142.       perror_name (output_filename);
  2143.   }
  2144. ! 
  2145.   /* Write the symbol table and string table of the output file.  */
  2146.   
  2147.   void
  2148. --- 5802,5808 ----
  2149.     if (ferror (outstream))
  2150.       perror_name (output_filename);
  2151.   }
  2152. ! 
  2153.   /* Write the symbol table and string table of the output file.  */
  2154.   
  2155.   void
  2156. ***************
  2157. *** 5248,5253 ****
  2158. --- 5830,5841 ----
  2159.     /* Pointer for storing into BUF.  */
  2160.     register struct nlist *bufp = buf;
  2161.   
  2162. + #ifdef HUNK_INSTEAD_OF_A_OUT
  2163. +   /* this enables us to output "regular" amiga symbols without
  2164. +    * the BSD-like debug-hunk */
  2165. +   if (number_of_debug_hunk == -1) return;
  2166. + #endif
  2167. + 
  2168.     /* Size of string table includes the bytes that store the size.  */
  2169.     strtab_size = sizeof strtab_size;
  2170.   
  2171. ***************
  2172. *** 5370,5377 ****
  2173.   
  2174.     /* Output the buffer full of `struct nlist's.  */
  2175.   
  2176. !   lseek (outdesc, output_syms_offset + output_syms_size, 0);
  2177. !   mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  2178.     output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2179.   
  2180.     if (syms_written != nsyms)
  2181. --- 5958,5965 ----
  2182.   
  2183.     /* Output the buffer full of `struct nlist's.  */
  2184.   
  2185. !   fseek (outstream, output_syms_offset + output_syms_size, 0);
  2186. !   mywrite (buf, sizeof (struct nlist), bufp - buf, outstream);
  2187.     output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2188.   
  2189.     if (syms_written != nsyms)
  2190. ***************
  2191. *** 5380,5393 ****
  2192.     /* Now the total string table size is known, so write it into the
  2193.        first word of the string table.  */
  2194.   
  2195. !   lseek (outdesc, output_strs_offset, 0);
  2196. !   mywrite (&strtab_size, sizeof (int), 1, outdesc);
  2197.   
  2198.     /* Write the strings for the global symbols.  */
  2199.   
  2200.     write_string_table ();
  2201.   }
  2202. ! 
  2203.   /* Write the local and debugger symbols of file ENTRY.
  2204.      Increment *SYMS_WRITTEN_ADDR for each symbol that is written.  */
  2205.   
  2206. --- 5968,5981 ----
  2207.     /* Now the total string table size is known, so write it into the
  2208.        first word of the string table.  */
  2209.   
  2210. !   fseek (outstream, output_strs_offset, 0);
  2211. !   mywrite (&strtab_size, sizeof (int), 1, outstream);
  2212.   
  2213.     /* Write the strings for the global symbols.  */
  2214.   
  2215.     write_string_table ();
  2216.   }
  2217. ! 
  2218.   /* Write the local and debugger symbols of file ENTRY.
  2219.      Increment *SYMS_WRITTEN_ADDR for each symbol that is written.  */
  2220.   
  2221. ***************
  2222. *** 5489,5496 ****
  2223.   
  2224.     /* All the symbols are now in BUF; write them.  */
  2225.   
  2226. !   lseek (outdesc, output_syms_offset + output_syms_size, 0);
  2227. !   mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  2228.     output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2229.   
  2230.     /* Write the string-table data for the symbols just written,
  2231. --- 6077,6084 ----
  2232.   
  2233.     /* All the symbols are now in BUF; write them.  */
  2234.   
  2235. !   fseek (outstream, output_syms_offset + output_syms_size, 0);
  2236. !   mywrite (buf, sizeof (struct nlist), bufp - buf, outstream);
  2237.     output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2238.   
  2239.     /* Write the string-table data for the symbols just written,
  2240. ***************
  2241. *** 5499,5505 ****
  2242.     write_string_table ();
  2243.     entry->strings = 0;        /* Since it will dissapear anyway.  */
  2244.   }
  2245. ! 
  2246.   /* Copy any GDB symbol segments from the input files to the output file.
  2247.      The contents of the symbol segment is copied without change
  2248.      except that we store some information into the beginning of it.  */
  2249. --- 6087,6093 ----
  2250.     write_string_table ();
  2251.     entry->strings = 0;        /* Since it will dissapear anyway.  */
  2252.   }
  2253. ! 
  2254.   /* Copy any GDB symbol segments from the input files to the output file.
  2255.      The contents of the symbol segment is copied without change
  2256.      except that we store some information into the beginning of it.  */
  2257. ***************
  2258. *** 5509,5515 ****
  2259.   void
  2260.   write_symsegs ()
  2261.   {
  2262. !   lseek (outdesc, output_symseg_offset, 0);
  2263.     each_file (write_file_symseg, 0);
  2264.   }
  2265.   
  2266. --- 6097,6103 ----
  2267.   void
  2268.   write_symsegs ()
  2269.   {
  2270. !   fseek (outstream, output_symseg_offset, 0);
  2271.     each_file (write_file_symseg, 0);
  2272.   }
  2273.   
  2274. ***************
  2275. *** 5544,5550 ****
  2276.   
  2277.     /* Write the modified root into the output file.  */
  2278.   
  2279. !   mywrite (&root, sizeof root, 1, outdesc);
  2280.   
  2281.     /* Copy the rest of the symbol segment unchanged.  */
  2282.   
  2283. --- 6132,6138 ----
  2284.   
  2285.     /* Write the modified root into the output file.  */
  2286.   
  2287. !   mywrite (&root, sizeof root, 1, outstream);
  2288.   
  2289.     /* Copy the rest of the symbol segment unchanged.  */
  2290.   
  2291. ***************
  2292. *** 5557,5568 ****
  2293.         if (len != min (sizeof buffer, total))
  2294.       fatal_with_file ("premature end of file in symbol segment of ", entry);
  2295.         total -= len;
  2296. !       mywrite (buffer, len, 1, outdesc);
  2297.       }
  2298.   
  2299.     file_close ();
  2300.   }
  2301. ! 
  2302.   /* Define a special symbol (etext, edata, or end).  NAME is the
  2303.      name of the symbol, with a leading underscore (whether or not this
  2304.      system uses such underscores).  TYPE is its type (e.g. N_DATA | N_EXT).
  2305. --- 6145,6156 ----
  2306.         if (len != min (sizeof buffer, total))
  2307.       fatal_with_file ("premature end of file in symbol segment of ", entry);
  2308.         total -= len;
  2309. !       mywrite (buffer, len, 1, outstream);
  2310.       }
  2311.   
  2312.     file_close ();
  2313.   }
  2314. ! 
  2315.   /* Define a special symbol (etext, edata, or end).  NAME is the
  2316.      name of the symbol, with a leading underscore (whether or not this
  2317.      system uses such underscores).  TYPE is its type (e.g. N_DATA | N_EXT).
  2318. ***************
  2319. *** 5616,5621 ****
  2320. --- 6204,6235 ----
  2321.     symbol_define ("__etext", N_TEXT | N_EXT, &etext_symbol_alt);
  2322.     symbol_define ("__end", N_BSS | N_EXT, &end_symbol_alt);
  2323.   
  2324. + #ifdef amigados
  2325. +   if (output_datadata_relocs)
  2326. +     symbol_define ("___datadata_relocs", N_TEXT | N_EXT, &datadata_reloc_symbol);
  2327. + 
  2328. +   symbol_define ("__sdata", N_DATA | N_EXT, &sdata_symbol);
  2329. +   symbol_define ("___text_size", N_ABS | N_EXT, &text_size_symbol);
  2330. +   symbol_define ("___data_size", N_ABS | N_EXT, &data_size_symbol);
  2331. +   symbol_define ("___bss_size", N_ABS | N_EXT, &bss_size_symbol);
  2332. +   {
  2333. +     symbol *a_symbol;
  2334. +     symbol_define ("___machtype", N_ABS | N_EXT, &a_symbol);
  2335. +     if (a_symbol)
  2336. +       a_symbol->value = amiga_machtype;
  2337. +       
  2338. +     symbol_define ("___databss_together", N_ABS | N_EXT, &a_symbol);
  2339. +     if (a_symbol)
  2340. +       a_symbol->value = databss_together;
  2341. +       
  2342. +     if (databss_together)
  2343. +       {
  2344. +         symbol_define ("___a4_init", N_DATA | N_EXT, &a_symbol);
  2345. +         if (a_symbol)
  2346. +           a_symbol->value = data_start + 0x7ffe;
  2347. +       }
  2348. +   }
  2349. + #endif
  2350.   #ifdef sun
  2351.     {
  2352.       symbol *dynamic_symbol;
  2353. ***************
  2354. *** 5658,5664 ****
  2355.   
  2356.     return k;
  2357.   }
  2358. ! 
  2359.   /* Get the symbol table entry for the global symbol named KEY.
  2360.      Create one if there is none.  */
  2361.   
  2362. --- 6272,6278 ----
  2363.   
  2364.     return k;
  2365.   }
  2366. ! 
  2367.   /* Get the symbol table entry for the global symbol named KEY.
  2368.      Create one if there is none.  */
  2369.   
  2370. ***************
  2371. *** 5725,5731 ****
  2372.   
  2373.     return 0;
  2374.   }
  2375. ! 
  2376.   /* Report a usage error.
  2377.      Like fatal except prints a usage summary.  */
  2378.   
  2379. --- 6339,6345 ----
  2380.   
  2381.     return 0;
  2382.   }
  2383. ! 
  2384.   /* Report a usage error.
  2385.      Like fatal except prints a usage summary.  */
  2386.   
  2387. ***************
  2388. *** 5739,5750 ****
  2389. --- 6353,6374 ----
  2390.         fprintf (stderr, string, arg);
  2391.         fprintf (stderr, "\n");
  2392.       }
  2393. + #ifdef HUNK_INSTEAD_OF_A_OUT
  2394. +   fprintf (stderr, "\
  2395. + Usage: %s [-d] [-dc] [-dp] [-e symbol] [-l lib] [-n] [-noinhibit-exec]\n\
  2396. +        [-nostdlib] [-o file] [-r] [-s] [-t] [-u symbol] [-x] [-y symbol]\n\
  2397. +        [-z] [-A file] [-Bstatic] [-D size] [-L libdir] [-M] [-N]\n\
  2398. +        [-S] [-T[{text,data}] addr] [-V prefix] [-X] \n\
  2399. +        [{-a,-amiga-debug-hunk}] [{-f,-flavor} flavor] [file...]\n",
  2400. +        progname);
  2401. + #else
  2402.     fprintf (stderr, "\
  2403.   Usage: %s [-d] [-dc] [-dp] [-e symbol] [-l lib] [-n] [-noinhibit-exec]\n\
  2404.          [-nostdlib] [-o file] [-r] [-s] [-t] [-u symbol] [-x] [-y symbol]\n\
  2405.          [-z] [-A file] [-Bstatic] [-D size] [-L libdir] [-M] [-N]\n\
  2406.          [-S] [-T[{text,data}] addr] [-V prefix] [-X] [file...]\n",
  2407.          progname);
  2408. + #endif
  2409.     exit (1);
  2410.   }
  2411.   
  2412. ***************
  2413. *** 5765,5776 ****
  2414.      followed by the filename of ENTRY.  */
  2415.   
  2416.   void
  2417. ! fatal_with_file (string, entry)
  2418.        char *string;
  2419.        struct file_entry *entry;
  2420.   {
  2421.     fprintf (stderr, "%s: ", progname);
  2422. !   fprintf (stderr, string);
  2423.     print_file_name (entry, stderr);
  2424.     fprintf (stderr, "\n");
  2425.     exit (1);
  2426. --- 6389,6400 ----
  2427.      followed by the filename of ENTRY.  */
  2428.   
  2429.   void
  2430. ! fatal_with_file (string, entry, arg)
  2431.        char *string;
  2432.        struct file_entry *entry;
  2433.   {
  2434.     fprintf (stderr, "%s: ", progname);
  2435. !   fprintf (stderr, string, arg);
  2436.     print_file_name (entry, stderr);
  2437.     fprintf (stderr, "\n");
  2438.     exit (1);
  2439. ***************
  2440. *** 5784,5794 ****
  2441.        char *name;
  2442.   {
  2443.     extern int errno, sys_nerr;
  2444. -   extern char *sys_errlist[];
  2445.     char *s;
  2446.   
  2447.     if (errno < sys_nerr)
  2448. !     s = concat ("", sys_errlist[errno], " for %s");
  2449.     else
  2450.       s = "cannot open %s";
  2451.     fatal (s, name);
  2452. --- 6408,6417 ----
  2453.        char *name;
  2454.   {
  2455.     extern int errno, sys_nerr;
  2456.     char *s;
  2457.   
  2458.     if (errno < sys_nerr)
  2459. !     s = concat ("", strerror (errno), " for %s");
  2460.     else
  2461.       s = "cannot open %s";
  2462.     fatal (s, name);
  2463. ***************
  2464. *** 5802,5812 ****
  2465.        struct file_entry *entry;
  2466.   {
  2467.     extern int errno, sys_nerr;
  2468. -   extern char *sys_errlist[];
  2469.     char *s;
  2470.   
  2471.     if (errno < sys_nerr)
  2472. !     s = concat ("", sys_errlist[errno], " for ");
  2473.     else
  2474.       s = "cannot open ";
  2475.     fatal_with_file (s, entry);
  2476. --- 6425,6434 ----
  2477.        struct file_entry *entry;
  2478.   {
  2479.     extern int errno, sys_nerr;
  2480.     char *s;
  2481.   
  2482.     if (errno < sys_nerr)
  2483. !     s = concat ("", strerror (errno), " for ");
  2484.     else
  2485.       s = "cannot open ";
  2486.     fatal_with_file (s, entry);
  2487. ***************
  2488. *** 5824,5840 ****
  2489.     fprintf (stderr, "\n");
  2490.   }
  2491.   
  2492. ! 
  2493.   /* Output COUNT*ELTSIZE bytes of data at BUF
  2494.      to the descriptor DESC.  */
  2495.   
  2496.   void
  2497. ! mywrite (buf, count, eltsize, desc)
  2498.        char *buf;
  2499.        int count;
  2500.        int eltsize;
  2501. !      int desc;
  2502.   {
  2503.     register int val;
  2504.     register int bytes = count * eltsize;
  2505.   
  2506. --- 6446,6463 ----
  2507.     fprintf (stderr, "\n");
  2508.   }
  2509.   
  2510. ! 
  2511.   /* Output COUNT*ELTSIZE bytes of data at BUF
  2512.      to the descriptor DESC.  */
  2513.   
  2514.   void
  2515. ! mywrite (buf, count, eltsize, stream)
  2516.        char *buf;
  2517.        int count;
  2518.        int eltsize;
  2519. !      FILE *stream;
  2520.   {
  2521. + #if 0
  2522.     register int val;
  2523.     register int bytes = count * eltsize;
  2524.   
  2525. ***************
  2526. *** 5846,5860 ****
  2527.         buf += val;
  2528.         bytes -= val;
  2529.       }
  2530.   }
  2531.   
  2532. ! /* Output PADDING zero-bytes to descriptor OUTDESC.
  2533.      PADDING may be negative; in that case, do nothing.  */
  2534.   
  2535.   void
  2536. ! padfile (padding, outdesc)
  2537.        int padding;
  2538. !      int outdesc;
  2539.   {
  2540.     register char *buf;
  2541.     if (padding <= 0)
  2542. --- 6469,6486 ----
  2543.         buf += val;
  2544.         bytes -= val;
  2545.       }
  2546. + #else
  2547. +   fwrite (buf, eltsize, count, stream);
  2548. + #endif
  2549.   }
  2550.   
  2551. ! /* Output PADDING zero-bytes to descriptor OUTSTREAM.
  2552.      PADDING may be negative; in that case, do nothing.  */
  2553.   
  2554.   void
  2555. ! padfile (padding, outstream)
  2556.        int padding;
  2557. !      FILE *outstream;
  2558.   {
  2559.     register char *buf;
  2560.     if (padding <= 0)
  2561. ***************
  2562. *** 5862,5868 ****
  2563.   
  2564.     buf = (char *) alloca (padding);
  2565.     bzero (buf, padding);
  2566. !   mywrite (buf, padding, 1, outdesc);
  2567.   }
  2568.   
  2569.   /* Return a newly-allocated string
  2570. --- 6488,6494 ----
  2571.   
  2572.     buf = (char *) alloca (padding);
  2573.     bzero (buf, padding);
  2574. !   mywrite (buf, padding, 1, outstream);
  2575.   }
  2576.   
  2577.   /* Return a newly-allocated string
  2578. ***************
  2579. *** 5903,5910 ****
  2580.   xmalloc (size)
  2581.        int size;
  2582.   {
  2583.     register char *result = malloc (size);
  2584. !   if (!result)
  2585.       fatal ("virtual memory exhausted", 0);
  2586.     return result;
  2587.   }
  2588. --- 6529,6537 ----
  2589.   xmalloc (size)
  2590.        int size;
  2591.   {
  2592. +   extern char *malloc();
  2593.     register char *result = malloc (size);
  2594. !   if (!result && size)
  2595.       fatal ("virtual memory exhausted", 0);
  2596.     return result;
  2597.   }
  2598. ***************
  2599. *** 5916,5927 ****
  2600.        char *ptr;
  2601.        int size;
  2602.   {
  2603. !   register char *result = realloc (ptr, size);
  2604.     if (!result)
  2605.       fatal ("virtual memory exhausted", 0);
  2606.     return result;
  2607.   }
  2608. ! 
  2609.   #ifdef USG
  2610.   
  2611.   void
  2612. --- 6543,6555 ----
  2613.        char *ptr;
  2614.        int size;
  2615.   {
  2616. !   extern char *malloc(), *realloc();
  2617. !   register char *result = ptr ? realloc (ptr, size) : malloc (size);
  2618.     if (!result)
  2619.       fatal ("virtual memory exhausted", 0);
  2620.     return result;
  2621.   }
  2622. ! 
  2623.   #ifdef USG
  2624.   
  2625.   void
  2626. ***************
  2627. *** 5952,5954 ****
  2628. --- 6580,7214 ----
  2629.     return 8192;
  2630.   }
  2631.   #endif
  2632. + 
  2633. + #ifdef HUNK_INSTEAD_OF_A_OUT
  2634. + /* the whole rest of the file is used for managment of hunks and subhunks.. */
  2635. + 
  2636. + /* this is the amiga-equivalent of struct exec */
  2637. + struct simple_hunk_header {
  2638. +   long    id,    /* this will be 0x3f3 */
  2639. +     zero,
  2640. +     table_size,
  2641. +     first_hunk,
  2642. +     last_hunk,
  2643. +     sizes[4];   /* there can be at most a code,data,bss & debug hunk */
  2644. + };
  2645. + 
  2646. + /* this writes out a hunk header, depending on the information collected
  2647. +  * so far, it will only create hunks, that really exist, so if your data-
  2648. +  * size is zero, you won't get a data-hunk at all. */
  2649. + 
  2650. + void
  2651. + write_hunk_header(outfd)
  2652. +     int outfd;
  2653. + {
  2654. +   struct simple_hunk_header sh;
  2655. +   int this_hunk, header_size;
  2656. + 
  2657. +   sh.id = 0x3f3;    /* HUNK_HEADER */
  2658. +   sh.zero = 0;
  2659. +   sh.table_size = current_hunk;
  2660. +   sh.first_hunk = 0;
  2661. +   sh.last_hunk  = current_hunk - 1;
  2662. + 
  2663. +   this_hunk = 0;
  2664. +   if (number_of_code_hunk != -1)
  2665. +      sh.sizes[this_hunk++] = LONGSIZE(text_size);
  2666. + 
  2667. +   if (number_of_data_hunk != -1)
  2668. +      sh.sizes[this_hunk++] = databss_together 
  2669. +                  ? LONGSIZE(data_size + bss_size) : LONGSIZE(data_size);
  2670. + 
  2671. +   if (!databss_together && number_of_bss_hunk  != -1)
  2672. +      sh.sizes[this_hunk++] = LONGSIZE(bss_size);
  2673. + 
  2674. +   if (number_of_debug_hunk != -1)
  2675. +      sh.sizes[this_hunk++] = 0;  /* to be filled in later */
  2676. + 
  2677. +   header_size = sizeof(sh) - (4-this_hunk)*sizeof(long);
  2678. +   mywrite(&sh, 1, header_size, outfd);
  2679. + }
  2680. + 
  2681. + /* if we really write out a debug hunk, this fills in the remaining
  2682. +  * spots, that are known only at the end of load-file output */
  2683. + 
  2684. + void
  2685. + conditionally_rewrite_headers ()
  2686. + {
  2687. +   long size_of_debug_hunk,
  2688. +        end_hunk = 0x3f2,
  2689. +        eof;
  2690. + 
  2691. +   /* if we don't want a debug hunk, just return */
  2692. +   if (number_of_debug_hunk == -1)  return;
  2693. + 
  2694. +   /* while we're at it, since we started the debug-hunk, lets finish it
  2695. +    * now. */
  2696. +   fseek (outstream, 0L, 2);
  2697. +   eof = ftell (outstream);
  2698. +   dh.strs = eof - offset_of_debug_hunk - sizeof(dh) - dh.syms;
  2699. +   /* just to be sure, we HAVE to pad to a long-boundery */
  2700. +   if (eof & 3)
  2701. +     {
  2702. +       long zero = 0;
  2703. + 
  2704. +       mywrite(&zero, 4 - (eof & 3), 1, outstream);
  2705. +       eof = (eof + 3) & ~3;
  2706. +     }
  2707. + 
  2708. +   mywrite(&end_hunk, sizeof(long), 1, outstream);
  2709. + 
  2710. +   /* ok, so calculate the size of the debug hunk. This is the 
  2711. +    * size of the debug_header plus the symbol and string tables,
  2712. +    * but it doesn't include the 2 longs, that identify the hunk and
  2713. +    * its length, whence the "- 2*sizeof(long)" */
  2714. +   size_of_debug_hunk = eof - offset_of_debug_hunk - 2*sizeof(long);
  2715. +   /* we actually need the size in longs.. */
  2716. +   size_of_debug_hunk = LONGSIZE(size_of_debug_hunk);
  2717. + 
  2718. +   /* now first patch the debug-hunk itself, afterwards the load-file header */
  2719. +   fseek (outstream, offset_of_debug_hunk, 0);
  2720. +   dh.len = size_of_debug_hunk;
  2721. +   mywrite(&dh, sizeof dh, 1, outstream);
  2722. + 
  2723. +   /* now the main header, this involves calculating, at which offset we
  2724. +    * find the index for the debug hunk */   
  2725. +   fseek (outstream, (5 + number_of_debug_hunk)*sizeof(long), 0);
  2726. +   mywrite(&size_of_debug_hunk, sizeof(long), 1, outstream);
  2727. +   fseek (outstream, 0L, 2);
  2728. +   /* that's it! */
  2729. + }
  2730. + 
  2731. + /* this is the only information that we can store in a regular amiga
  2732. +  * symbol, just its value, nothing further, that's why I added the 
  2733. +  * debug-hunk-feature */
  2734. + 
  2735. + typedef struct {
  2736. +   char *sym_name;
  2737. +   long  sym_offset;
  2738. + } simple_symbol;
  2739. + 
  2740. + /* we'll only define symbols after at most 3 hunks, ie. the code, data
  2741. +  * and bss hunk, but not after the debug hunk, whence the index 3 */
  2742. + 
  2743. + simple_symbol *hunk_sym_tab[3];
  2744. + int hunk_sym_tab_size[3], hunk_sym_tab_index[3];
  2745. + 
  2746. + void
  2747. + init_symbol_hunks()
  2748. + {
  2749. +   int i;
  2750. + 
  2751. +   if (trace_files) fprintf(stderr, "init_symbol_hunks()\n");
  2752. + 
  2753. +   for (i = 0; i < 3; i++)
  2754. +     {
  2755. +        hunk_sym_tab[i] = 
  2756. +          (simple_symbol *) xmalloc((hunk_sym_tab_size[i] = 10) * 
  2757. +        sizeof(simple_symbol));
  2758. +        hunk_sym_tab_index[i] = 0;
  2759. +     }
  2760. + }
  2761. + 
  2762. + /* this should go into libc, well, it wasn't there, so... */
  2763. + 
  2764. + char *
  2765. + strsave(str)
  2766. +     char *str;
  2767. + {
  2768. +   char *cp;
  2769. +   int len = strlen(str);
  2770. +   if (len)
  2771. +     {
  2772. +       cp = xmalloc(len+1);
  2773. +       strcpy(cp, str);
  2774. +     }
  2775. +   else
  2776. +     cp = NULL;
  2777. +   return cp;
  2778. + }
  2779. + 
  2780. + void
  2781. + add_to_symbol_hunk(hunk_num, name, offset)
  2782. +     int hunk_num;
  2783. +     char *name;
  2784. +     long offset;
  2785. + {
  2786. +    if (hunk_num == -1) return;
  2787. +    if (hunk_num >= 3) fatal ("invalid hunk_number: %d\n", hunk_num);
  2788. + 
  2789. +    /* no checks for duplicate symbols. Since it is legitimate to have
  2790. +     * symbols with the same name, we can't strip them.. just make 
  2791. +     * sure not to call this function multiple times with the same
  2792. +     * symbol, since it won't be detected, and you'll get several
  2793. +     * labels for the same offset...
  2794. +     */
  2795. +     
  2796. +    if (trace_files) fprintf(stderr, "add_to_symbol_hunk(%d, %s, %d)\n",
  2797. +                 hunk_num, name, offset);
  2798. + 
  2799. +    hunk_sym_tab[hunk_num][hunk_sym_tab_index[hunk_num]].sym_offset = offset;
  2800. +    hunk_sym_tab[hunk_num][hunk_sym_tab_index[hunk_num]++].sym_name = 
  2801. +      strsave(name);
  2802. + 
  2803. +    if (hunk_sym_tab_index[hunk_num] == hunk_sym_tab_size[hunk_num])
  2804. +     hunk_sym_tab[hunk_num] = (simple_symbol *)
  2805. +       xrealloc(hunk_sym_tab[hunk_num],
  2806. +             (hunk_sym_tab_size[hunk_num] <<= 1) * 
  2807. +               sizeof(simple_symbol));
  2808. + }
  2809. + 
  2810. + int
  2811. + compare_simple_symbols(l1, l2)
  2812. +     simple_symbol *l1, *l2;
  2813. + {
  2814. +   return l1->sym_offset - l2->sym_offset;
  2815. + }
  2816. + 
  2817. + /* this writes the symbol subhunk #hunk_num, you call this just after
  2818. +  * you created your {code,data,bss}-hunk */
  2819. + 
  2820. + void
  2821. + write_symbol_hunk(hunk_num)
  2822. +     int hunk_num;
  2823. + {
  2824. +   int i, j;
  2825. +   simple_symbol *tab;
  2826. +   long size, index;
  2827. + 
  2828. +   if (hunk_num == -1) return;
  2829. +   if (hunk_num >= 3) fatal ("invalid hunk_number: %d\n", hunk_num);
  2830. +   
  2831. +   tab   = hunk_sym_tab[hunk_num];
  2832. +   size  = hunk_sym_tab_size[hunk_num];
  2833. +   index = hunk_sym_tab_index[hunk_num];
  2834. +    
  2835. +   /* kind of abused as general debug-flag:-) */
  2836. +   if (trace_files) fprintf(stderr, 
  2837. +                 "wsh: hnum=%d,size=%d,index=%d\n",
  2838. +                hunk_num,size,index);
  2839. +    
  2840. +   if (index > 0)
  2841. +     {
  2842. +       qsort(tab, index, sizeof(simple_symbol), compare_simple_symbols);
  2843. + 
  2844. +       j = 0x3f0; /* HUNK_SYMBOL */
  2845. +       mywrite(&j, 1, sizeof(long), outstream);
  2846. +    
  2847. +       for (i = 0; i < index; i++)
  2848. +         {
  2849. +        register simple_symbol *ss = tab+i;
  2850. +        int len = strlen (ss->sym_name);
  2851. + 
  2852. +        j = LONGSIZE (len);
  2853. +        mywrite(&j, 1, sizeof(long), outstream);
  2854. + 
  2855. +        mywrite(ss->sym_name, 1, len, outstream);
  2856. +        if (len < 4*j)
  2857. +          padfile (4*j - len, outstream);
  2858. + 
  2859. +        mywrite(&(ss->sym_offset), 1, sizeof(long), outstream);
  2860. +     }
  2861. + 
  2862. +       j = 0;
  2863. +       mywrite(&j, 1, sizeof(long), outstream);
  2864. +     }
  2865. + }
  2866. + 
  2867. + /* now follow the quite similar routines for dealing with
  2868. +  * reloc-subhunks, the difference to the symbol-subhunks is, that reloc
  2869. +  * subhunks can be output only after the {code,data}-Hunks, AND there
  2870. +  * can be more than one after each of them */
  2871. + 
  2872. + long *hunk_rel_tab[3], hunk_rel_tab_size[3], hunk_rel_tab_index[3];
  2873. + 
  2874. + void
  2875. + init_reloc_hunk()
  2876. + {
  2877. +   int i;
  2878. + 
  2879. +   if (trace_files) fprintf(stderr, "init_reloc_hunk()\n");
  2880. + 
  2881. +   for (i = 0; i < 3; i++)
  2882. +     {
  2883. +        hunk_rel_tab[i] = 
  2884. +          (long *) xmalloc((hunk_rel_tab_size[i] = 10) * sizeof(long));
  2885. +        hunk_rel_tab_index[i] = 0;
  2886. +     }
  2887. + }
  2888. + 
  2889. + void
  2890. + add_to_reloc_hunk(hunk_num, offset)
  2891. +     int hunk_num;
  2892. +     long offset;
  2893. + {
  2894. +    /* no checks for duplicate symbols, they will show up when we sort
  2895. +     * the table, and we will strip them off before writing out the table */
  2896. + 
  2897. +    if (trace_files) fprintf(stderr, "add_to_reloc_hunk(%d, %d)\n", hunk_num, offset);
  2898. + 
  2899. +    hunk_rel_tab[hunk_num][hunk_rel_tab_index[hunk_num]++] = offset;
  2900. + 
  2901. +    if (hunk_rel_tab_index[hunk_num] == hunk_rel_tab_size[hunk_num])
  2902. +     hunk_rel_tab[hunk_num] = (long *)
  2903. +       xrealloc(hunk_rel_tab[hunk_num],
  2904. +                    (hunk_rel_tab_size[hunk_num] <<= 1) * sizeof(long));
  2905. + }
  2906. + 
  2907. + int
  2908. + compare_longs(l1, l2)
  2909. +     long *l1, *l2;
  2910. + {
  2911. +   return *l1 - *l2;
  2912. + }
  2913. + 
  2914. + int
  2915. + compare_strings (s1p, s2p)
  2916. +     char **s1p;
  2917. +     char **s2p;
  2918. + {
  2919. +   return (strcmp (*s1p, *s2p));
  2920. + }
  2921. + 
  2922. + void
  2923. + write_reloc_hunk()
  2924. + {
  2925. +    int i, j;
  2926. +    long *tab, size, index;
  2927. +    /* only write a hunk-header & -end, if we really output some relocs */
  2928. +    int did_start_hunk = 0;
  2929. + 
  2930. +    for (i = 0; i < 3; i++)
  2931. +      {
  2932. +     tab   = hunk_rel_tab[i];
  2933. +     size  = hunk_rel_tab_size[i];
  2934. +     index = hunk_rel_tab_index[i];
  2935. + 
  2936. +     /* kind of abused as general debug-flag:-) */
  2937. +         if (trace_files) fprintf(stderr, 
  2938. +                  "wrh: i=%d,size=%d,index=%d\n",
  2939. +                  i,size,index);
  2940. + 
  2941. +         if (index > 0)
  2942. +       {
  2943. +         qsort(tab, index, sizeof(long), compare_longs);
  2944. + 
  2945. +         /* kick out duplicate symbols.. I don't know, what
  2946. +          * the loader would do, if it had to relocate the same
  2947. +          * address twice.. BTW: can this happen or can't it???? */
  2948. +         for (j = 0; j < index-1; )
  2949. +           {
  2950. +         if (tab[j] == tab[j+1])
  2951. +           bcopy(tab+j+1, tab+j, ((index--)-j-1)*sizeof(long));
  2952. +         else
  2953. +           j++;
  2954. +           }
  2955. + 
  2956. +         if (!did_start_hunk++)
  2957. +           {
  2958. +         j = 0x3ec; /* HUNK_RELOC32 */
  2959. +         mywrite(&j, 1, sizeof(long), outstream);
  2960. +           }
  2961. + 
  2962. +         mywrite(&index, 1, sizeof(long), outstream);
  2963. +         mywrite(&i, 1, sizeof(long), outstream);
  2964. +         mywrite(tab, 1, index*sizeof(long), outstream);
  2965. +         hunk_rel_tab_index[i] = index;
  2966. +       }
  2967. +      }
  2968. +    if (did_start_hunk)
  2969. +      {
  2970. +     j = 0;
  2971. +        mywrite(&j, 1, sizeof(long), outstream);
  2972. +      }
  2973. + }
  2974. + 
  2975. + 
  2976. + void
  2977. + write_datadata_relocs ()
  2978. + {
  2979. +   int numdd, i, prev;
  2980. + 
  2981. +   prev = ftell (outstream);
  2982. +   fseek (outstream, datadata_relocs_offset, L_SET);
  2983. +   
  2984. +   numdd = hunk_rel_tab_index[number_of_data_hunk];
  2985. +   if (numdd > numdatadata_relocs)
  2986. +     fatal ("found more data-data relocs than estimated!\n", 0);
  2987. +   
  2988. +   mywrite (&numdd, 1, sizeof (long), outstream);
  2989. +   if (numdd)
  2990. +     mywrite (hunk_rel_tab[number_of_data_hunk], numdd, sizeof (long), outstream);
  2991. + 
  2992. +   fseek (outstream, prev, L_SET);
  2993. + }
  2994. + 
  2995. + 
  2996. + /* create the bss hunk if needed */
  2997. + 
  2998. + void
  2999. + write_bss()
  3000. + {
  3001. +   long bss_hunk[2];
  3002. +   if (!databss_together && bss_size)
  3003. +    {
  3004. +      bss_hunk[0] = 0x3eb;
  3005. +      bss_hunk[1] = LONGSIZE(bss_size);
  3006. +      mywrite(bss_hunk, 1, sizeof bss_hunk, outstream);
  3007. +      write_symbol_hunk(number_of_bss_hunk);
  3008. +      bss_hunk[0] = 0x3f2; /* HUNK_END */
  3009. +      mywrite(bss_hunk, 1, sizeof(long), outstream);
  3010. +    }
  3011. + }
  3012. + 
  3013. + /* this scans one object file for its symbols, and deposits them in 
  3014. +  * the symbol-hunk tables for later output */
  3015. + 
  3016. + void
  3017. + look_for_file_syms (entry)
  3018. +      struct file_entry *entry;
  3019. + {
  3020. +   register struct nlist *p = entry->symbols;
  3021. +   register struct nlist *end = p + entry->syms_size / sizeof (struct nlist);
  3022. + 
  3023. + #if 0
  3024. +   /* don't do this, it only confuses most amiga disassemblers.. */
  3025. + 
  3026. +   /* Generate a local symbol for the start of this file's text.  */
  3027. + 
  3028. +   if (discard_locals != DISCARD_ALL)
  3029. +     add_to_symbol_hunk(number_of_code_hunk, entry->local_sym_name, 
  3030. +        entry->text_start_address);
  3031. + #endif
  3032. + 
  3033. +   /* Read the file's string table.  */
  3034. + 
  3035. +   entry->strings = (char *) alloca (entry->strs_size);
  3036. +   read_entry_strings (file_open (entry), entry);
  3037. + 
  3038. +   for (; p < end; p++)
  3039. +     {
  3040. +       register unsigned char type = p->n_type;
  3041. +       register int write = 0;
  3042. +       int this_hunk;
  3043. +       char *cp;
  3044. + 
  3045. +       /* WRITE gets 1 for a non-global symbol that should be written.  */
  3046. + 
  3047. +       if (SET_ELEMENT_P (type))    /* This occurs even if global.  These */
  3048. +                 /* types of symbols are never written */
  3049. +                 /* globally, though they are stored */
  3050. +                 /* globally.  */
  3051. +         write = output_style == OUTPUT_RELOCATABLE;
  3052. +       else if (!(type & (N_STAB | N_EXT)))
  3053. +           /* ordinary local symbol */
  3054. +       write = ((discard_locals != DISCARD_ALL)
  3055. +            && !(discard_locals == DISCARD_L &&
  3056. +                (p->n_un.n_strx + entry->strings)[0] == LPREFIX)
  3057. +            && type != N_WARNING);
  3058. + 
  3059. +       else if (!(type & N_EXT))
  3060. +     /* debugger symbol */
  3061. +         write = (strip_symbols == STRIP_NONE);
  3062. + 
  3063. +       /* skip STAB symbols if present */
  3064. +       write = write && !(type & N_STAB);
  3065. + 
  3066. +       /* those weird types are NOT output in the normal symbols:-)) */
  3067. +       write = write && (type != N_ABS && type != (N_ABS|N_EXT));
  3068. + 
  3069. +       /* don't know where those symbols come from, they're well suited to
  3070. +        * crash enforcer, and they're not `real' symbols anyway.. */
  3071. +       if (p->n_un.n_strx > entry->strs_size) continue;
  3072. + 
  3073. +       /* symbols that end with a dot are only useful for gdb, 
  3074. +        * not for a normal amiga debugger (currently gcc_compiled. and
  3075. +        * gcc_compiled2.) so skip them in this section */
  3076. + 
  3077. +       /* check to see, whether this string ends with a dot */
  3078. +       if (write && p->n_un.n_strx)
  3079. +         {
  3080. +           cp = rindex (p->n_un.n_strx + entry->strings, '.');
  3081. + 
  3082. +       write = write && !(cp && !cp[1]);
  3083. +       
  3084. + #if 0
  3085. +       printf ("%s >%s<\n", write ? "adding" : "skipping", p->n_un.n_strx + entry->strings);
  3086. + #endif
  3087. +     }
  3088. + 
  3089. +       if (write)
  3090. +     {
  3091. +       if (p->n_un.n_strx)
  3092. +         {
  3093. +           switch (type & ~N_EXT)
  3094. +             {
  3095. +           case N_TEXT:
  3096. +             this_hunk = number_of_code_hunk;
  3097. +             break;
  3098. +           case N_SETV:
  3099. +           case N_DATA:
  3100. +             this_hunk = number_of_data_hunk;
  3101. +             break;
  3102. +           case N_UNDF:
  3103. +           case N_BSS:
  3104. +             this_hunk = number_of_bss_hunk;
  3105. +             break;
  3106. +           default:
  3107. +             error ("unknown type %d while trying to build lsymhunk", type);
  3108. +             goto skip1;
  3109. +             }
  3110. + 
  3111. +           add_to_symbol_hunk(this_hunk, p->n_un.n_strx + entry->strings,
  3112. +                  p->n_value);
  3113. + skip1:    ;
  3114. +             }
  3115. +     }
  3116. +     }
  3117. + }
  3118. + 
  3119. + /* scan all input files for symbols and store them in the symbolhunk tables */
  3120. + 
  3121. + void
  3122. + look_for_symbols()
  3123. + {
  3124. +   int this_hunk;
  3125. +   int i;
  3126. +   symbol *sp;
  3127. + 
  3128. +   if (strip_symbols == STRIP_ALL)
  3129. +     return;
  3130. + 
  3131. +   /* Write the local symbols defined by the various files.  */
  3132. + 
  3133. +   each_file (look_for_file_syms, 0);
  3134. +   file_close ();
  3135. + 
  3136. +   /* Scan the symbol hash table, bucket by bucket.  */
  3137. + 
  3138. +   for (i = 0; i < TABSIZE; i++)
  3139. +     for (sp = symtab[i]; sp; sp = sp->link)
  3140. +       {
  3141. +     struct nlist nl;
  3142. + 
  3143. +     /* Compute a `struct nlist' for the symbol.  */
  3144. + 
  3145. +     nl.n_value = 0;
  3146. + 
  3147. +     if (sp->defined || sp->referenced)
  3148. +       {
  3149. +         /* common condition needs to be before undefined condition */
  3150. +         /* because unallocated commons are set undefined in */
  3151. +         /* digest_symbols */
  3152. +         if (sp->defined > 1) /* defined with known type */
  3153. +           {
  3154. +         /* If the target of an indirect symbol has been
  3155. +            defined and we are outputting an executable,
  3156. +            resolve the indirection; it's no longer needed */
  3157. +         if (output_style != OUTPUT_RELOCATABLE
  3158. +             && ((sp->defined & ~N_EXT) == N_INDR)
  3159. +             && (((symbol *) sp->value)->defined > 1))
  3160. +           {
  3161. +             symbol *newsp = (symbol *) sp->value;
  3162. +             nl.n_type = newsp->defined;
  3163. +             nl.n_value = newsp->value;
  3164. +           }
  3165. +         else
  3166. +           {
  3167. +             nl.n_type = sp->defined;
  3168. +             if (sp->defined != (N_INDR | N_EXT))
  3169. +               nl.n_value = sp->value;
  3170. +             else
  3171. +               nl.n_value = 0;
  3172. +           }
  3173. +           }
  3174. +         else if (sp->max_common_size) /* defined as common but not allocated. */
  3175. +           {
  3176. +         /* happens only with -r and not -d */
  3177. +         /* write out a common definition */
  3178. +         nl.n_type = N_UNDF | N_EXT;
  3179. +         nl.n_value = sp->max_common_size;
  3180. +           }
  3181. +         else if (!sp->defined)          /* undefined -- legit only if -r */
  3182. +           {
  3183. +         nl.n_type = N_UNDF | N_EXT;
  3184. +         nl.n_value = 0;
  3185. +           }
  3186. +         else
  3187. +           fatal ("internal error: %s defined in mysterious way", sp->name);
  3188. + 
  3189. +         switch (nl.n_type & ~N_EXT)
  3190. +           {
  3191. +         case N_TEXT:
  3192. +           this_hunk = number_of_code_hunk;
  3193. +           break;
  3194. +         case N_SETV:
  3195. +         case N_DATA:
  3196. +           this_hunk = number_of_data_hunk;
  3197. +           break;
  3198. +         case N_UNDF:
  3199. +         case N_BSS:
  3200. +           this_hunk = number_of_bss_hunk;
  3201. +           break;
  3202. +         case N_ABS:
  3203. +           break;
  3204. +         default:
  3205. +           error ("unknown type %d while trying to build symhunk", nl.n_type);
  3206. +           goto skip2;
  3207. +           }
  3208. + 
  3209. +         /* sigh, there is no equivalent in the symbol section of a load
  3210. +          * file on the amiga, have to forget about those symbols */
  3211. +         if ((nl.n_type & ~N_EXT) == N_ABS)
  3212. +           continue;
  3213. + 
  3214. +         add_to_symbol_hunk(this_hunk, sp->name, nl.n_value);
  3215. + skip2:    ;
  3216. +       }
  3217. +       }
  3218. + }
  3219. + 
  3220. + void
  3221. + relocate_set_vectors (vectors, num_entries)
  3222. +     unsigned long *vectors;
  3223. +     int num_entries;
  3224. + {
  3225. +   unsigned long i;
  3226. +   unsigned long offset = set_sect_start;
  3227. +   int hunk_num;
  3228. + 
  3229. +   while (num_entries-- > 0)
  3230. +     {
  3231. +       /* the number of entries for this symbol */
  3232. +       i = *vectors++; offset += 4;
  3233. +       while (num_entries --, i--)
  3234. +     {
  3235. +       hunk_num = number_of_code_hunk;
  3236. +       if (*vectors >= text_size)
  3237. +         {
  3238. +           if (*vectors >= text_size + data_size)
  3239. +               {
  3240. +           hunk_num = number_of_bss_hunk;
  3241. +           if (databss_together)
  3242. +             *vectors -= text_size;
  3243. +           else
  3244. +             *vectors -= text_size + data_size;
  3245. +         }
  3246. +           else
  3247. +         {
  3248. +           hunk_num = number_of_data_hunk;
  3249. +           *vectors -= text_size;
  3250. +         }
  3251. +         }
  3252. +       add_to_reloc_hunk (hunk_num, offset);
  3253. +       ++vectors;
  3254. +       offset += 4;
  3255. +     }
  3256. +       /* check.. HAS to be zero */
  3257. +       if (*vectors)
  3258. +     fatal ("set-vector corrupt, num_entries = %d", num_entries);
  3259. +       vectors++; offset += 4; --num_entries;
  3260. +     }
  3261. + }
  3262. + #endif
  3263. + 
  3264. diff -rc --new-file binutils-1.8.x-fsf/objdump.c binutils-1.8.x-amiga/objdump.c
  3265. *** binutils-1.8.x-fsf/objdump.c    Sat Dec 30 00:16:07 1989
  3266. --- binutils-1.8.x-amiga/objdump.c    Wed Sep 22 12:45:33 1993
  3267. ***************
  3268. *** 24,31 ****
  3269.   #include <stdio.h>
  3270.   #include "getopt.h"
  3271.   
  3272.   #ifndef COFF_ENCAPSULATE
  3273. ! #include <a.out.h>
  3274.   /* Tell a.out.gnu.h not to try to redefine some things.  */
  3275.   #define __STRUCT_EXEC_OVERRIDE__
  3276.   #define N_NLIST_DECLARED
  3277. --- 24,35 ----
  3278.   #include <stdio.h>
  3279.   #include "getopt.h"
  3280.   
  3281. + #ifdef MCH_AMIGA
  3282. + #define getpagesize() 256
  3283. + #endif
  3284. + 
  3285.   #ifndef COFF_ENCAPSULATE
  3286. ! #include <sun/a.out.h>
  3287.   /* Tell a.out.gnu.h not to try to redefine some things.  */
  3288.   #define __STRUCT_EXEC_OVERRIDE__
  3289.   #define N_NLIST_DECLARED
  3290. diff -rc --new-file binutils-1.8.x-fsf/ranlib.c binutils-1.8.x-amiga/ranlib.c
  3291. *** binutils-1.8.x-fsf/ranlib.c    Thu Mar  1 00:18:42 1990
  3292. --- binutils-1.8.x-amiga/ranlib.c    Sat Feb  5 12:31:20 1994
  3293. ***************
  3294. *** 54,60 ****
  3295.      as the location of the GNU AR program.  */
  3296.   
  3297.   char *prog = AR_PROG;
  3298. ! char *prog_pref = "/usr/local/gnubin/ar";
  3299.   
  3300.   int
  3301.   main (argc, argv)
  3302. --- 54,60 ----
  3303.      as the location of the GNU AR program.  */
  3304.   
  3305.   char *prog = AR_PROG;
  3306. ! char *prog_pref = "/gnu/bin/ar";
  3307.   
  3308.   int
  3309.   main (argc, argv)
  3310. diff -rc --new-file binutils-1.8.x-fsf/strip.c binutils-1.8.x-amiga/strip.c
  3311. *** binutils-1.8.x-fsf/strip.c    Mon Jun 11 21:40:01 1990
  3312. --- binutils-1.8.x-amiga/strip.c    Wed Sep 22 12:45:43 1993
  3313. ***************
  3314. *** 71,77 ****
  3315.   
  3316.   /* If BSD, we can use `ftruncate'.  */
  3317.   
  3318. ! #ifndef USG
  3319.   #define HAVE_FTRUNCATE
  3320.   #endif
  3321.   
  3322. --- 71,77 ----
  3323.   
  3324.   /* If BSD, we can use `ftruncate'.  */
  3325.   
  3326. ! #if !defined(USG) && !defined(MCH_AMIGA)
  3327.   #define HAVE_FTRUNCATE
  3328.   #endif
  3329.   
  3330. ***************
  3331. *** 287,294 ****
  3332. --- 287,296 ----
  3333.       signal (SIGTERM, SIG_DFL);
  3334.   
  3335.     /* Handle any signal that came in while they were deferred.  */
  3336. + #ifndef MCH_AMIGA
  3337.     if (delayed_signal)
  3338.       kill (getpid (), delayed_signal);
  3339. + #endif
  3340.   }
  3341.   
  3342.   /** Convenient functions for operating on one or all files being processed.  */
  3343. ***************
  3344. *** 928,933 ****
  3345. --- 930,936 ----
  3346.   }
  3347.   
  3348.   #ifdef USG
  3349. + #ifndef MCH_AMIGA
  3350.   
  3351.   rename (from, to)
  3352.        char *from, *to;
  3353. ***************
  3354. *** 940,945 ****
  3355. --- 943,949 ----
  3356.       return 0;
  3357.   }
  3358.   
  3359. + #endif
  3360.   #endif
  3361.   
  3362.   usage ()
  3363.