home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 9 / FreshFishVol9-CD2.bin / bbs / gnu / gdb-4.14-src.lha / gdb-4.14 / bfd / amigados.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-09  |  69.8 KB  |  2,595 lines
  1. /* BFD back-end for Commodore-Amiga AmigaDOS binaries.
  2.    Copyright (C) 1990-1994 Free Software Foundation, Inc.
  3.    Contributed by Leonard Norrgard.  Partially based on the bout
  4.    and ieee BFD backends and Markus Wild's tool hunk2gcc.
  5.    Revised and updated by Stephan Thesing 
  6.  
  7. This file is part of BFD, the Binary File Descriptor library.
  8.  
  9. This program is free software; you can redistribute it and/or modify
  10. it under the terms of the GNU General Public License as published by
  11. the Free Software Foundation; either version 2 of the License, or
  12. (at your option) any later version.
  13.  
  14. This program is distributed in the hope that it will be useful,
  15. but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. GNU General Public License for more details.
  18.  
  19. You should have received a copy of the GNU General Public License
  20. along with this program; if not, write to the Free Software
  21. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22.  
  23. /*
  24. SECTION
  25.     amiga back end
  26.  
  27. This section describes the overall structure of the Amiga BFD back end.
  28. The linker stuff can be found in @xref{amigalink}.
  29. @menu
  30. @* implementation::
  31. @* amigalink::
  32. @end menu
  33.  
  34. INODE
  35. implementation, amigalink, amiga, amiga
  36.  
  37.  
  38. SECTION
  39.     implementation
  40.  
  41.  
  42. The need for a port of the bfd library for Amiga style object (hunk) files
  43. arose by the desire to port the GNU debugger gdb to the Amiga.
  44. Also, the linker ld should be updated to the current version (2.5.2).
  45. @@*
  46. This port bases on the work done by Leonard Norrgard, who started porting
  47. gdb. Raphael Luebbert, who supports the ixemul.library, has also worked on
  48. implementing the needed @code{ptrace()} system call and gas2.5.
  49.  
  50. @menu
  51. @* not supported::
  52. @* Does it work ?::
  53. @* TODO::
  54. @end menu
  55.  
  56. INODE
  57. not supported, Does it work ?,implementation,implementation
  58. SUBSECTION
  59.     not supported
  60.  
  61. Currently, the implementation does not support Amiga link library files, like
  62. e.g. amiga.lib. This may be added in a later version, if anyone starts work
  63. on it, or I find some time for it.
  64.  
  65. The handling of the symbols in hunk files is a little bit broken:
  66.       o The symbols in a load file are totally ignored at the moment, so gdb and gprof
  67.             do not work.
  68.       o The symbols of a object module (Hunk file, starting with HUNK_UNIT) are read in
  69.             correctly, but HUNK_SYMBOL hunks are also ignored.
  70.  
  71. The reason for this is the following:
  72. Amiga symbol hunks do not allow for much information. Only a name and a value are allowed.
  73. On the other hand, a.out format carries along much more information (see, e.g. the
  74. entry on set symbols in the ld manual). The old linker copied this information into
  75. a HUNK_DEBUG hunk. Now there is the choice:
  76.     o ignoring the debug hunk, read in only HUNK_SYMBOL definitions => extra info is lost.
  77.     o read in the debug hunk and use the information therein => How can clashs between the
  78.           information in the debug hunk and HUNK_SYMBOL or HUNK_EXT hunks be avoided ?
  79. I haven't decided yet, what to do about this.
  80.  
  81.  
  82. Although bfd allows to link together object modules of different flavours, 
  83. producing a.out style executables does not work on Amiga :-)
  84. It should, however, be possible to create a.out files with the -r option of ld
  85. (incremental link).
  86.  
  87. INODE 
  88. Does it work ?,TODO ,not supported , implementation
  89. SUBSECTION
  90.     Does it work ?
  91.  
  92. Currently, the following utillities work:
  93.     o objdump
  94.     o objcopy
  95.     o strip
  96.     o nm
  97.     o ar
  98.     o gas
  99.  
  100.     
  101. INODE
  102. TODO, , Does it work ?, implementation
  103. SUBSECTION
  104.     TODO
  105.  
  106.     o fix fixme:s
  107.  
  108. @*
  109. BFD:
  110.     o add flag to say if the format allows multiple sections with the
  111.           same name.  Fix bfd_get_section_by_name() and bfd_make_section()
  112.           accordingly.
  113.        
  114.     o dumpobj.c: the disassembler: use relocation record data to find symbolic
  115.            names of addresses, when available.  Needs new routine where one can
  116.           specify the source section of the symbol to be printed as well as some
  117.           rewrite of the disassemble functions.
  118.        
  119. */
  120.  
  121. #include "bfd.h"
  122. #include "bfdlink.h"
  123. #include "sysdep.h"
  124. #include "libbfd.h"
  125. #include "libamiga.h"
  126. #include <a.out.h>
  127.  
  128. #define GL(x) bfd_get_32 (abfd, (bfd_byte *) (x))
  129.  
  130. #define DEBUG_AMIGA 10000
  131.  
  132. #if DEBUG_AMIGA
  133. #include <varargs.h>
  134. static void error_print(va_alist)
  135. va_dcl
  136. {
  137. va_list args;
  138. char *fmt;
  139.  
  140. va_start(args);
  141. fmt=va_arg(args,char *);
  142.  
  143. (void)vfprintf(stderr,fmt,args);
  144. va_end(args);
  145. }
  146.  
  147. #define DPRINT(L,x) if (L>=DEBUG_AMIGA) error_print x
  148. #else
  149. #define DPRINT(L,x) 
  150. #endif
  151.  
  152. static boolean amiga_digest_file ();
  153. static boolean amiga_mkobject ();
  154.  
  155. reloc_howto_type howto_hunk_reloc8 =
  156. {
  157.   HUNK_RELOC8, /* type */
  158.   0,           /* rightshift */
  159.   0,           /* size */
  160.   8,           /* bitsize */
  161.   true,        /* pc_relative */
  162.   0,           /* bitpos */
  163.   complain_overflow_bitfield,  /* complain_on_overflow */
  164.   0,           /* special_function */
  165.   "reloc8",    /* textual name */
  166.   false,       /* partial_inplace? */
  167.   0x000000ff,  /* src_mask */
  168.   0x000000ff,  /* dst_mask */
  169.   true         /* pcrel_offset */
  170. };
  171.  
  172. reloc_howto_type howto_hunk_reloc16 =
  173. {HUNK_RELOC16,0,1,16,true,0,complain_overflow_bitfield,0,"reloc16",false,0x0000ffff,0x0000ffff,true};
  174.  
  175. reloc_howto_type howto_hunk_reloc32 =
  176. {HUNK_RELOC32,0,2,32,true,0,complain_overflow_bitfield,0,"reloc32",false,0xffffffff,0xffffffff,true};
  177.  
  178. reloc_howto_type howto_hunk_drel8 =
  179. {HUNK_DREL8,0,0,8,false,0,complain_overflow_bitfield,0,"drel8",false,0x000000ff,0x000000ff,false};
  180.  
  181. reloc_howto_type howto_hunk_drel16 =
  182. {HUNK_DREL16,0,1,16,false,0,complain_overflow_bitfield,0,"drel16",false,0x0000ffff,0x0000ffff,false};
  183.  
  184. reloc_howto_type howto_hunk_drel32 =
  185. {HUNK_DREL32,0,2,32,false,0,complain_overflow_bitfield,0,"drel32",false,0xffffffff,0xffffffff,false};
  186.  
  187. reloc_howto_type *amiga_howto_array[2][3] =
  188. {
  189.   { &howto_hunk_reloc8, &howto_hunk_reloc16, &howto_hunk_reloc32 },
  190.   { &howto_hunk_drel8, &howto_hunk_drel16, &howto_hunk_drel32 }
  191. };
  192.  
  193.  
  194. /* This one is used by the linker and tells us, if a debug hunk should be written out*/
  195. int write_debug_hunk=0;
  196. /* This is also used by the linker to set the attribute of sections */
  197. int amiga_attribute=0;
  198.  
  199. static const struct bfd_target *
  200. amiga_object_p (abfd)
  201.      bfd *abfd;
  202. {
  203.   char buf[8];
  204.   unsigned int x;
  205.   struct stat stat_buffer;
  206.  
  207.   /* An Amiga object file must be at least 8 bytes long.  */
  208.   if (bfd_read ((PTR) buf, 1, 8, abfd) != 8)
  209.     {
  210.       bfd_set_error(bfd_error_wrong_format);
  211.       return 0;
  212.     }
  213.  
  214.   /* Does it look like an Amiga object file?  */
  215.   x = GL(buf);
  216.   if ((x != HUNK_UNIT) && (x != HUNK_HEADER))
  217.     {
  218.       /* Not an Amiga file.  */
  219.       bfd_set_error(bfd_error_wrong_format);
  220.       return 0;
  221.     }
  222.  
  223.   /* So far it seems to be an Amiga file.  Now slurp it
  224.      in and examine it closer.  */
  225.   stat_buffer.st_size=0;
  226.   if ((-1 == fstat (fileno ((FILE *) abfd->iostream), &stat_buffer))||(stat_buffer.st_size%4!=0))
  227.     { /* Error during system call or file length is not multiple of longword size */
  228.       bfd_set_error((stat_buffer.st_size%4==0)?bfd_error_system_call:bfd_error_wrong_format);
  229.       return 0;
  230.     }
  231.  
  232.   /* Can't fail and return (but must be declared boolean to suit
  233.      other bfd requirements).  */
  234.   (void) amiga_mkobject (abfd);
  235.  
  236.  
  237.   AMIGA_DATA(abfd)->first_byte = (unsigned long *) bfd_alloc (abfd, stat_buffer.st_size);
  238.   bfd_seek (abfd, 0, SEEK_SET);
  239.   
  240.   if (bfd_read (AMIGA_DATA(abfd)->first_byte, 1, stat_buffer.st_size, abfd)!=stat_buffer.st_size)
  241.     {
  242.       /* Error, reading file */
  243.      return (const struct bfd_target *)0;
  244.    }
  245.  
  246.   AMIGA_DATA(abfd)->file_pointer = AMIGA_DATA(abfd)->first_byte;
  247.   AMIGA_DATA(abfd)->file_end = (unsigned long *)((unsigned char *)AMIGA_DATA(abfd)->first_byte + stat_buffer.st_size);
  248.  
  249.   if (!amiga_digest_file (abfd))
  250.     {
  251.       /* Something went wrong.  */
  252.       return (const struct bfd_target *) 0;
  253.     }
  254.  
  255.   /* Set default architecture to m68k:68000.  */
  256.   /* So we can link on 68000 AMIGAs..... */
  257.   abfd->arch_info = bfd_scan_arch ("m68k:68000");
  258.  
  259.   return (abfd->xvec);
  260. }
  261.  
  262. /* Skip over the hunk length longword + the number of longwords given there.  */
  263. #define next_hunk(abfd) \
  264.   { AMIGA_DATA(abfd)->file_pointer += 1 + GL(AMIGA_DATA(abfd)->file_pointer); }
  265.  
  266. static asection *
  267. amiga_get_section_by_hunk_number (abfd, hunk_number)
  268.      bfd *abfd;
  269.       long hunk_number;
  270. {
  271.   /* A cache, so we don't have to search the entire list every time.  */
  272.   static asection *last_reference;
  273.   asection *p;
  274.  
  275.   switch(hunk_number)
  276.     {
  277.     case -1:
  278.       return bfd_abs_section_ptr;
  279.       break;
  280.     case -2:
  281.       return bfd_und_section_ptr;
  282.       break;
  283.     case -3: 
  284.       return bfd_com_section_ptr;
  285.       break;
  286.     default:
  287.       if (last_reference)
  288.     if (last_reference->target_index == hunk_number)
  289.       return last_reference;
  290.       for (p = abfd->sections; p != NULL; p = p->next)
  291.     if (p->target_index == hunk_number)
  292.       {
  293.         last_reference = p;
  294.         return p;
  295.       }
  296.       BFD_FAIL();
  297.       return (asection *) 0;
  298.     }
  299. return NULL;
  300. }
  301.  
  302. static boolean
  303. amiga_add_reloc (abfd, section, offset, symbol, howto, target_hunk)
  304.      bfd *abfd;
  305.      asection *section;
  306.      bfd_size_type offset;
  307.      amiga_symbol_type * symbol;
  308.      reloc_howto_type *howto;
  309.      long target_hunk;
  310. {
  311.   amiga_reloc_type *reloc;
  312.  
  313.   reloc = (amiga_reloc_type *) bfd_zalloc (abfd, sizeof (amiga_reloc_type));
  314.   reloc->next = 0;
  315.  
  316.   if (!reloc)
  317.     {
  318.       bfd_set_error(bfd_error_no_memory);
  319.       return(false);
  320.     }
  321.  
  322.  
  323.   abfd -> flags |= HAS_RELOC;
  324.   section -> flags |= SEC_RELOC;
  325.  
  326.   if (amiga_per_section(section)->reloc_tail)
  327.     amiga_per_section(section)->reloc_tail->next = reloc;
  328.   else
  329.     section->relocation = (struct reloc_cache_entry *) reloc;
  330.   amiga_per_section(section)->reloc_tail = reloc;
  331.   amiga_per_section(section)->reloc_tail->next = NULL;
  332.   reloc->relent.address = offset;
  333.   reloc->relent.addend = 0;
  334.   reloc->relent.howto = howto;
  335.  
  336.   if (symbol==NULL) /* relative to section */
  337.     reloc->symbol=(amiga_symbol_type *)(amiga_get_section_by_hunk_number(abfd,target_hunk)->symbol);
  338.   else
  339.     reloc->symbol = symbol;
  340.   reloc->relent.sym_ptr_ptr=(asymbol **)(&(reloc->symbol));
  341.   reloc->target_hunk = target_hunk;
  342.  
  343.   return true;
  344. }
  345.  
  346. /* BFD doesn't currently allow multiple sections with the same
  347.    name, so we try a little harder to get a unique name.  */
  348. asection *
  349. amiga_make_unique_section (abfd, name)
  350.      bfd *abfd;
  351.      CONST char *name;
  352. {
  353.   asection *section;
  354.  
  355.  
  356.   section = bfd_make_section (abfd, name);
  357.   if (!section)
  358.     {
  359.       int i = 1;
  360.       char *new_name;
  361.  
  362.       new_name = bfd_alloc (abfd, strlen(name) + 3);
  363.  
  364.       /* We try to come up with an original name (since BFD
  365.      currently requires all sections to have different names).  */
  366.       while (!section && (i<=99))
  367.     {
  368.       sprintf (new_name, "%s_%u", name, i);
  369.       section = bfd_make_section (abfd, new_name);
  370.     }
  371.  
  372.       if (!section)
  373.     {
  374.       /* Complain about the given name.  */
  375.       bfd_set_error(bfd_error_bad_value);
  376.       return 0;
  377.     }
  378.     }
  379.  
  380.  
  381.   return section;
  382. }
  383.  
  384.  
  385.  
  386. #if DEBUG_AMIGA
  387. #define DPRINTHUNK(x)   fprintf (stderr,"Processing %s hunk (0x%x)...",\
  388.       (x) == HUNK_UNIT ? "HUNK_UNIT" :\
  389.       (x) == HUNK_NAME ? "HUNK_NAME" :\
  390.       (x) == HUNK_DEBUG ? "HUNK_DEBUG" :\
  391.       (x) == HUNK_OVERLAY ? "HUNK_OVERLAY" :\
  392.       (x) == HUNK_BREAK ? "HUNK_BREAK" :\
  393.       (x) == HUNK_HEADER ? "HUNK_HEADER" :\
  394.       (x) == HUNK_CODE ? "HUNK_CODE" :\
  395.       (x) == HUNK_DATA ? "HUNK_DATA" :\
  396.       (x) == HUNK_BSS ? "HUNK_BSS" :\
  397.       (x) == HUNK_RELOC8 ? "HUNK_RELOC8" :\
  398.       (x) == HUNK_RELOC16 ? "HUNK_RELOC16" :\
  399.       (x) == HUNK_RELOC32 ? "HUNK_RELOC32" :\
  400.       (x) == HUNK_DREL8 ? "HUNK_DREL8" :\
  401.       (x) == HUNK_DREL16 ? "HUNK_DREL16" :\
  402.       (x) == HUNK_DREL32 ? "HUNK_DREL32" :\
  403.       (x) == HUNK_SYMBOL ? "HUNK_SYMBOL" :\
  404.       (x) == HUNK_EXT ? "HUNK_EXT" :\
  405.       (x) == HUNK_END ? "HUNK_END" :\
  406.       (x) == HUNK_LIB ? "HUNK_LIB" :\
  407.       (x) == HUNK_INDEX ? "HUNK_INDEX" :\
  408.       "*unknown*",(x))
  409. #define DPRINTHUNKEND fprintf(stderr,"...done\n")
  410. #else
  411. #define DPRINTHUNK(x) 
  412. #define DPRINTHUNKEND 
  413. #endif
  414.  
  415. static boolean amiga_read_unit(bfd *abfd);
  416. static boolean amiga_read_load(bfd *abfd);
  417. static boolean amiga_handle_cdb_hunk(bfd *abfd, int ht,int hn,int ha,int hs);
  418. static boolean amiga_handle_rest(bfd *abfd,asection *cs,boolean isload);
  419.  
  420. static boolean
  421. amiga_digest_file (abfd)
  422.      bfd *abfd;
  423. {
  424.   amiga_data_type *amiga_data = AMIGA_DATA(abfd);
  425.   int hunk_type;
  426.  
  427.  
  428.   hunk_type = HUNK_VALUE(GL(amiga_data->file_pointer++));
  429.  
  430.  
  431.   switch (hunk_type)
  432.     {
  433.     case HUNK_UNIT:
  434.  
  435.       /* Read in the unit  */
  436.       if (!amiga_read_unit(abfd)) /* Error */
  437.     return(false);
  438.       break;
  439.       
  440.     case HUNK_HEADER:
  441.       /* This is a load file, well it should not be used with linking,
  442.      but it is possible to do so, so always allow it. */
  443.       
  444.       /* Read in the load file */
  445.       if (!amiga_read_load(abfd)) /* Error */
  446.     {
  447.       return(false);
  448.     }
  449.       break;
  450.     } /* of switch hunk_type */
  451.  
  452.  
  453.  
  454.   /* If there is any trailing garbage, i.e. we are not at EOF, then
  455.      complain and reject the file... */
  456.   if (amiga_data->file_pointer!=amiga_data->file_end) /* ooops */
  457.     {
  458.       bfd_set_error(bfd_error_wrong_format);
  459.       return(false);
  460.     }
  461.  
  462.   /* Success, all went well... */
  463.  return(true);
  464.  
  465. }/* of amiga_digest_file */
  466.  
  467.  
  468. /* If we read over the end of file, error */
  469. #define TOO_LARGE_P   if (amiga_data->file_pointer>=amiga_data->file_end)\
  470.     {DPRINT(10,("Overflow of file pointer\n"));bfd_set_error(bfd_error_wrong_format);return false;}
  471.  
  472.  
  473. /* Read in Unit file */
  474. /* file pointer is located after the HUNK_UNIT LW */
  475. static boolean amiga_read_unit(bfd *abfd)
  476. {
  477.  
  478.   amiga_data_type *amiga_data = AMIGA_DATA(abfd);
  479.   int hunk_type;
  480.   int hunk_number=0;
  481.   int hunk_attribute=0;
  482.  
  483.   /* The unit name, if given, has no meaning to us, 
  484.      since we are not in an archive. 
  485.      We could set the name of abfd to the name, but that 
  486.      may cause confusion... 
  487.      So just ignore the unit name 
  488.      ST 121194 */
  489.   amiga_data->file_pointer+=GL(amiga_data->file_pointer)+1;
  490.  
  491.   TOO_LARGE_P;
  492.  
  493.  
  494.   while (true)
  495.     {
  496.  
  497.       /* Now there may be CODE, DATA, BSS, SYMBOL, DEBUG, RELOC Hunks */
  498.       
  499.       hunk_type=HUNK_VALUE(GL(amiga_data->file_pointer)); /* Type of next hunk */
  500.       hunk_attribute=HUNK_ATTRIBUTE(GL(amiga_data->file_pointer++));
  501.       hunk_attribute=(hunk_attribute==HUNK_ATTR_CHIP)?
  502.     MEMF_CHIP:(hunk_attribute==HUNK_ATTR_FAST)?MEMF_FAST:0;
  503.       
  504.     
  505.       switch(hunk_type)
  506.     {
  507.     case HUNK_DEBUG:
  508.       /* We ignore debug hunks in UNITS, for now, because gnu's debug hunks
  509.          are only added by the linker to LOAD files.....
  510.          And anyhow, a.out format can keep much more information for units...
  511.          */
  512.       amiga_data->file_pointer+=1+GL(amiga_data->file_pointer);
  513.       TOO_LARGE_P;
  514.  
  515.       break;
  516.  
  517.     case HUNK_NAME:
  518.     case HUNK_CODE:
  519.     case HUNK_DATA:
  520.     case HUNK_BSS:
  521.       /* Handle this hunk, including relocs, etc.
  522.          The finishing HUNK_END is consumed by the routine
  523.          */
  524.       if (!amiga_handle_cdb_hunk(abfd,hunk_type,hunk_number++,hunk_attribute,-1))
  525.         return(false);
  526.  
  527.       break;
  528.  
  529.     default:
  530.       /* Something very nasty happened:
  531.          Illegal Hunk occured....
  532.          */
  533.       bfd_set_error(bfd_error_wrong_format);
  534.       return(false);
  535.       break;
  536.       
  537.     }/* Of switch hunk_type */
  538.  
  539.  
  540.       /* Last HUNK ?*/
  541.       if (amiga_data->file_pointer==amiga_data->file_end)
  542.     return true;
  543.  
  544.       TOO_LARGE_P; /* Sanity check */
  545.   
  546.       /* Next hunk */
  547.     }/* Of while */
  548.  
  549. }/* Of amiga_read_unit */
  550.  
  551.  
  552. #define MAX_HUNKS 200 /* Max # of hunks. we can read in.. */
  553.  
  554. /* Read a load file */
  555. static boolean amiga_read_load(bfd *abfd)
  556. {
  557.   amiga_data_type *amiga_data = AMIGA_DATA(abfd); 
  558.   int hunk_sizes[MAX_HUNKS]; /* If there are more hunks than this, we are in trouble...*/
  559.   int hunk_attributes[MAX_HUNKS];
  560.   int hunk_number=0;
  561.   int hunk_type;
  562.   int max_hunk_number=0;
  563.   int i,n;
  564.  
  565.   TOO_LARGE_P; /* Sanity */
  566.  
  567.   /* Read hunk lengths (and memory attributes...) */
  568.   /* Read in each hunk */
  569.  
  570.   /* If there are resident libs: abort (obsolete feature) */
  571.   if (GL(amiga_data->file_pointer++)!=0)
  572.     {
  573.       bfd_set_error(bfd_error_wrong_format);
  574.       return(false);
  575.     }
  576.  
  577.   TOO_LARGE_P;
  578.  
  579.   max_hunk_number=GL(amiga_data->file_pointer++);
  580.  
  581.   if (max_hunk_number>MAX_HUNKS) /* Ooops... too much hunks */
  582.     {
  583.       fprintf(stderr,"File %s has too many hunks (%d), aborting\n",abfd->filename,max_hunk_number);
  584.       bfd_set_error(bfd_error_wrong_format);
  585.       return(false);
  586.     }
  587.  
  588.   /* Sanity */
  589.   if ((max_hunk_number<1)||
  590.       (amiga_data->file_pointer+max_hunk_number+2>=amiga_data->file_end))
  591.     {
  592.       bfd_set_error(bfd_error_wrong_format);
  593.       return(false);
  594.     }
  595.  
  596.   /* Num of root hunk must be 0 */
  597.   if (GL(amiga_data->file_pointer++)!=0)
  598.     {
  599.       bfd_set_error(bfd_error_wrong_format);
  600.       return(false);
  601.     }
  602.  
  603.   /* Num of last hunk must be mhn-1 */
  604.   if (GL(amiga_data->file_pointer++)!=max_hunk_number-1)
  605.     {
  606.       bfd_set_error(bfd_error_wrong_format);
  607.       return(false);
  608.     }
  609.  
  610.   /* Now, read in sizes and memory attributes */
  611.  
  612.   for (i=0;i<max_hunk_number;i++)
  613.     {
  614.       n=HUNK_VALUE(GL(amiga_data->file_pointer));
  615.       hunk_sizes[i]=n<<2;
  616.       n=HUNK_ATTRIBUTE(GL(amiga_data->file_pointer++));
  617.       if (n==HUNK_ATTR_FOLLOWS) /* Attribute is in next long */
  618.     hunk_attributes[i]=GL(amiga_data->file_pointer++);
  619.       else
  620.     hunk_attributes[i]= (n==HUNK_ATTR_CHIP)?MEMF_CHIP:
  621.       (n==HUNK_ATTR_FAST)?MEMF_FAST:0;
  622.     }
  623.  
  624.   TOO_LARGE_P; /* Sanity */
  625.  
  626.   /* We can now read in all the hunks */
  627.  
  628.   for (hunk_number=0;hunk_number<max_hunk_number;hunk_number++)
  629.     {
  630.       hunk_type=HUNK_VALUE(GL(amiga_data->file_pointer++));
  631.  
  632.  
  633.       /* This may be HUNK_NAME, CODE, BSS, DEBUG, DATA */
  634.  
  635.       switch(hunk_type)
  636.     {
  637.     case HUNK_NAME:
  638.     case HUNK_CODE:
  639.     case HUNK_DATA:
  640.     case HUNK_BSS:
  641.     case HUNK_DEBUG:
  642.       if (
  643.       !amiga_handle_cdb_hunk(abfd,hunk_type,hunk_number,hunk_attributes[hunk_number],
  644.                 hunk_sizes[hunk_number]))
  645.         {
  646.           bfd_set_error(bfd_error_wrong_format);
  647.           return(false);
  648.         }
  649.       break;
  650.  
  651.     default:
  652.       /* illegal hunk */
  653.       bfd_set_error(bfd_error_wrong_format);
  654.       return(false);
  655.       break;
  656.     }/* Of switch */
  657.  
  658.  
  659.     }
  660.  
  661.   if (amiga_data->file_pointer!=amiga_data->file_end)
  662.     {
  663.       bfd_set_error(bfd_error_wrong_format);
  664.       return(false);
  665.     }
  666.  
  667.   return(true);
  668.  
  669. }/* Of amiga_read_load */
  670.  
  671.  
  672. /* Handle NAME, CODE, DATA, BSS, DEBUG Hunks */
  673. static boolean 
  674. amiga_handle_cdb_hunk(bfd *abfd, 
  675.               int hunk_type, 
  676.               int hunk_number,
  677.               int hunk_attribute, /* MEMF_CHIP, etc. */
  678.               int hunk_size)
  679. /* If hunk_size==-1, then we are digesting a HUNK_UNIT */
  680. {
  681.   amiga_data_type *amiga_data = AMIGA_DATA(abfd);
  682.   char *current_name=NULL;
  683.   int len;
  684.   asection *current_section=NULL;
  685.  
  686.   if (hunk_type==HUNK_NAME) /* get name */
  687.     {
  688.       len=HUNK_VALUE(GL(amiga_data->file_pointer))<<2; /* Length */
  689.       /* DIRTY: We move the name 4 bytes towards the beginning of the file,
  690.             overwriting the length,
  691.             and end it with a '\0' */
  692.       strncpy((char *)amiga_data->file_pointer,(char *)(amiga_data->file_pointer+1),len);
  693.       *(((char *)amiga_data->file_pointer)+len)='\0';
  694.       current_name=(char *)amiga_data->file_pointer;
  695.       amiga_data->file_pointer+=1+(len>>2); /* Advance */
  696.  
  697.       TOO_LARGE_P;
  698.  
  699.       hunk_type=HUNK_VALUE(GL(amiga_data->file_pointer++)); /* Next hunk */
  700.       if (hunk_size==-1) /* In a unit ==> Get attribute from file */
  701.     {
  702.       hunk_attribute=HUNK_ATTRIBUTE(GL(amiga_data->file_pointer-1));
  703.       hunk_attribute=(hunk_attribute==HUNK_ATTR_CHIP)?MEMF_CHIP:
  704.                  (hunk_attribute==HUNK_ATTR_FAST)?MEMF_FAST:0;
  705.     }
  706.     }
  707.   else /* Set curent name to something appropriate */
  708.     current_name=(hunk_type==HUNK_CODE)?".text":
  709.                  (hunk_type==HUNK_BSS)?".bss":".data";
  710.       
  711.  
  712.  
  713.   /* file_pointer is now at  hunk_type */
  714.  
  715.   switch (hunk_type)
  716.     {
  717.     case HUNK_CODE:
  718.       /* Handle code hunk */
  719.  
  720.       len=HUNK_VALUE(GL(amiga_data->file_pointer++))<<2; /* Length of section */
  721.       if (len>hunk_size) /* len may be shorter than hunk_size... */ 
  722.     if (hunk_size==-1)
  723.       hunk_size=len;
  724.     else
  725.       {
  726.         bfd_set_error(bfd_error_wrong_format);
  727.         return false;
  728.       }
  729.  
  730.       /* Make new section */
  731.       current_section=amiga_make_unique_section(abfd,current_name);
  732.       if (!current_section)
  733.     return false;
  734.  
  735.       current_section->filepos=(char *)(amiga_data->file_pointer)-(char *)amiga_data->first_byte;
  736.       current_section->_raw_size=hunk_size;
  737.       current_section->_cooked_size=hunk_size;
  738.       current_section->target_index=hunk_number;
  739.       bfd_set_section_flags(abfd,current_section, 
  740.                 SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS);
  741.  
  742.       amiga_per_section(current_section)->real_length=len; /* real size */
  743.       amiga_per_section(current_section)->attribute=hunk_attribute;
  744.  
  745.       amiga_data->file_pointer+=(len>>2); /* next hunk */
  746.  
  747.       if (!amiga_handle_rest(abfd,current_section,hunk_size!=-1))
  748.     return false;
  749.       
  750.       break;
  751.  
  752.     case HUNK_DATA:
  753.       /* Handle data hunk */
  754.  
  755.       len=HUNK_VALUE(GL(amiga_data->file_pointer++))<<2; /* Length of section */
  756.       if (len>hunk_size) /* len may be shorter than hunk_size... */ 
  757.     if (hunk_size==-1)
  758.       hunk_size=len;
  759.     else
  760.       {
  761.         bfd_set_error(bfd_error_wrong_format);
  762.         return false;
  763.       }
  764.  
  765.       current_section=amiga_make_unique_section(abfd,current_name);
  766.       if (!current_section)
  767.     return false;
  768.  
  769.       current_section->filepos=(char *)amiga_data->file_pointer-(char *)amiga_data->first_byte;
  770.       current_section->_raw_size=hunk_size;
  771.       current_section->_cooked_size=hunk_size;
  772.       current_section->target_index=hunk_number;
  773.       bfd_set_section_flags(abfd,current_section, 
  774.                 SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS);
  775.  
  776.       amiga_per_section(current_section)->real_length=len; /* real size */
  777.       amiga_per_section(current_section)->attribute=hunk_attribute;
  778.  
  779.       amiga_data->file_pointer+=(len>>2); /* next hunk */
  780.       if (!amiga_handle_rest(abfd,current_section,hunk_size!=-1))
  781.     return false;
  782.       break;
  783.  
  784.     case HUNK_BSS:
  785.       /* Handle bss hunk */
  786.       
  787.       len=HUNK_VALUE(GL(amiga_data->file_pointer++))<<2; /* Length of section */
  788.       if (len>hunk_size) /* len may be shorter than hunk_size... */ 
  789.     if (hunk_size==-1)
  790.       hunk_size=len;
  791.     else
  792.       {
  793.         bfd_set_error(bfd_error_wrong_format);
  794.         return false;
  795.       }
  796.  
  797.       current_section=amiga_make_unique_section(abfd,current_name);
  798.       if (!current_section)
  799.     return false;
  800.  
  801.       current_section->filepos=(file_ptr)-1;
  802.       current_section->_raw_size=hunk_size;
  803.       current_section->_cooked_size=hunk_size;
  804.       current_section->target_index=hunk_number;
  805.  
  806.       bfd_set_section_flags(abfd,current_section, SEC_ALLOC );
  807.  
  808.       amiga_per_section(current_section)->real_length=len; /* real size */
  809.       amiga_per_section(current_section)->attribute=hunk_attribute;
  810.  
  811.       if (!amiga_handle_rest(abfd,current_section,hunk_size!=-1))
  812.     return false;
  813.       break;
  814.  
  815.     case HUNK_DEBUG:
  816.       if (hunk_size==-1) /* We are digesting a unit ==> ignore debug hunks */
  817.     {
  818.       amiga_data->file_pointer+=1+GL(amiga_data->file_pointer);
  819.       return(true);
  820.     }
  821.       /* We are digesting a load file, so check for gnu debug hunk, else ignore it */
  822.       /* format of gnu debug hunk is:
  823.           HUNK_DEBUG
  824.               N
  825.             0413.L    Magic number
  826.       symtabsize
  827.       strtabsize
  828.       symtabdata  [length=symtabsize]
  829.       strtabdata  [length=strtabsize]
  830.           [pad bytes]
  831.       */
  832.  
  833.       if (GL(amiga_data->file_pointer+1)==0413) /* GNU DEBUG HUNK */
  834.     {
  835.       /*FIXME: we should add the symbols in the debug hunk to symtab... */
  836.       
  837.       amiga_data->symtab_size=GL(amiga_data->file_pointer+2);
  838.       amiga_data->stringtab_size=GL(amiga_data->file_pointer+3);
  839.       adata(abfd).sym_filepos=
  840.         (file_ptr)((char *)(amiga_data->file_pointer +4)-(char *)amiga_data->first_byte);
  841.       adata(abfd).str_filepos=adata(abfd).sym_filepos+amiga_data->symtab_size;
  842.       amiga_data->file_pointer+=1+GL(amiga_data->file_pointer);
  843.     }
  844.       else /* NOT GNU DEBUG HUNK... */
  845.     {
  846.       /* ignore it */
  847.       amiga_data->file_pointer+=1+GL(amiga_data->file_pointer);
  848.     }
  849.  
  850.       /* there has to be an HUNK_END here... */
  851.       if (GL(amiga_data->file_pointer++)!=HUNK_END)
  852.     {
  853.       bfd_set_error(bfd_error_wrong_format);
  854.       return(false);
  855.     }
  856.       break;
  857.  
  858.     default:
  859.       bfd_set_error(bfd_error_wrong_format);
  860.       return false;
  861.       break;
  862.     }/* of switch hunk_type */
  863.  
  864.  
  865.   return(true);
  866.  
  867. }/* Of amiga_handle_cdb_hunk */
  868.  
  869.  
  870. /* Handle rest of a hunk 
  871.    I.e.: Relocs, EXT, SYMBOLS... */
  872. static boolean amiga_handle_rest(bfd *abfd, asection *current_section, boolean isload)
  873. {
  874.   amiga_data_type *amiga_data = AMIGA_DATA(abfd);
  875.   int hunk_type;
  876.   int type;
  877.   int len;
  878.   int n;
  879.   unsigned long **p;
  880.   struct amiga_raw_symbol *sp=NULL;
  881.  
  882.  
  883.   while (1)/* loop */
  884.     {
  885.       hunk_type=GL(amiga_data->file_pointer++);
  886.  
  887.  
  888.       switch (hunk_type)
  889.     {
  890.     case HUNK_END: /* Reached end */
  891.       return(true); /* Done */
  892.       break;
  893.  
  894.       /* Relocs.... */
  895.     case HUNK_RELOC8:
  896.     case HUNK_RELOC16:
  897.     case HUNK_RELOC32:
  898.     case HUNK_DREL8:
  899.     case HUNK_DREL16:
  900.     case HUNK_DREL32:
  901.       /* We leave them alone, but attach them to the section,
  902.          so we can read them in later.....*/
  903.       
  904.       /* But we already set the flags HAS_RELOC, SEC_RELOC */
  905.       /* We also maintain the reloc count */
  906.       /* This is simply done by adding all addresses of relocs to an array in the section */
  907.       p=amiga_per_section(current_section)->raw_relocs;
  908.       if (amiga_per_section(current_section)->max_raw_relocs<=
  909.           amiga_per_section(current_section)->num_raw_relocs) /* allocate more space */
  910.         {
  911.           if (p==NULL)
  912.         {
  913.           p=(unsigned long **)malloc(sizeof(unsigned long *)*10); /* initial */
  914.           amiga_per_section(current_section)->max_raw_relocs=10;
  915.           amiga_per_section(current_section)->num_raw_relocs=0;
  916.         }
  917.           else /* More space */
  918.         {
  919.           p=(unsigned long **)realloc((void *)p,
  920.                  sizeof(unsigned long *)*(amiga_per_section(current_section)->max_raw_relocs+30));
  921.           amiga_per_section(current_section)->max_raw_relocs+=30;
  922.         }
  923.  
  924.           if (p==NULL)
  925.         {
  926.           bfd_set_error(bfd_error_no_memory);
  927.           return(false);
  928.         }
  929.           amiga_per_section(current_section)->raw_relocs=p;
  930.         }
  931.       p[amiga_per_section(current_section)->num_raw_relocs++]=amiga_data->file_pointer-1;
  932.       
  933.       abfd->flags|=HAS_RELOC;
  934.       current_section->flags|=SEC_RELOC;
  935.  
  936.       /* Advance file_pointer */
  937.       while ((n=GL(amiga_data->file_pointer++)))
  938.         {
  939.           amiga_data->file_pointer+=1+n;
  940.           current_section->reloc_count+=n;
  941.         }
  942.  
  943.       break;
  944.  
  945.       /* Symbol definition */
  946.     case HUNK_SYMBOL:
  947.       /* In a unit, we ignore these, since all symbol information comes with HUNK_EXT,
  948.          in a load file, these are added */
  949.       if (!isload)
  950.         {
  951.           int foo;
  952.           
  953.           while ((foo=GL(amiga_data->file_pointer))!=0)
  954.         amiga_data->file_pointer+=foo+2;
  955.           amiga_data->file_pointer++;
  956.           break;
  957.         }
  958.       /* We add these, by falling through... */
  959.  
  960.     case HUNK_EXT:
  961.       /* We leave these alone, until they are requested by the user */
  962.       sp=amiga_per_section(current_section)->last;
  963.       
  964.       if (sp==NULL) /* First one added */
  965.         {
  966.           amiga_per_section(current_section)->last=amiga_per_section(current_section)->first=
  967.         (struct amiga_raw_symbol *)(amiga_data->file_pointer-1);
  968.           *(amiga_data->file_pointer-1)=0;
  969.         }
  970.       else
  971.         {
  972.           sp->next=(struct amiga_raw_symbol *)(amiga_data->file_pointer-1);
  973.           *(amiga_data->file_pointer-1)=0;
  974.           amiga_per_section(current_section)->last=sp->next;
  975.         }
  976.       /* skip these */
  977.  
  978.       while ((n=GL(amiga_data->file_pointer)))
  979.         {
  980.           amiga_data->file_pointer++;
  981.  
  982.           type=(n>>24)&0xff;
  983.           len=n&0xffffff;
  984.           
  985.           amiga_data->file_pointer+=len; /* skip name */
  986.  
  987.           switch(type)
  988.         {
  989.         case EXT_SYMB: /* Symbol hunks are relative to hunk start... */
  990.         case EXT_DEF: /* def relative to hunk */
  991.         case EXT_ABS: /* def absolute */
  992.           abfd->flags|=HAS_SYMS; /* We have symbols */
  993.           abfd->symcount++;
  994.           amiga_data->file_pointer++;
  995.           break;
  996.  
  997.         case EXT_REF8: /* 8 bit ref */
  998.         case EXT_REF16: /* 16 bit ref */
  999.         case EXT_REF32: /* 32 bit ref */
  1000.         case EXT_DEXT8: /* 8 bit base relative ref */
  1001.         case EXT_DEXT16: /* 16 bit " "*/
  1002.         case EXT_DEXT32: /* 32 bit " " */
  1003.           abfd->flags|=HAS_SYMS;
  1004.           n=GL(amiga_data->file_pointer);
  1005.           if (n)
  1006.             {
  1007.               abfd->flags|=HAS_RELOC;
  1008.               current_section->flags|=SEC_RELOC;
  1009.             }
  1010.           current_section->reloc_count+=n;
  1011.           amiga_data->file_pointer+=1+n;
  1012.           break;
  1013.           
  1014.         case EXT_COMMON: /* Common ref/def */
  1015.           abfd->flags|=HAS_SYMS;
  1016.           abfd->symcount++;
  1017.           n=GL(amiga_data->file_pointer+1);
  1018.           if (n)
  1019.             {
  1020.               abfd->flags|=HAS_RELOC;
  1021.               current_section->flags|=SEC_RELOC;
  1022.             }
  1023.               
  1024.           current_section->reloc_count+=n;
  1025.           amiga_data->file_pointer+=2+n;
  1026.           break;
  1027.           
  1028.         default: /* error */
  1029.           
  1030.           bfd_set_error(bfd_error_wrong_format);
  1031.           return false;
  1032.           break;
  1033.         }/* of switch type */
  1034.           
  1035.         }/* Of while */
  1036.       amiga_data->file_pointer++;
  1037.  
  1038.       break;
  1039.  
  1040.  
  1041.     default: /* error */
  1042.  
  1043.       bfd_set_error(bfd_error_wrong_format);
  1044.       return(false);
  1045.       break;
  1046.     }/* Of switch */
  1047.  
  1048.     }/* of while */
  1049.  
  1050.   return(true);
  1051.  
  1052. }/* of amiga_handle_rest*/
  1053.  
  1054.  
  1055.  
  1056. static boolean
  1057. amiga_mkobject (abfd)
  1058.      bfd *abfd;
  1059. {
  1060.   struct amiga_data_struct *rawptr;
  1061.  
  1062.   rawptr = (struct amiga_data_struct *) bfd_zalloc (abfd, sizeof (struct amiga_data_struct));
  1063.   abfd->tdata.amiga_data = rawptr;
  1064.  
  1065.   return true;
  1066. }
  1067.  
  1068.  
  1069. static boolean amiga_write_section_contents(bfd *, asection *);
  1070. static boolean amiga_write_symbols(bfd *, asection *);
  1071.  
  1072. /* used with base relative linking */
  1073. extern int amiga_base_relative;
  1074.  
  1075. /* Write out the contents of a bfd */
  1076. static boolean
  1077. amiga_write_object_contents (abfd)
  1078.      bfd *abfd;
  1079. {
  1080.   struct amiga_data_struct *amiga_data=AMIGA_DATA(abfd);
  1081.   sec_ptr p;
  1082.   unsigned long n[5];
  1083.   int i;
  1084.   char b[3];
  1085.  
  1086.   /* Distinguish UNITS, LOAD Files
  1087.     Write out hunks+relocs+HUNK_EXT+HUNK_DEBUG (GNU format)*/
  1088.   DPRINT(5,("Entering write_object_conts\n"));
  1089.  
  1090.   abfd->output_has_begun=true; /* Output has begun */
  1091.  
  1092.  
  1093.   /* Distinguish Load files and Unit files */
  1094.   if (amiga_data->IsLoadFile)
  1095.     {
  1096.       DPRINT(5,("Writing Load file\n"));
  1097.  
  1098.       /* Write out load file header */
  1099.       n[0]=HUNK_HEADER;
  1100.       n[1]=0;
  1101.       n[2]=abfd->section_count;
  1102.       /* If amiga_base_relative is set, we write out one hunk less */
  1103.       if (amiga_base_relative)
  1104.     {
  1105.       n[2]=abfd->section_count-1;
  1106.       BFD_ASSERT(abfd->section_count==3); /* Or we are in big trouble */
  1107.     }
  1108.  
  1109.       n[3]=0;
  1110.       n[4]=n[2]-1;
  1111.       if (bfd_write((PTR)(n),sizeof(unsigned long),5,abfd)!=5*sizeof(unsigned long))
  1112.     return false;
  1113.       /* Write out sizes and memory specifiers... */
  1114.       /* We have to traverse the section list again, bad but no other way... */
  1115.       for (p=abfd->sections;p!=NULL;p=p->next)
  1116.     {
  1117.       if (amiga_base_relative && (strcmp(p->name,".bss")==0)) /* skip */
  1118.         continue;
  1119.  
  1120.       /* Get  size for header*/
  1121.       if (amiga_per_section(p)->real_length!=0)
  1122.         n[0]=(amiga_per_section(p)->real_length)>>2;
  1123.       else
  1124.         n[0]=(p->_raw_size)>>2;
  1125.       i=amiga_per_section(p)->attribute;
  1126.       switch (i)
  1127.         {
  1128.         case MEMF_CHIP:
  1129.           n[0]|=0x40000000;
  1130.           i=1;
  1131.           break;
  1132.         case MEMF_FAST:
  1133.           n[0]|=0x80000000;
  1134.           i=1;
  1135.           break;
  1136.         case 0: /* nothing*/
  1137.           i=1;
  1138.           break;
  1139.         default: /* Special one */
  1140.           n[0]|=0xc0000000;
  1141.           n[1]=i;
  1142.           i=2;
  1143.           break;
  1144.         }/* Of switch */
  1145.  
  1146.       if (bfd_write((PTR)(n),sizeof(unsigned long),i,abfd)!=i*sizeof(unsigned long))
  1147.     return false;
  1148.     }/* Of for */
  1149.     }
  1150.   else
  1151.     {/* Unit , no base-relative linking here.... */
  1152.       /* Write out unit header */
  1153.       DPRINT(5,("Writing Unit\n"));
  1154.  
  1155.       n[0]=HUNK_UNIT;
  1156.       if (bfd_write((PTR)(n),sizeof(unsigned long),1,abfd)!=sizeof(unsigned long))
  1157.     return false;
  1158.  
  1159.       i=(strlen(abfd->filename)+3)>>2; /* longword size of name */
  1160.       if (bfd_write((PTR)(&i),sizeof(unsigned long),1,abfd)!=sizeof(unsigned long))
  1161.     return false;
  1162.       if (bfd_write((PTR)(abfd->filename),sizeof(char),strlen(abfd->filename),abfd)!=strlen(abfd->filename))
  1163.     return false;
  1164.       /* Pad to lw boundary */
  1165.       b[0]=b[1]=b[2]='\0';
  1166.       i=(i<<2)-strlen(abfd->filename);
  1167.       if (i)
  1168.     if (bfd_write((PTR)(b),sizeof(char),i,abfd)!=i)
  1169.       return false;
  1170.       /* That's all... for units :-)*/
  1171.     }
  1172.  
  1173.   /* Write out every section */
  1174.   for (p=abfd->sections;p!=NULL;p=p->next)
  1175.     {
  1176.       if (!amiga_write_section_contents(abfd,p)) /* Write out section data + relocs */
  1177.     return false;
  1178.  
  1179.       if (!amiga_write_symbols(abfd,p)) /* Write out symbols, incl HUNK_END */
  1180.     return false;
  1181.  
  1182.     }/* of for sections */
  1183.  
  1184.   /* Write out debug hunk, if requested */
  1185.   if (amiga_data->IsLoadFile && write_debug_hunk)
  1186.     {
  1187.       struct external_nlist {
  1188.     bfd_byte e_strx[BYTES_IN_WORD];       /* index into string table of name */
  1189.     bfd_byte e_type[1];                   /* type of symbol */
  1190.     bfd_byte e_other[1];                  /* misc info (usually empty) */
  1191.     bfd_byte e_desc[2];                   /* description field */
  1192.     bfd_byte e_value[BYTES_IN_WORD];      /* value of symbol */
  1193.       };
  1194.  
  1195.       extern boolean
  1196.     translate_to_native_sym_flags(bfd *, asymbol *, struct external_nlist *);
  1197.  
  1198.       /* We have to convert all the symbols in abfd to a.out style.... */
  1199.       struct external_nlist *data,*p; /* Were to put the data */
  1200.       char *strtab; /* string table */
  1201.       int str_size;
  1202.       int max_str_size;
  1203.       asymbol *sym;
  1204.       asection *s;
  1205.  
  1206.       if (abfd->symcount)
  1207.     {
  1208.       if ((data=(struct external_nlist *)malloc(sizeof(struct external_nlist)*abfd->symcount))==NULL)
  1209.         {
  1210.         hunk_no_mem:
  1211.           fprintf(stderr,"No memory for debug hunk, hunk not written\n");
  1212.           return true;
  1213.         }
  1214.  
  1215.       str_size=4; /* At least*/
  1216.       max_str_size=400; /* initial value */
  1217.       if ((strtab=(char *)malloc(max_str_size))==NULL)
  1218.         {
  1219.           free((void *)data);
  1220.           goto hunk_no_mem;
  1221.         }
  1222.       /* Now, set the .text, .data and .bss fields in the tdata struct (because
  1223.          translate_to_native_sym_flags needs them... */
  1224.       for (i=0,s=abfd->sections;s!=NULL;s=s->next)
  1225.         if (strcmp(s->name,".text")==0)
  1226.           {
  1227.         i|=1;
  1228.         adata(abfd).textsec=s;
  1229.           }
  1230.       else if (strcmp(s->name,".data")==0)
  1231.         {
  1232.           i|=2;
  1233.           adata(abfd).datasec=s;
  1234.         }
  1235.       else if (strcmp(s->name,".bss")==0)
  1236.         {
  1237.           i|=4;
  1238.           adata(abfd).bsssec=s;
  1239.         }
  1240.  
  1241.       if (i!=7) /* One section missing... */
  1242.         {
  1243. free_all:
  1244.           free(strtab);
  1245.           free(data);
  1246.           goto hunk_no_mem;
  1247.         }
  1248.  
  1249.  
  1250.       for (p=data,i=0;i<abfd->symcount;i++) /* Translate every symbol */
  1251.         {
  1252.           sym=abfd->outsymbols[i];
  1253.           if (sym!=NULL) /* NULL entries have been written already.... */
  1254.         {
  1255.           char *q;
  1256.  
  1257.           if (!translate_to_native_sym_flags(abfd,sym,p))
  1258.             goto free_all;
  1259.           /* Now, add the name of sym to the stringtab */
  1260.           while (max_str_size<=strlen(sym->name)+1+str_size)
  1261.             { /* Realloc space */
  1262.               if ((strtab=(char *)realloc(strtab, max_str_size+1024))==NULL)
  1263.             {
  1264.               free(data);
  1265.               goto hunk_no_mem;
  1266.             }
  1267.               max_str_size+=1024;
  1268.             }
  1269.           PUT_WORD(abfd,str_size,&(p->e_strx[0])); /* Store index */
  1270.           for (q=sym->name;strtab[str_size++]=*q++;)
  1271.             ;
  1272.           p++;
  1273.         }
  1274.         }
  1275.           
  1276.           
  1277.     
  1278.       /* Write out HUNK_DEBUG, size, 0413.... */
  1279.       n[0]=HUNK_DEBUG;
  1280.       n[1]=3+(((p-data)*sizeof(struct nlist)+str_size+3)>>2);
  1281.       n[2]=0413L; /* Magic number */
  1282.       n[3]=(p-data)*sizeof(struct nlist);
  1283.       n[4]=str_size;
  1284.       if (bfd_write((PTR)(n),sizeof(unsigned long),5,abfd)!=5*sizeof(unsigned long))
  1285.         return false;
  1286.  
  1287.       /* Write out symbols */
  1288.       if (bfd_write((PTR)(data),sizeof(struct nlist),(p-data),abfd)!=(p-data)*sizeof(struct nlist))
  1289.         return false;
  1290.       /* Write string tab */
  1291.       if (bfd_write((PTR)(strtab),sizeof(char),(str_size+3)&(~3),abfd)!=(str_size+3)&(~3))
  1292.         return false;
  1293.     }/* Of if abfd->symcount */
  1294.     }/* Of write out debug hunk */
  1295.  
  1296.   return true;
  1297. }
  1298.  
  1299.  
  1300. /* Write out section contents, including relocs */
  1301. static boolean
  1302. amiga_write_section_contents(bfd *abfd, asection * section)
  1303. {
  1304.   unsigned long n[2];
  1305.   int i,j;
  1306.   unsigned int k;
  1307.   char b[3];
  1308.   struct reloc_cache_entry *r;
  1309.   asection *osection,*sec,*insection;
  1310.   asymbol *sym_p;
  1311.   unsigned long *reloc_data=NULL;
  1312.   int reloc_count=0;
  1313.   unsigned long *reloc_out=NULL;
  1314.   unsigned long reloc_types[6]={HUNK_RELOC32, HUNK_RELOC16, HUNK_RELOC8,
  1315.                   HUNK_DREL32,HUNK_DREL16, HUNK_DREL8};
  1316.   int reloc_counts[6]={0,0,0,0,0,0};
  1317.   int out_size=0;
  1318.   int max_hunk=-1;
  1319.   int size=0;
  1320.   char *c_p;
  1321.   unsigned char *values;
  1322.  
  1323.   DPRINT(5,("Entered Write-section-conts\n"));
  1324.  
  1325.   /* If we are base-relative linking and the section is .bss and abfd is a load file, then return */
  1326.   if (AMIGA_DATA(abfd)->IsLoadFile && amiga_base_relative && (strcmp(section->name,".bss")==0))
  1327.     return true; /* Nothing 2 do */
  1328.  
  1329.   /* WRITE out HUNK_NAME + section name */
  1330.   n[0]=HUNK_NAME;
  1331.   j=strlen(section->name);
  1332.   i=(j+3)>>2; /* LW len of name */
  1333.   n[1]=i;
  1334.   if (bfd_write((PTR)(n),sizeof(unsigned long),2,abfd)!=2*sizeof(unsigned long))
  1335.     return false;
  1336.   if (bfd_write((PTR)(section->name),sizeof(char),j,abfd)!=j)
  1337.     return false;
  1338.   b[0]=b[1]=b[2]='\0';
  1339.   if ((i<<2)-j!=0) /* Pad */
  1340.     if(bfd_write((PTR)(b),sizeof(char),(i<<2)-j,abfd)!=((i<<2)-j))
  1341.       return false;
  1342.  
  1343.   /* Depending on the type of the section, write out HUNK_{CODE|DATA|BSS} */
  1344.   if (section->flags&SEC_CODE) /* Code section */
  1345.     n[0]=HUNK_CODE;
  1346.   else if (section->flags&SEC_DATA) /* data section */
  1347.     n[0]=HUNK_DATA;
  1348.   else if (section->flags&SEC_ALLOC) /* BSS */
  1349.     n[0]=HUNK_BSS;
  1350.   else /* Error */
  1351.     {
  1352.       bfd_set_error(bfd_error_nonrepresentable_section);
  1353.       return(false);
  1354.     }
  1355.  
  1356.   DPRINT(10,("Section type is %lx\n",n[0]));
  1357.  
  1358.   /* Get attribute for section */
  1359.   switch (amiga_per_section(section)->attribute)
  1360.     {
  1361.     case MEMF_CHIP:
  1362.       n[0]|=HUNKF_CHIP;
  1363.       break;
  1364.     case MEMF_FAST:
  1365.       n[0]|=HUNKF_FAST;
  1366.       break;
  1367.     case 0:
  1368.       break;
  1369.     default: /* error , can't represent this */
  1370.       bfd_set_error(bfd_error_nonrepresentable_section);
  1371.       return(false);
  1372.       break;
  1373.     }/* Of switch */
  1374.  
  1375.   DPRINT(10,("Section attribute is %lx\n",n[0]));
  1376.  
  1377.   /* Get real size in n[1], this may be shorter than the size in the header */
  1378.   n[1]=section->_cooked_size>>2;
  1379.   if(n[1]==0)
  1380.     n[1]=section->_raw_size>>2;
  1381.   if (bfd_write((PTR)(n),sizeof(unsigned long),2,abfd)!=2*sizeof(unsigned long))
  1382.       return false;
  1383.  
  1384.   DPRINT(5,("Wrote code and size=%lx\n",n[1]));
  1385.  
  1386.   /* If a BSS hunk, we're done, else write out section contents */
  1387.   if (HUNK_VALUE(n[0])==HUNK_BSS)
  1388.     return true;
  1389.  
  1390.   DPRINT(5,("Non bss hunk...\n"));
  1391.  
  1392.   /* Traverse through the relocs, sample them in reloc_data, adjust section data to get 0 addend
  1393.      Then compactify reloc_data 
  1394.      Set the entry in the section for the reloc to NULL */
  1395.  
  1396.   /* Get memory for relocs, we use upper bound */
  1397.   if ((reloc_data=(unsigned long *)malloc(5*sizeof(unsigned long)*section->reloc_count))==NULL)
  1398.     {
  1399.       bfd_set_error(bfd_error_no_memory);
  1400.       return(false);
  1401.     }
  1402.  
  1403.   BFD_ASSERT((section->flags&SEC_IN_MEMORY)!=0);
  1404.  
  1405.   DPRINT(5,("Section has %d relocs\n",section->reloc_count));
  1406.  
  1407.   for (i=0;i<section->reloc_count;i++)
  1408.     {
  1409.       r=section->orelocation[i];
  1410.  
  1411.       DPRINT(5,("Doing reloc %d=%lx(%d)\n",i,r,r?r->howto->type:-1));
  1412.  
  1413.       sym_p=*(r->sym_ptr_ptr); /* The symbol for this section */
  1414.  
  1415.       insection=sym_p->section;
  1416.  
  1417.       DPRINT(5,("Sec for reloc is %lx(%s)\n",insection,insection->name));
  1418.       DPRINT(5,("Symbol for this reloc is %lx(%s)\n",sym_p, sym_p->name));
  1419.       /* Is reloc relative to a special section ? */
  1420.       if ((insection==bfd_abs_section_ptr)||(insection==bfd_com_section_ptr)||
  1421.       (insection==bfd_und_section_ptr)||(insection==bfd_ind_section_ptr))
  1422.     continue; /* Nothing to do, since this translates to HUNK_EXT */
  1423.       
  1424.       r->addend+=sym_p->value; /* Add offset of symbol from section start */
  1425.       /* Address of reloc has been unchanged since original reloc, or has been adjusted by 
  1426.      get_relocated_section_contents */
  1427.       /* For relocs, the vma of the target section is in the data, the addend is
  1428.      -vma of that section =>No need to add vma*/
  1429.       /* Add in offset */
  1430.       r->addend+=insection->output_offset;
  1431.       osection=insection->output_section; /* target section */
  1432.  
  1433.       /* Determine which hunk to write, and index of target */
  1434.       reloc_data[5*reloc_count+1]=1; /* 1 reloc ==> Waste of space */
  1435.       for (j=0,sec=abfd->sections;sec!=NULL;sec=sec->next,j++)
  1436.     {
  1437.       if (sec==osection)
  1438.         break;
  1439.     }
  1440.    
  1441.       BFD_ASSERT(sec!=NULL);
  1442.       
  1443.       if (j>max_hunk) /* Maximum number used */
  1444.     max_hunk=j;
  1445.  
  1446.       reloc_data[5*reloc_count+2]=j;
  1447.       reloc_data[5*reloc_count+3]=r->address;
  1448.       reloc_data[5*reloc_count+4]=0;
  1449.  
  1450.       switch(r->howto->type) /* FIXME: Is this sufficient to distinguish them ?*/
  1451.     {
  1452.       /* AMIGA specific */
  1453.     case HUNK_RELOC8:
  1454.     case HUNK_RELOC16:
  1455.     case HUNK_RELOC32:
  1456.     case HUNK_DREL8:
  1457.     case HUNK_DREL16:
  1458.     case HUNK_DREL32:
  1459.       reloc_data[5*reloc_count+1]=r->howto->type;
  1460.       if (r->howto->type>=HUNK_DREL32)
  1461.         {
  1462.           size=2-(r->howto->type-HUNK_DREL32);
  1463.           reloc_counts[3+r->howto->type-HUNK_DREL32]++;
  1464.         }
  1465.       else
  1466.         {
  1467.           size=2-(r->howto->type-HUNK_RELOC32); /* 0:8bit, 1:16bit, 2:32 bit */
  1468.           reloc_counts[r->howto->type-HUNK_RELOC32]++;
  1469.         }
  1470.  
  1471.       break;
  1472.  
  1473.       /* Now, these may occur, if a.out was used as input */
  1474.     case 0: /* 8 bit ref */
  1475.       reloc_data[5*reloc_count]=HUNK_RELOC8;
  1476.       reloc_counts[2]++;
  1477.       size=0;
  1478.       break;
  1479.     case 1: /* 16 bit relative */
  1480.       reloc_data[5*reloc_count]=HUNK_RELOC16;
  1481.       reloc_counts[1]++;
  1482.       size=1;
  1483.       break;
  1484.     case 2: /* 32 bit relative */
  1485.       reloc_data[5*reloc_count]=HUNK_RELOC32;
  1486.       reloc_counts[0]++;
  1487.       size=2;
  1488.       break;
  1489.  
  1490.     case 9: /* 16 bit base rel */
  1491.       reloc_data[5*reloc_count+1]=HUNK_DREL16;
  1492.       reloc_counts[4]++;
  1493.       size=1;
  1494.       break;
  1495.  
  1496.     case 10: /* 32 bit baserel */
  1497.       reloc_data[5*reloc_count+1]=HUNK_DREL32;
  1498.       reloc_counts[3]++;
  1499.       size=2;
  1500.       break;
  1501.  
  1502.       /* FIXME: There are other (pc relative) displacements left */
  1503.     default: /* Error, can't represent this */
  1504.       bfd_set_error(bfd_error_nonrepresentable_section);
  1505.       free((void *)reloc_data);
  1506.       return false;
  1507.       break;
  1508.     }/* Of switch */
  1509.  
  1510.       section->orelocation[i]=NULL;
  1511.  
  1512.       c_p=((char*)(section->contents))+r->address;
  1513.       DPRINT(5,("reloc address=%lx,addend=%lx\n",r->address,r->addend));
  1514.  
  1515.       /* There is no error checking with these.. */
  1516.       values=(unsigned char *)c_p;
  1517.       switch (size)
  1518.     {
  1519.     case 0: /* adjust byte */
  1520.       j=(int)(*c_p);
  1521.       DPRINT(5,("content(b):%x\n",j));
  1522.       j+=r->addend;
  1523.       *c_p=(signed char)j;
  1524.       break;
  1525.     case 1: /* Adjust word */
  1526.       k=values[0]|(values[1]<<8);
  1527.       j=(int)k;
  1528.       DPRINT(5,("content(w):%x\n",j));
  1529.       j+=r->addend;
  1530.       values[0]=j&0xff;
  1531.       values[1]=(j&0xff00)>>8;
  1532.       break;
  1533.     case 2: /* adjust long */
  1534.       k=values[3]|(values[2]<<8)|(values[1]<<16)|(values[0]<<24);
  1535.       j=k;
  1536.       DPRINT(5,("content(l):%x\n",j));
  1537.       DPRINT(5,("[3,2,1,0]=%x,%x,%x,%x\n",values[3],values[2],values[1],values[0]));
  1538.       j+=r->addend;
  1539.       values[3]=j&0xff;
  1540.       values[2]=(j&0xff00)>>8;
  1541.       values[1]=(j&0xff0000)>>16;
  1542.       values[0]=(j&0xff000000)>>24;
  1543.       break;
  1544.     }/* of switch */
  1545.       r->addend=0;
  1546.       DPRINT(5,("Did adjusting\n"));
  1547.  
  1548.       reloc_count++;
  1549.     }/* of for i */
  1550.  
  1551.   DPRINT(5,("Did all relocs\n"));
  1552.  
  1553.   /* We applied all the relocs, as far as possible to obtain 0 addend fields */
  1554.   /* Write the section contents */
  1555.   if(bfd_write((PTR)(section->contents),sizeof(char),section->_raw_size,abfd)!=section->_raw_size)
  1556.       return false;
  1557.  
  1558.   DPRINT(10,("Wrote contents, writing relocs now\n"));
  1559.  
  1560.   /* We gathered all the relocs, now compactify them */
  1561.   if (!reloc_count) /* No reloc found ==> We are done */
  1562.     {
  1563.       free((void *)reloc_data);
  1564.       return true;
  1565.     }
  1566.  
  1567.   /* There are some relocs.... */
  1568.   /* Get mem for output array */
  1569.   if ((reloc_out=(unsigned long *)malloc(5*sizeof(unsigned long)*reloc_count))==NULL)
  1570.     {
  1571.       bfd_set_error(bfd_error_no_memory);
  1572.       free((void *)reloc_data);
  1573.       return false;
  1574.     }
  1575.  
  1576.   /* Sample every reloc type */
  1577.   for (i=0,out_size=0;i<6;i++)
  1578.     if (reloc_counts[i]!=0) /* there are some relocs of these */
  1579.       {
  1580.     int k,num;
  1581.  
  1582.     reloc_out[out_size++]=reloc_types[i];
  1583.     /* sample all of these, for every hunk */
  1584.     for (j=0;j<=max_hunk;j++) /* For every hunk */
  1585.       { /* Walk through reloc_data, */
  1586.         num=0; /* # relocs to hunk j */
  1587.         for (k=0;k<reloc_count;k++)
  1588.           if (reloc_data[5*k+2]==j) /* Reloc to this hunk */
  1589.         {
  1590.           if (!(num++)) /* one more and was first one */
  1591.             {
  1592.               reloc_out[out_size+1]=j; /* write hunk number */
  1593.             }
  1594.           reloc_out[out_size+1+num]=reloc_data[5*k+3]; /* offset */
  1595.         }
  1596.         if (num) /* There was at least one ref to this hunk */
  1597.           {
  1598.         reloc_out[out_size]=num; /* number of refs */
  1599.         out_size+=2+num; /* adjust */
  1600.           }
  1601.       } /* sampled all hunks */
  1602.     reloc_out[out_size++]=0; /* End of this reloc type */
  1603.       }/* Of if there is one reloc */
  1604.  
  1605.  
  1606.   DPRINT(10,("Sampled relocs, write them now\n"));
  1607.  
  1608.   /* Write out the relocs */
  1609.  
  1610.   if (bfd_write((PTR)reloc_out,sizeof(unsigned long),out_size,abfd)!=sizeof(unsigned long)*out_size)
  1611.     {
  1612.       free((void *)reloc_out);
  1613.       free((void *)reloc_data);
  1614.       return (false);
  1615.     }
  1616.  
  1617.   free ((void *)reloc_out);
  1618.   free ((void *)reloc_data);
  1619.  
  1620.   DPRINT(5,("Leaving write_section...\n"));
  1621.  
  1622.   return true;
  1623.  
  1624. }
  1625.  
  1626.  
  1627. /* Write out symbol information, including HUNK_EXT, DEFS, ABS */
  1628. /* In the case, we were linking base relative, the symbols of the .bss hunk have been converted already
  1629. to belong to the .data hunk */
  1630. static boolean amiga_write_symbols(bfd *abfd, asection *section)
  1631. {
  1632.  
  1633.   int i,j;
  1634.   struct reloc_cache_entry *r;
  1635.   asection *osection;
  1636.   asymbol *sym_p;
  1637.   char b[3]="\0\0\0";
  1638.   unsigned long n[3];
  1639.   int symbol_count;
  1640.   unsigned int symbol_header;
  1641.   unsigned long type;
  1642.   int len;
  1643.  
  1644.   /* If base rel linking and section is .bss ==> exit */
  1645.   if (amiga_base_relative && (strcmp(section->name,".bss")==0))
  1646.     return true;
  1647.  
  1648.   if (section->reloc_count==0 && abfd->symcount==0)
  1649.     {/* Write HUNK_END */
  1650.     alldone:
  1651.       DPRINT(5,("Leaving write_symbols\n"));
  1652.       n[0]=HUNK_END;
  1653.       return(bfd_write((PTR)n,sizeof(unsigned long),1,abfd)==sizeof(unsigned long));
  1654.     }
  1655.  
  1656.   symbol_count=0;
  1657.   symbol_header=HUNK_EXT;
  1658.  
  1659.   /* If this is Loadfile, then do not write HUNK_EXT, but rather HUNK_SYMB*/
  1660.  
  1661.  /* Write out all the symbol definitions, then HUNK_END 
  1662.  
  1663.      Now, first traverse the relocs, all entries that are non NULL
  1664.      have to be taken into account */
  1665.   /* Determine the type of HUNK_EXT to issue and build a single HUNK_EXT subtype */
  1666.  
  1667.  
  1668.   /*FIXME: We write out many HUNK_EXT's entries for references to the same symbol.. */
  1669.   for (i=0;i<section->reloc_count;i++)
  1670.     {
  1671.       r=section->orelocation[i];
  1672.  
  1673.       if (r==NULL) /* Empty entry */
  1674.     continue;
  1675.  
  1676.       sym_p=*(r->sym_ptr_ptr); /* The symbol for this section */
  1677.  
  1678.       osection=sym_p->section; /* The section the symbol belongs to */
  1679.       /* this section MUST be a special section */
  1680.  
  1681.       DPRINT(5,("Symbol is %s, section is %lx(%s)\n",sym_p->name,osection,osection->name));
  1682.  
  1683.       if (osection!=bfd_com_section_ptr) /* Not common symbol */
  1684.     {
  1685.       DPRINT(5,("Non common ref\n"));
  1686.       /* Add a reference to this HUNK */
  1687.       if ((symbol_count++)==0) /* First write out the HUNK_EXT */
  1688.         {
  1689.           j=HUNK_EXT;
  1690.           if(bfd_write((PTR)(&j),sizeof(int),1,abfd)!=sizeof(int))
  1691.         return false;
  1692.         }
  1693.  
  1694.       /* Determine type of ref */
  1695.       switch(r->howto->type) /* FIXME: Is this sufficient to distinguish them ?*/
  1696.         {
  1697.           /* AMIGA specific */
  1698.         case 0:
  1699.         case HUNK_RELOC8:
  1700.           type=EXT_REF8;
  1701.           break;
  1702.  
  1703.         case 1:
  1704.         case HUNK_RELOC16:
  1705.           type=EXT_REF16;
  1706.           break;
  1707.  
  1708.         case 2:
  1709.         case HUNK_RELOC32:
  1710.           type=EXT_REF32;
  1711.           break;
  1712.         case HUNK_DREL8:
  1713.           type=EXT_DEXT8;
  1714.           break;
  1715.  
  1716.         case 9:
  1717.         case HUNK_DREL16:
  1718.           type=EXT_DEXT16;
  1719.           break;
  1720.  
  1721.         case 10:
  1722.         case HUNK_DREL32:
  1723.             type=EXT_DEXT32;
  1724.           break;
  1725.           
  1726.           /* FIXME: There are other (pc relative) displacements left */
  1727.         default: /* Error, can't represent this */
  1728.           bfd_set_error(bfd_error_nonrepresentable_section);
  1729.           return false;
  1730.           break;
  1731.         }/* Of switch */
  1732.       DPRINT(5,("Type is %x\n",type));
  1733.  
  1734.       type<<=24;
  1735.       type&=0xff000000;
  1736.  
  1737.       j=strlen(sym_p->name);
  1738.       len=(j+3)>>2; /* LW Len of name */
  1739.       
  1740.       type|=(len & 0xffffff);
  1741.       if (bfd_write((PTR)(&type),sizeof(unsigned long),1,abfd)!=sizeof(unsigned long))
  1742.         return false;
  1743.  
  1744.       if (bfd_write((PTR)(sym_p->name),sizeof(char),j,abfd)!=j)
  1745.         return false;
  1746.  
  1747.       if ((len<<2)-j!=0) /* Pad name */
  1748.         if (bfd_write((PTR)(b),sizeof(char),(len<<2)-j,abfd)!=((len<<2)-j))
  1749.           return false;
  1750.  
  1751.       n[0]=1; /* 1 ref at address... */
  1752.       n[1]=r->address;
  1753.  
  1754.       if (bfd_write((PTR)(n),sizeof(unsigned long),2,abfd)!=2*sizeof(long))
  1755.         return false;
  1756.       
  1757.       continue; /* Next relocation */
  1758.     }/* Of is ref to undefined or abs symbol */
  1759.  
  1760.       
  1761.       if (osection==bfd_com_section_ptr) /* ref to common symbol */
  1762.     {
  1763.       DPRINT(5,("Common ref\n"));
  1764.  
  1765.       /* If the reference is NOT 32 bit wide absolute , then issue warning */
  1766.       if ((r->howto->type!=2)&&(r->howto->type!=HUNK_RELOC32))
  1767.         fprintf(stderr,"Warning: Non 32 bit wide reference to common symbol %s\n",
  1768.             sym_p->name);
  1769.  
  1770.       if ((symbol_count++)==0) /* First write out the HUNK_EXT */
  1771.         {
  1772.           j=HUNK_EXT;
  1773.           if(bfd_write((PTR)(&j),sizeof(int),1,abfd)!=sizeof(int))
  1774.         return false;
  1775.         }
  1776.  
  1777.       type=(EXT_COMMON<<24)&0xff000000;
  1778.  
  1779.       j=strlen(sym_p->name);
  1780.  
  1781.       len=(j+3)>>2;
  1782.       type|=(len&0xffffff);
  1783.  
  1784.       if (bfd_write((PTR)(&type),sizeof(unsigned long),1,abfd)!=sizeof(unsigned long))
  1785.         return false;
  1786.       if (bfd_write((PTR)(sym_p->name),sizeof(char),j,abfd)!=j)
  1787.         return false;
  1788.       
  1789.       if ((len<<2)-j!=0) /* Pad name */
  1790.         if (bfd_write((PTR)(b),sizeof(char),(len<<2)-j,abfd)!=((len<<2)-j))
  1791.           return false;
  1792.       n[0]=sym_p->value; /* Size of common block */
  1793.       n[1]=1;
  1794.       n[2]=r->address;
  1795.  
  1796.       if (bfd_write((PTR)(n),sizeof(unsigned long),3,abfd)!=3*sizeof(long))
  1797.         return false;
  1798.       
  1799.       continue;
  1800.     }/* Of is common section */
  1801.  
  1802.       DPRINT(10,("Failing...\n"));
  1803.       BFD_FAIL();
  1804.     }/* Of traverse relocs */
  1805.       
  1806.       
  1807.   /* Now traverse the symbol table and write out all definitions, that are relative
  1808.      to this hunk */
  1809.   /* Absolute defs are always only written out with the first hunk */
  1810.   /* Don't write out COMMON symbols
  1811.                      local symbols
  1812.                      undefined symbols
  1813.              indirect symbols
  1814.              warning symbols
  1815.              debugging symbols
  1816.              warning symbols
  1817.              constructor symbols, since they are unrepresentable in HUNK format..*/
  1818.  
  1819.   DPRINT(10,("Traversing symbol table\n"));
  1820.   symbol_header=(AMIGA_DATA(abfd)->IsLoadFile)?HUNK_SYMBOL:HUNK_EXT;
  1821.   for (i=0;i<abfd->symcount;i++)
  1822.     {
  1823.       sym_p=abfd->outsymbols[i];
  1824.       osection=sym_p->section;
  1825.  
  1826.       DPRINT(5,("%d. symbol(%s), osec=%x(%s)\n",i,sym_p->name,osection,osection->name));
  1827.  
  1828.       if ((osection==bfd_und_section_ptr)||(osection==bfd_com_section_ptr)||
  1829.       (osection==bfd_ind_section_ptr))
  1830.     continue; /* Don't write these */
  1831.  
  1832.       /* Only write abs defs, if not writing A Loadfile */
  1833.       if ((osection==bfd_abs_section_ptr)&&(section->index==0)&&!AMIGA_DATA(abfd)->IsLoadFile) /* Write out abs defs */
  1834.     {
  1835.       DPRINT(5,("Abs symbol\n"));
  1836.       if ((symbol_count++)==0) /* First write out the HUNK_EXT */
  1837.         {
  1838.           if(bfd_write((PTR)(&symbol_header),sizeof(int),1,abfd)!=sizeof(int))
  1839.         return false;
  1840.         }
  1841.       type=(EXT_ABS<<24)&0xff000000;
  1842.  
  1843.       j=strlen(sym_p->name);
  1844.       
  1845.       len=(j+3)>>2;
  1846.       
  1847.       type|=(len & 0xffffff);
  1848.  
  1849.       if (bfd_write((PTR)(&type),sizeof(unsigned long),1,abfd)!=sizeof(unsigned long))
  1850.         return false;
  1851.       if (bfd_write((PTR)(sym_p->name),sizeof(char),j,abfd)!=j)
  1852.         return false;
  1853.       
  1854.       if ((len<<2)-j!=0) /* Pad name */
  1855.         if (bfd_write((PTR)(b),sizeof(char),(len<<2)-j,abfd)!=((len<<2)-j))
  1856.           return false;
  1857.       
  1858.       n[0]=sym_p->value;
  1859.       if (bfd_write((PTR)n,sizeof(unsigned long),1,abfd)!=sizeof(unsigned long))
  1860.         return false;
  1861.       continue;
  1862.     }/* Of abs def */
  1863.       if (osection==bfd_abs_section_ptr) /* Not first hunk. Already written */
  1864.     continue;
  1865.  
  1866.       /* If it is a warning symbol, or a constructor symbol or a debugging or a local symbol,
  1867.      don't write it */
  1868.       if (sym_p->flags & (BSF_WARNING|BSF_CONSTRUCTOR|BSF_DEBUGGING|BSF_LOCAL))
  1869.     continue;
  1870.  
  1871.       /* Now, if osection==section, write it out */
  1872.       if (osection->output_section==section)
  1873.     {
  1874.       DPRINT(5,("Writing it out\n"));
  1875.  
  1876.       if ((symbol_count++)==0) /* First write out the header */
  1877.         {
  1878.           if(bfd_write((PTR)(&symbol_header),sizeof(int),1,abfd)!=sizeof(int))
  1879.         return false;
  1880.         }
  1881.       type=((symbol_header==HUNK_EXT?EXT_DEF:0)<<24)&0xff000000;
  1882.  
  1883.       j=strlen(sym_p->name);
  1884.       
  1885.       len=(j+3)>>2;
  1886.       
  1887.       type|=(len & 0xffffff);
  1888.  
  1889.       if (bfd_write((PTR)(&type),sizeof(unsigned long),1,abfd)!=sizeof(unsigned long))
  1890.         return false;
  1891.       if (bfd_write((PTR)(sym_p->name),sizeof(char),j,abfd)!=j)
  1892.         return false;
  1893.       
  1894.       if ((len<<2)-j!=0) /* Pad name */
  1895.         if (bfd_write((PTR)(b),sizeof(char),(len<<2)-j,abfd)!=((len<<2)-j))
  1896.           return false;
  1897.  
  1898.       n[0]=sym_p->value+sym_p->section->output_offset;
  1899.       if (bfd_write((PTR)n,sizeof(unsigned long),1,abfd)!=sizeof(unsigned long))
  1900.         return false;
  1901.     }/* Of this section */
  1902.     }/* Of for */
  1903.  
  1904.   DPRINT(10,("Did traversing\n"));
  1905.   if (symbol_count) /* terminate HUNK_EXT, HUNK_SYMBOL */
  1906.     {
  1907.       n[0]=0;
  1908.       if (bfd_write((PTR)n,sizeof(unsigned long),1,abfd)!=sizeof(unsigned long))
  1909.     return false;
  1910.     }
  1911.   DPRINT(5,("Leaving\n"));
  1912.   goto alldone; /* Write HUNK_END, return */
  1913.  
  1914. }
  1915.  
  1916.  
  1917. static boolean
  1918. amiga_get_section_contents (abfd, section, location, offset, count)
  1919.      bfd *abfd;
  1920.      sec_ptr section;
  1921.      PTR location;
  1922.      file_ptr offset;
  1923.      bfd_size_type count;
  1924. {
  1925.   memmove ((void *) location,
  1926.        (void *) (((int) AMIGA_DATA(abfd)->first_byte)
  1927.              + (int) section->filepos
  1928.              + (int) offset),
  1929.        count);
  1930.   return true;
  1931. }
  1932.  
  1933. boolean
  1934. amiga_new_section_hook (abfd, newsect)
  1935.      bfd *abfd;
  1936.      asection *newsect;
  1937. {
  1938.   newsect->used_by_bfd = (PTR) bfd_zalloc (abfd, sizeof (amiga_per_section_type));
  1939.   newsect->alignment_power = 2;
  1940.   amiga_per_section(newsect)->reloc_tail = NULL;
  1941.   return true;
  1942. }
  1943.  
  1944.  
  1945. /* This reads the symbol table, by following various pointers,
  1946.    set up by amiga_digest_file */
  1947. static boolean
  1948. amiga_slurp_symbol_table (abfd)
  1949.      bfd *abfd;
  1950. {
  1951.   /* slurp in symbols, associated with this bfd */
  1952.   amiga_data_type *amiga_data=AMIGA_DATA(abfd);
  1953.   asection *section;
  1954.   struct amiga_raw_symbol *sp;
  1955.   amiga_symbol_type *asp=NULL;
  1956.   unsigned long *lp;
  1957.   int len;
  1958.   int type;
  1959.  
  1960.   if (amiga_data->symbols)
  1961.     return true; /* already read */
  1962.  
  1963.   /* Symbols are associated with every section */
  1964.   for (section=abfd->sections;section!=NULL;section=section->next)
  1965.     {
  1966.       for (sp=amiga_per_section(section)->first;sp!=NULL;sp=sp->next)
  1967.     {
  1968.       lp=&(sp->data[0]);
  1969.       while (*lp)
  1970.         {
  1971.           type =(*lp)>>24; /* type of entry */
  1972.           len=(*lp++)&0xffffff; /* namelength */
  1973.           
  1974.           switch(type)
  1975.         {
  1976.         case EXT_COMMON: /* Common reference/definition*/
  1977.         case EXT_ABS: /* Absolute */
  1978.         case EXT_DEF: /* Relative Definition */
  1979.         case EXT_SYMB: /* Same as EXT_DEF for load files */
  1980.           /* Add symbol to section.... */
  1981.           /* We don't have to increase symcount, this has already been done */
  1982.           
  1983.           asp=(amiga_symbol_type *)bfd_zalloc(abfd,sizeof(amiga_symbol_type));
  1984.           if (!asp) /* No mem */
  1985.             {
  1986.               bfd_set_error(bfd_error_no_memory);
  1987.               return(false);
  1988.             }
  1989.           
  1990.           /* Add symbol to list of all symbols */
  1991.           asp->next=NULL;
  1992.           if (!amiga_data->symbols) /* first one */
  1993.             {
  1994.               amiga_data->symbols=amiga_data->symbol_tail=asp;
  1995.             }
  1996.           else
  1997.             {
  1998.               amiga_data->symbol_tail->next=asp;
  1999.               amiga_data->symbol_tail=asp;
  2000.             }
  2001.  
  2002.           asp->symbol.section=((type==EXT_DEF)||(type==EXT_SYMB))?section:(type==EXT_COMMON)?
  2003.                bfd_com_section_ptr:bfd_abs_section_ptr;
  2004.           asp->symbol.flags=BSF_GLOBAL;
  2005.           asp->symbol.value=lp[len];
  2006.           asp->symbol.the_bfd=abfd;
  2007.           asp->type=type;
  2008.           asp->hunk_number=((type==EXT_DEF)||(type==EXT_SYMB))?section->target_index:
  2009.              (type==EXT_ABS)?-1:-3;
  2010.           if ((asp->symbol.name=bfd_alloc(abfd,(len<<2)+1))==NULL)
  2011.             {
  2012.               bfd_set_error(bfd_error_no_memory);
  2013.               return(false);
  2014.             } 
  2015.           strncpy((char *)(asp->symbol.name),(char *)lp,len<<2);
  2016.           ((char*)(asp->symbol.name))[(len<<2)]='\0';
  2017.  
  2018.           /* Now store the symbol in the first name longword */
  2019.           *lp=(unsigned long)asp;
  2020.  
  2021.           lp+=len+1;
  2022.  
  2023.           if (type==EXT_COMMON) /* skip refs */
  2024.             lp+=(*lp)+1;
  2025.  
  2026.           break;
  2027.  
  2028.         default: /* References to an undefined symbol */
  2029.           /* Problem is that this symbol may be defined in another hunk WITHIN this bfd */
  2030.           /* To avoid conflicts with bfd, we simply scan through the list of already defined symbols
  2031.              and add a symbol only, if we did not find it */
  2032.  
  2033.           for (asp=amiga_data->symbols;asp!=NULL;asp=asp->next)
  2034.             {
  2035.               if (strncmp((char *)lp,asp->symbol.name,len<<2)==0)
  2036.             break; /* Found symbol */
  2037.             }
  2038.  
  2039.           if (asp==NULL) /* Symbol not  defined */
  2040.             {
  2041.               asp=(amiga_symbol_type *)bfd_zalloc(abfd,sizeof(amiga_symbol_type));
  2042.               if (!asp) /* No mem */
  2043.             {
  2044.               bfd_set_error(bfd_error_no_memory);
  2045.               return(false);
  2046.             }
  2047.               
  2048.               /* Add symbol to list of all symbols */
  2049.               asp->next=NULL;
  2050.               if (!amiga_data->symbols) /* first one */
  2051.             {
  2052.               amiga_data->symbols=amiga_data->symbol_tail=asp;
  2053.             }
  2054.               else
  2055.             {
  2056.               amiga_data->symbol_tail->next=asp;
  2057.               amiga_data->symbol_tail=asp;
  2058.             }
  2059.               if ((asp->symbol.name=bfd_alloc(abfd,(len<<2)+1))==NULL)
  2060.             {
  2061.               bfd_set_error(bfd_error_no_memory);
  2062.               return(false);
  2063.             } 
  2064.               strncpy((char *)(asp->symbol.name),(const char *)lp,len<<2);
  2065.               ((char *)(asp->symbol.name))[(len<<2)]='\0';
  2066.  
  2067.               asp->symbol.section=bfd_und_section_ptr;
  2068.               asp->symbol.flags=0;
  2069.               asp->symbol.the_bfd=abfd;
  2070.               asp->hunk_number=-2;
  2071.               asp->type=type;
  2072.               abfd->symcount++;
  2073.  
  2074.             }
  2075.           
  2076.           /* Store symbol in 1st LW of name */
  2077.           *lp=(unsigned long)asp;
  2078.           lp+=len;
  2079.           lp+=1+(*lp); /* skip refs */
  2080.           break;
  2081.         }/* Of switch type */
  2082.         }/* Of while *lp */
  2083.     }/* of for sp */
  2084.     }/* Of for section */
  2085.  
  2086.  
  2087.   return true;
  2088. }
  2089.  
  2090.  
  2091. /* Get size of symtab */
  2092. long
  2093. amiga_get_symtab_upper_bound (abfd)
  2094.      bfd *abfd;
  2095. {
  2096.   /* We read in the symbol table first */
  2097.   if (!amiga_slurp_symbol_table (abfd))
  2098.     return -1;
  2099.  
  2100.   return (abfd->symcount != 0) ?
  2101.     (abfd->symcount+1) * (sizeof (amiga_symbol_type *)) : 0;
  2102. }
  2103.  
  2104. long
  2105. amiga_get_symtab (abfd, location)
  2106.      bfd *abfd;
  2107.      asymbol **location;
  2108. {
  2109.   amiga_symbol_type *symp;
  2110.  
  2111.   if(!amiga_slurp_symbol_table(abfd))
  2112.     return -1;
  2113.  
  2114.   if (abfd->symcount)
  2115.     {
  2116.       int i = 0;
  2117.  
  2118.       for (symp = AMIGA_DATA(abfd)->symbols;
  2119.                  symp != (amiga_symbol_type *) NULL;
  2120.                  symp = symp->next)
  2121.     {
  2122.       location[i++] = &symp->symbol;
  2123.     }
  2124.     }
  2125.   return abfd->symcount;
  2126. }
  2127.  
  2128. asymbol *
  2129. amiga_make_empty_symbol (abfd)
  2130.      bfd *abfd;
  2131. {
  2132.   amiga_symbol_type *new =
  2133.     (amiga_symbol_type *) bfd_zalloc (abfd, sizeof (amiga_symbol_type));
  2134.   new->symbol.the_bfd = abfd;
  2135.   return &new->symbol;
  2136. }
  2137.  
  2138.  
  2139.  
  2140. void
  2141. amiga_get_symbol_info (ignore_abfd, symbol, ret)
  2142.       bfd *ignore_abfd;
  2143.       asymbol *symbol;
  2144.       symbol_info *ret;
  2145. {
  2146.   bfd_symbol_info (symbol, ret);
  2147.   if (symbol->name[0] == ' ')
  2148.     ret->name = "* empty table entry ";
  2149.   if (symbol->section==bfd_abs_section_ptr)
  2150.     ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
  2151. }
  2152.  
  2153.  
  2154.  
  2155. void
  2156. amiga_print_symbol (ignore_abfd, afile,  symbol, how)
  2157.       bfd *ignore_abfd;
  2158.       PTR afile;
  2159.       asymbol *symbol;
  2160.       bfd_print_symbol_type how;
  2161. {
  2162.   FILE *file = (FILE *)afile;
  2163.   
  2164.   switch (how) {
  2165.   case bfd_print_symbol_name:
  2166.     fprintf(file, "%s", symbol->name);
  2167.     break;
  2168.   case bfd_print_symbol_more:
  2169.     fprintf(stderr,"%4x %2x %2x",
  2170.         (unsigned int)((amiga_symbol(symbol)->hunk_number)&0xffff),0,amiga_symbol(symbol)->type);
  2171.     break;
  2172.   case bfd_print_symbol_all:
  2173.       {
  2174.     CONST char *section_name = symbol->section->name;
  2175.     if (symbol->name[0] == ' ')
  2176.       {
  2177.         fprintf(file, "* empty table entry ");
  2178.       }
  2179.     else
  2180.       {
  2181.         bfd_print_symbol_vandf ((PTR)file, symbol);
  2182.  
  2183.         fprintf(file," %-5s %04x %02x %s",
  2184.             section_name,
  2185.             (unsigned int)((amiga_symbol(symbol)->hunk_number)&0xffff),  /* ->desc */
  2186.             (unsigned) 0,                       /* ->other */
  2187.                                                 /* type */
  2188.             symbol->name);                      /* ->name */
  2189.     }
  2190.       }
  2191.     break;
  2192.   }
  2193. }
  2194.  
  2195.  long
  2196. amiga_get_reloc_upper_bound (abfd, asect)
  2197.      bfd *abfd;
  2198.      sec_ptr asect;
  2199. {
  2200.   if (bfd_get_format (abfd) != bfd_object)
  2201.     {
  2202.       bfd_set_error(bfd_error_invalid_operation);
  2203.       return 0;
  2204.     }
  2205.   return sizeof (arelent *) * (asect->reloc_count + 1);
  2206. }
  2207.  
  2208.  
  2209. /* slurp in relocs , amiga_digest_file left various pointers for us*/
  2210. static boolean 
  2211. amiga_slurp_relocs(bfd *abfd, sec_ptr section, asymbol **symbols)
  2212. {
  2213.   struct amiga_raw_symbol *sp;
  2214.   amiga_symbol_type *asp;
  2215.   long *lp;
  2216.   
  2217.   int i,n,br,j;
  2218.   int index;
  2219.   long hunk_number;
  2220.   int type;
  2221.  
  2222.   /* First browse through raw_relocs */
  2223.   for (i=0;i<amiga_per_section(section)->num_raw_relocs;i++)
  2224.     {
  2225.       lp=amiga_per_section(section)->raw_relocs[i];
  2226.  
  2227.       /* lp points to RELOC ID */
  2228.       /* first determine type of reloc */
  2229.       switch (*lp)
  2230.     {
  2231.     case HUNK_RELOC32: /* 32 bit ref */
  2232.     case HUNK_RELOC16: /* 16 bit ref */
  2233.     case HUNK_RELOC8: /* 8 bit ref */
  2234.     case HUNK_DREL32: /* 32 bit ref baserel */
  2235.     case HUNK_DREL16: /* 16 bit baserel */
  2236.     case HUNK_DREL8: /* 8 bit baserel */
  2237.       if (*lp<HUNK_DREL32)
  2238.         { /*0:8bit, 1: 16bit, 2:32bit */
  2239.           index=2-((*lp)-HUNK_RELOC32);
  2240.           br=0; /* not base relative */
  2241.         }
  2242.       else
  2243.         {
  2244.           index=2-((*lp)-HUNK_DREL32);
  2245.           br=1; /* base relative */
  2246.         }
  2247.  
  2248.       lp++;
  2249.       while ((n=*lp++)) /* read offsets and hunk number */
  2250.         {
  2251.           hunk_number=(long)(*lp++);
  2252.           for (j=0;j<n;j++)
  2253.         { /* add relocs */
  2254.  
  2255.           if (!amiga_add_reloc(abfd,section,lp[j],NULL,
  2256.                        amiga_howto_array[br][index],hunk_number))
  2257.             return false;
  2258.         }/* of for */
  2259.           lp+=n;
  2260.         }/* of while */
  2261.       break;
  2262.  
  2263.     default: /* error */
  2264.       bfd_set_error(bfd_error_wrong_format);
  2265.       return (false);
  2266.       break;
  2267.     }/* of switch */
  2268.  
  2269.     }/* of for i */
  2270.   
  2271.  
  2272.   /* Now step through the raw_symbols and add all relocs in them */
  2273.   for (sp=amiga_per_section(section)->first;sp!=NULL;sp=sp->next)
  2274.     {
  2275.       lp=&(sp->data[0]);
  2276.       /* points to id */
  2277.  
  2278.       while (*lp) /* until end is reached */
  2279.     {
  2280.       type=((*lp)>>24)&0xff;
  2281.       n=(*lp++)&0xffffff;
  2282.  
  2283.       /* lp points to symbol pointer (former 1st LW of name )*/
  2284.       asp=(amiga_symbol_type *)(*lp);
  2285.  
  2286.       switch (type)
  2287.         {
  2288.         case EXT_SYMB:
  2289.         case EXT_DEF:
  2290.         case EXT_ABS: /* no relocs here, just advance the pointer */
  2291.           lp+=1+n;
  2292.           break;
  2293.  
  2294.         case EXT_COMMON: /* same as below, but advance lp by one to skip common size */
  2295.           lp++;
  2296.           /* Fall through */
  2297.         default: /* reference to something */
  2298.           /* skip name first */
  2299.           lp+=n;
  2300.  
  2301.           /* points to num of refs to hunk */
  2302.           n=*lp++;
  2303.  
  2304.           for (i=0;i<n;i++) /* refs follow */
  2305.         {
  2306.           /* Add relocs to this section, relative to asp, offset is lp[i] */
  2307.           /* determine howto first */
  2308.           if (type==EXT_COMMON) /* 32 bit ref */
  2309.             {
  2310.               index=2;
  2311.               br=0;
  2312.             }
  2313.           else
  2314.             {
  2315.               if (type>EXT_REF32)
  2316.             type--; /* skip EXT_COMMON gap */
  2317.              
  2318.              type-=EXT_REF32;
  2319.              br=0;
  2320.  
  2321.              if (type>2) /* base relative */
  2322.                {
  2323.              type-=3;
  2324.              br=1;
  2325.                }
  2326.              index=2-type;
  2327.             }/* of else */
  2328.           
  2329.           if (!amiga_add_reloc(abfd,section,lp[i],asp,amiga_howto_array[br][index],-4))
  2330.             return false;
  2331.         }
  2332.           
  2333.           lp+=n;
  2334.           
  2335.           break;
  2336.         }/* of switch */
  2337.     }/* of while *lp */
  2338.     }/* Of for sp*/
  2339.  
  2340.   return true;
  2341.  
  2342. }/* Of slurp_relocs */
  2343.  
  2344.  
  2345. long
  2346. amiga_canonicalize_reloc (abfd, section, relptr, symbols)
  2347.      bfd *abfd;
  2348.      sec_ptr section;
  2349.      arelent **relptr;
  2350.      asymbol **symbols;
  2351. {
  2352.  
  2353.   amiga_reloc_type *src = NULL;
  2354.  
  2355.   if (!amiga_slurp_relocs(abfd,section,symbols))
  2356.     return -1;
  2357.  
  2358.   src=(amiga_reloc_type *)section->relocation;
  2359.   while (src != (amiga_reloc_type *) 0)
  2360.     {
  2361.       *relptr++ = &src->relent;
  2362.       src = src->next;
  2363.     }
  2364.   *relptr = (arelent *) 0;
  2365.  
  2366.   return section->reloc_count;
  2367. }
  2368.  
  2369.  
  2370. /* Set section contents */
  2371. /* We do it the following way: 
  2372.    if this is a bss setion ==> error
  2373.    otherwise, we try to allocate space for this section,
  2374.    if  this has not already been done
  2375.    Then we set the memory area to the contents */
  2376. static boolean
  2377. amiga_set_section_contents (abfd, section, location, offset, count)
  2378.      bfd *abfd;
  2379.      sec_ptr section;
  2380.      unsigned char *location;
  2381.      file_ptr offset;
  2382.       int count;
  2383. {
  2384.   unsigned char *contents;
  2385.  
  2386.   if ((section->flags&SEC_HAS_CONTENTS)==0) /* BSS */
  2387.     {
  2388.       bfd_set_error(bfd_error_invalid_operation);
  2389.       return false;
  2390.     }
  2391.   
  2392.   if ((section->flags&SEC_IN_MEMORY)==0) /* Not in memory, so alloc space */
  2393.     {
  2394.       contents=bfd_zalloc(abfd,section->_raw_size);
  2395.       if (!contents)
  2396.     {
  2397.       bfd_set_error(bfd_error_no_memory);
  2398.       return false;
  2399.     }
  2400.       
  2401.       DPRINT(5,("Allocated %lx bytes at %lx\n",section->_raw_size,contents));
  2402.  
  2403.       section->contents=contents;
  2404.       section->flags|=SEC_IN_MEMORY;
  2405.     }
  2406.   else /* In memory */
  2407.     contents=section->contents;
  2408.  
  2409.   /* Copy mem */
  2410.   memmove(contents+offset,location,count);
  2411.  
  2412.   return(true);
  2413.  
  2414. }/* Of section_set_contents */
  2415.  
  2416.  
  2417. /* FIXME: Is this everything ? */
  2418. static boolean
  2419. amiga_set_arch_mach (abfd, arch, machine)
  2420.      bfd *abfd;
  2421.      enum bfd_architecture arch;
  2422.      unsigned long machine;
  2423. {
  2424.   bfd_default_set_arch_mach(abfd, arch, machine);
  2425.  
  2426.   if (arch == bfd_arch_m68k)
  2427.     {
  2428.       switch (machine)
  2429.     {
  2430.     case 68000:
  2431.     case 68008:
  2432.     case 68010:
  2433.     case 68020:
  2434.     case 68030:
  2435.     case 68040:
  2436.     case 68070:
  2437.     case 0:
  2438.       return true;
  2439.     default:
  2440.       return false;
  2441.     }
  2442.     }
  2443.   return false;
  2444. }
  2445.  
  2446. static int
  2447. DEFUN(amiga_sizeof_headers,(ignore_abfd, ignore),
  2448.       bfd *ignore_abfd AND
  2449.       boolean ignore)
  2450. {
  2451.   /* The amiga hunk format doesn't have headers.*/
  2452.   return 0;
  2453. }
  2454.  
  2455. /* Provided a BFD, a section and an offset into the section, calculate
  2456.    and return the name of the source file and the line nearest to the
  2457.    wanted location.  */
  2458. boolean
  2459. amiga_find_nearest_line(abfd, section, symbols, offset, filename_ptr,
  2460.             functionname_ptr, line_ptr)
  2461.      bfd *abfd;
  2462.      asection *section;
  2463.      asymbol **symbols;
  2464.      bfd_vma offset;
  2465.      char **filename_ptr;
  2466.      char **functionname_ptr;
  2467.      int *line_ptr;
  2468. {
  2469.   /* FIXME (see aoutx.h, for example) */
  2470.   return false;
  2471. }
  2472.  
  2473. static const struct reloc_howto_struct *
  2474. amiga_bfd_reloc_type_lookup (abfd, code)
  2475.        bfd *abfd;
  2476.        bfd_reloc_code_real_type code;
  2477. {
  2478.   switch (code)
  2479.     {
  2480.     case BFD_RELOC_8_PCREL:  return &howto_hunk_reloc8;
  2481.     case BFD_RELOC_16_PCREL: return &howto_hunk_reloc16;
  2482.     case BFD_RELOC_32_PCREL: return &howto_hunk_reloc32;
  2483.     case BFD_RELOC_8:        return &howto_hunk_drel8;
  2484.     case BFD_RELOC_16:       return &howto_hunk_drel16;
  2485.     case BFD_RELOC_CTOR:    /* FIXME - assumes 32 bits */
  2486.     case BFD_RELOC_32:       return &howto_hunk_drel32;
  2487.       /* FIXME: Add more cases here for base relative relocs*/
  2488.     default:                 return 0;
  2489.     }
  2490. }
  2491.  
  2492.  
  2493. /* We don't have core files.  */
  2494. #define    amiga_core_file_failing_command _bfd_dummy_core_file_failing_command
  2495. #define    amiga_core_file_failing_signal _bfd_dummy_core_file_failing_signal
  2496. #define    amiga_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
  2497.  
  2498. /* 101194: We do not use archive files, AMIGA Hunk load libs will be supported someday... ST */
  2499. #define    amiga_openr_next_archived_file    (bfd * (*)(bfd *, bfd*))bfd_nullvoidptr
  2500. #define    amiga_generic_stat_arch_elt    (int (*)(bfd *, struct stat *))_bfd_n1
  2501. #define    amiga_slurp_armap        (boolean (*)(bfd *))bfd_false
  2502. #define    amiga_slurp_extended_name_table    (boolean (*)(bfd *))bfd_false
  2503. #define amiga_update_armap_timestamp    (boolean (*)(bfd *))bfd_false
  2504. #define    amiga_write_armap        (boolean (*)(bfd *,unsigned int, struct orl*,\
  2505. unsigned int,int))bfd_false
  2506. #define    amiga_truncate_arname        (void (*)(bfd *,const char *, char*))bfd_void
  2507. #define amiga_construct_extended_name_table (boolean (*)(bfd *,char **, bfd_size_type *,\
  2508.  const char **))bfd_false
  2509.  
  2510. #define amiga_bfd_debug_info_start        bfd_void
  2511. #define amiga_bfd_debug_info_end        bfd_void
  2512. #define amiga_bfd_debug_info_accumulate    (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
  2513.  
  2514. /* NOTE: We use a special get_relocated_section_contents both in amiga AND in a.out files.
  2515.    In addition, we use an own final_link routine, which is nearly identical to _bfd_generic_final_link */
  2516. extern bfd_byte *get_relocated_section_contents(bfd*, struct bfd_link_info *,
  2517.                         struct bfd_link_order *, bfd_byte *,
  2518.                         boolean, asymbol **);
  2519. #define amiga_bfd_get_relocated_section_contents get_relocated_section_contents
  2520. #define amiga_bfd_relax_section                   bfd_generic_relax_section
  2521. #define amiga_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
  2522. #define amiga_close_and_cleanup         _bfd_generic_close_and_cleanup
  2523. #define amiga_bfd_make_debug_symbol \
  2524.   (asymbol * (*)(bfd *, void *, unsigned long)) bfd_nullvoidptr
  2525. #define amiga_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
  2526. #define amiga_bfd_link_add_symbols _bfd_generic_link_add_symbols
  2527. extern boolean amiga_final_link(bfd *, struct bfd_link_info *);
  2528. #define amiga_bfd_final_link amiga_final_link
  2529. #define amiga_bfd_free_cached_info    _bfd_generic_bfd_free_cached_info
  2530. #define amiga_bfd_is_local_label    bfd_generic_is_local_label
  2531. #define amiga_bfd_copy_private_section_data (boolean (*)(bfd *,sec_ptr,bfd *,sec_ptr))bfd_true
  2532. #define amiga_bfd_copy_private_bfd_data (boolean (*)(bfd *,bfd *))bfd_true
  2533.  
  2534. #if defined (amiga)
  2535. /* So that the JUMP_TABLE() macro below can work.  */
  2536. #undef amiga
  2537. #endif
  2538.  
  2539. bfd_target amiga_vec =
  2540. {
  2541.   "amiga",        /* name */
  2542.   bfd_target_amiga_flavour,
  2543.   true,            /* data byte order is little */
  2544.   true,            /* header byte order is little */
  2545.   HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS | WP_TEXT, /* object flags */
  2546.   SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC, /* section flags */
  2547.   '_',                /* symbol leading char */
  2548.   ' ',                /* ar_pad_char */
  2549.   31,                /* ar_max_namelen */
  2550.   2,                /* minimum align */
  2551.   bfd_getb64, bfd_getb_signed_64, bfd_putb64, bfd_getb32, bfd_getb_signed_32,
  2552.   bfd_putb32, bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
  2553.   bfd_getb64, bfd_getb_signed_64, bfd_putb64, bfd_getb32, bfd_getb_signed_32,
  2554.   bfd_putb32, bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
  2555.   {
  2556.     /* bfd_check_format */
  2557.     _bfd_dummy_target,
  2558.     amiga_object_p,
  2559.     _bfd_dummy_target, /* AMIGA style like archives are not yet supported
  2560.               archives are supported by a.out backend (ar) */
  2561.     _bfd_dummy_target
  2562.   },
  2563.   {
  2564.     /* bfd_set_format */
  2565.     bfd_false,
  2566.     amiga_mkobject,
  2567.     bfd_false,    /* Archives not supported yet */
  2568.     bfd_false
  2569.   },
  2570.   {
  2571.     /* bfd_write_contents */
  2572.     bfd_false,
  2573.     amiga_write_object_contents,
  2574.     bfd_false,    /*Archives not supported yet */
  2575.     bfd_false
  2576.   },
  2577.   BFD_JUMP_TABLE_GENERIC (amiga),
  2578.   BFD_JUMP_TABLE_COPY (amiga),
  2579.   BFD_JUMP_TABLE_CORE (_bfd_nocore),
  2580.   BFD_JUMP_TABLE_ARCHIVE (amiga),
  2581.   BFD_JUMP_TABLE_SYMBOLS (amiga),
  2582.   BFD_JUMP_TABLE_RELOCS (amiga),
  2583.   BFD_JUMP_TABLE_WRITE (amiga),
  2584.   BFD_JUMP_TABLE_LINK (amiga),
  2585.   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
  2586.   (PTR) 0
  2587. #if 0
  2588. /* fixme: no longer in use?  */
  2589.   /* How applications can find out about amiga relocation types (see
  2590.      documentation on reloc types).  */
  2591.   amiga_reloc_type_lookup
  2592. #endif
  2593. };
  2594.  
  2595.