1 /* BFD backend for hp-ux 9000/300
2    Copyright (C) 1990-2016 Free Software Foundation, Inc.
3    Written by Glenn Engel.
4 
5    This file is part of BFD, the Binary File Descriptor library.
6 
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11 
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16 
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21 
22 
23 /*  hpux native  ------------> |               |
24                                | hp300hpux bfd | ----------> hpux w/gnu ext
25     hpux w/gnu extension ----> |               |
26 
27     Support for the 9000/[34]00 has several limitations.
28       1. Shared libraries are not supported.
29       2. The output format from this bfd is not usable by native tools.
30 
31     The primary motivation for writing this bfd was to allow use of
32     gdb and gcc for host based debugging and not to mimic the hp-ux tools
33     in every detail.  This leads to a significant simplification of the
34     code and a leap in performance.  The decision to not output hp native
35     compatible objects was further strengthened by the fact that the richness
36     of the gcc compiled objects could not be represented without loss of
37     information.  For example, while the hp format supports the concept of
38     secondary symbols, it does not support indirect symbols.  Another
39     reason is to maintain backwards compatibility with older implementations
40     of gcc on hpux which used 'hpxt' to translate .a and .o files into a
41     format which could be readily understood by the gnu linker and gdb.
42     This allows reading hp secondary symbols and converting them into
43     indirect symbols but the reverse it not always possible.
44 
45     Another example of differences is that the hp format stores symbol offsets
46     in the object code while the gnu utilities use a field in the
47     relocation record for this.  To support the hp native format, the object
48     code would need to be patched with the offsets when producing .o files.
49 
50     The basic technique taken in this implementation is to #include the code
51     from aoutx.h and aout-target.h with appropriate #defines to override
52     code where a unique implementation is needed:
53 
54     {
55         #define a bunch of stuff
56         #include <aoutx.h>
57 
58         implement a bunch of functions
59 
60         #include "aout-target.h"
61     }
62 
63     The hp symbol table is a bit different than other a.out targets.  Instead
64     of having an array of nlist items and an array of strings, hp's format
65     has them mixed together in one structure.  In addition, the strings are
66     not null terminated.  It looks something like this:
67 
68     nlist element 1
69     string1
70     nlist element 2
71     string2
72     ...
73 
74     The whole symbol table is read as one chunk and then we march thru it
75     and convert it to canonical form.  As we march thru the table, we copy
76     the nlist data into the internal form and we compact the strings and null
77     terminate them, using storage from the already allocated symbol table:
78 
79     string1
80     null
81     string2
82     null
83  */
84 
85 /* @@ Is this really so different from normal a.out that it needs to include
86    aoutx.h?  We should go through this file sometime and see what can be made
87    more dependent on aout32.o and what might need to be broken off and accessed
88    through the backend_data field.  Or, maybe we really do need such a
89    completely separate implementation.  I don't have time to investigate this
90    much further right now.  [raeburn:19930428.2124EST] */
91 /* @@ Also, note that there wind up being two versions of some routines, with
92    different names, only one of which actually gets used.  For example:
93 	slurp_symbol_table
94 	swap_std_reloc_in
95 	slurp_reloc_table
96 	canonicalize_symtab
97 	get_symtab_upper_bound
98 	canonicalize_reloc
99 	mkobject
100    This should also be fixed.  */
101 
102 #define TARGETNAME "a.out-hp300hpux"
103 
104 /* Do not "beautify" the CONCAT* macro args.  Traditional C will not
105    remove whitespace added here, and thus will fail to concatenate
106    the tokens.  */
107 #define MY(OP) CONCAT2 (m68k_aout_hp300hpux_,OP)
108 
109 #define external_exec hp300hpux_exec_bytes
110 #define external_nlist hp300hpux_nlist_bytes
111 
112 #include "aout/hp300hpux.h"
113 
114 /* define these so we can compile unused routines in aoutx.h */
115 #define e_strx  e_shlib
116 #define e_other e_length
117 #define e_desc  e_almod
118 
119 #define AR_PAD_CHAR '/'
120 #define TARGET_IS_BIG_ENDIAN_P
121 #define DEFAULT_ARCH bfd_arch_m68k
122 
123 #define MY_get_section_contents aout_32_get_section_contents
124 #define MY_slurp_armap bfd_slurp_bsd_armap_f2
125 
126 /***********************************************/
127 /* provide overrides for routines in this file */
128 /***********************************************/
129 /* these don't use MY because that causes problems within JUMP_TABLE
130    (CONCAT2 winds up being expanded recursively, which ANSI C compilers
131    will not do).  */
132 #define MY_canonicalize_symtab m68k_aout_hp300hpux_canonicalize_symtab
133 #define MY_get_symtab_upper_bound m68k_aout_hp300hpux_get_symtab_upper_bound
134 #define MY_canonicalize_reloc m68k_aout_hp300hpux_canonicalize_reloc
135 #define MY_write_object_contents m68k_aout_hp300hpux_write_object_contents
136 
137 #define MY_read_minisymbols _bfd_generic_read_minisymbols
138 #define MY_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
139 
140 #define MY_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
141 #define MY_bfd_link_add_symbols _bfd_generic_link_add_symbols
142 #define MY_final_link_callback unused
143 #define MY_bfd_final_link _bfd_generic_final_link
144 
145 /* Until and unless we convert the slurp_reloc and slurp_symtab
146    routines in this file, we can not use the default aout
147    free_cached_info routine which assumes that the relocs and symtabs
148    were allocated using malloc.  */
149 #define MY_bfd_free_cached_info bfd_true
150 
151 #define m68k_aout_hp300hpux_write_syms aout_32_write_syms
152 
153 #define MY_callback MY(callback)
154 
155 #define MY_exec_hdr_flags 0x2
156 
157 #define NAME_swap_exec_header_in NAME(hp300hpux_32_,swap_exec_header_in)
158 
159 #define HP_SYMTYPE_UNDEFINED	0x00
160 #define HP_SYMTYPE_ABSOLUTE	0x01
161 #define HP_SYMTYPE_TEXT		0x02
162 #define HP_SYMTYPE_DATA		0x03
163 #define HP_SYMTYPE_BSS		0x04
164 #define HP_SYMTYPE_COMMON	0x05
165 
166 #define HP_SYMTYPE_TYPE		0x0F
167 #define HP_SYMTYPE_FILENAME	0x1F
168 
169 #define HP_SYMTYPE_ALIGN	0x10
170 #define HP_SYMTYPE_EXTERNAL	0x20
171 #define HP_SECONDARY_SYMBOL     0x40
172 
173 /* RELOCATION DEFINITIONS */
174 #define HP_RSEGMENT_TEXT	0x00
175 #define HP_RSEGMENT_DATA	0x01
176 #define HP_RSEGMENT_BSS		0x02
177 #define HP_RSEGMENT_EXTERNAL	0x03
178 #define HP_RSEGMENT_PCREL       0x04
179 #define HP_RSEGMENT_RDLT        0x05
180 #define HP_RSEGMENT_RPLT        0x06
181 #define HP_RSEGMENT_NOOP	0x3F
182 
183 #define HP_RLENGTH_BYTE		0x00
184 #define HP_RLENGTH_WORD		0x01
185 #define HP_RLENGTH_LONG		0x02
186 #define HP_RLENGTH_ALIGN	0x03
187 
188 #define NAME(x,y) CONCAT3 (hp300hpux,_32_,y)
189 #define ARCH_SIZE 32
190 
191 /* aoutx.h requires definitions for BMAGIC and QMAGIC.  */
192 #define BMAGIC HPUX_DOT_O_MAGIC
193 #define QMAGIC 0314
194 
195 #include "aoutx.h"
196 
197 static const bfd_target * MY (callback) (bfd *);
198 static bfd_boolean MY (write_object_contents) (bfd *);
199 static void convert_sym_type
200   (struct external_nlist *, aout_symbol_type *, bfd *);
201 
202 bfd_boolean MY (slurp_symbol_table) (bfd *);
203 void MY (swap_std_reloc_in)
204   (bfd *, struct hp300hpux_reloc *, arelent *, asymbol **, bfd_size_type);
205 bfd_boolean MY (slurp_reloc_table)
206   (bfd *, sec_ptr, asymbol **);
207 long MY (canonicalize_symtab)  (bfd *, asymbol **);
208 long MY (get_symtab_upper_bound)  (bfd *);
209 long MY (canonicalize_reloc)  (bfd *, sec_ptr, arelent **, asymbol **);
210 
211 /* Since the hpux symbol table has nlist elements interspersed with
212    strings and we need to insert som strings for secondary symbols, we
213    give ourselves a little extra padding up front to account for
214    this.  Note that for each non-secondary symbol we process, we gain
215    9 bytes of space for the discarded nlist element (one byte used for
216    null).  SYM_EXTRA_BYTES is the extra space.  */
217 #define SYM_EXTRA_BYTES   1024
218 
219 /* Set parameters about this a.out file that are machine-dependent.
220    This routine is called from some_aout_object_p just before it returns.  */
221 static const bfd_target *
MY(callback)222 MY (callback) (bfd *abfd)
223 {
224   struct internal_exec *execp = exec_hdr (abfd);
225 
226   /* Calculate the file positions of the parts of a newly read aout header */
227   obj_textsec (abfd)->size = N_TXTSIZE (execp);
228 
229   /* The virtual memory addresses of the sections */
230   obj_textsec (abfd)->vma = N_TXTADDR (execp);
231   obj_datasec (abfd)->vma = N_DATADDR (execp);
232   obj_bsssec (abfd)->vma = N_BSSADDR (execp);
233 
234   obj_textsec (abfd)->lma = obj_textsec (abfd)->vma;
235   obj_datasec (abfd)->lma = obj_datasec (abfd)->vma;
236   obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma;
237 
238   /* The file offsets of the sections */
239   obj_textsec (abfd)->filepos = N_TXTOFF (execp);
240   obj_datasec (abfd)->filepos = N_DATOFF (execp);
241 
242   /* The file offsets of the relocation info */
243   obj_textsec (abfd)->rel_filepos = N_TRELOFF (execp);
244   obj_datasec (abfd)->rel_filepos = N_DRELOFF (execp);
245 
246   /* The file offsets of the string table and symbol table.  */
247   obj_sym_filepos (abfd) = N_SYMOFF (execp);
248   obj_str_filepos (abfd) = N_STROFF (execp);
249 
250   /* Determine the architecture and machine type of the object file.  */
251 #ifdef SET_ARCH_MACH
252   SET_ARCH_MACH (abfd, execp);
253 #else
254   bfd_default_set_arch_mach (abfd, DEFAULT_ARCH, 0);
255 #endif
256 
257   if (obj_aout_subformat (abfd) == gnu_encap_format)
258     {
259       /* The file offsets of the relocation info */
260       obj_textsec (abfd)->rel_filepos = N_GNU_TRELOFF (execp);
261       obj_datasec (abfd)->rel_filepos = N_GNU_DRELOFF (execp);
262 
263       /* The file offsets of the string table and symbol table.  */
264       obj_sym_filepos (abfd) = N_GNU_SYMOFF (execp);
265       obj_str_filepos (abfd) = (obj_sym_filepos (abfd) + execp->a_syms);
266 
267       abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
268       bfd_get_symcount (abfd) = execp->a_syms / 12;
269       obj_symbol_entry_size (abfd) = 12;
270       obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
271     }
272 
273   return abfd->xvec;
274 }
275 
276 extern bfd_boolean aout_32_write_syms (bfd *);
277 
278 static bfd_boolean
MY(write_object_contents)279 MY (write_object_contents) (bfd * abfd)
280 {
281   struct external_exec exec_bytes;
282   struct internal_exec *execp = exec_hdr (abfd);
283 
284   memset (&exec_bytes, 0, sizeof (exec_bytes));
285 
286   obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
287 
288   if (adata (abfd).magic == undecided_magic)
289     NAME (aout,adjust_sizes_and_vmas) (abfd);
290   execp->a_syms = 0;
291 
292   execp->a_entry = bfd_get_start_address (abfd);
293 
294   execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *
295 		     obj_reloc_entry_size (abfd));
296   execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *
297 		     obj_reloc_entry_size (abfd));
298 
299   N_SET_MACHTYPE (execp, 0xc);
300   N_SET_FLAGS (execp, aout_backend_info (abfd)->exec_hdr_flags);
301 
302   NAME (aout,swap_exec_header_out) (abfd, execp, &exec_bytes);
303 
304   /* update fields not covered by default swap_exec_header_out */
305 
306   /* this is really the sym table size but we store it in drelocs */
307   H_PUT_32 (abfd, (bfd_get_symcount (abfd) * 12), exec_bytes.e_drelocs);
308 
309   if (bfd_seek (abfd, (file_ptr) 0, FALSE) != 0
310       || (bfd_bwrite (&exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
311 	  != EXEC_BYTES_SIZE))
312     return FALSE;
313 
314   /* Write out the symbols, and then the relocs.  We must write out
315        the symbols first so that we know the symbol indices.  */
316 
317   if (bfd_get_symcount (abfd) != 0)
318     {
319       /* Skip the relocs to where we want to put the symbols.  */
320       if (bfd_seek (abfd, (file_ptr) (N_DRELOFF (execp) + execp->a_drsize),
321 		    SEEK_SET) != 0)
322 	return FALSE;
323     }
324 
325   if (!MY (write_syms) (abfd))
326     return FALSE;
327 
328   if (bfd_get_symcount (abfd) != 0)
329     {
330       if (bfd_seek (abfd, (file_ptr) N_TRELOFF (execp), SEEK_CUR) != 0)
331 	return FALSE;
332       if (!NAME (aout,squirt_out_relocs) (abfd, obj_textsec (abfd)))
333 	return FALSE;
334       if (bfd_seek (abfd, (file_ptr) N_DRELOFF (execp), SEEK_CUR) != 0)
335 	return FALSE;
336       if (!NAME (aout,squirt_out_relocs) (abfd, obj_datasec (abfd)))
337 	return FALSE;
338     }
339 
340   return TRUE;
341 }
342 
343 /* Convert the hp symbol type to be the same as aout64.h usage so we
344    can piggyback routines in aoutx.h.  */
345 
346 static void
convert_sym_type(struct external_nlist * sym_pointer ATTRIBUTE_UNUSED,aout_symbol_type * cache_ptr,bfd * abfd ATTRIBUTE_UNUSED)347 convert_sym_type (struct external_nlist *sym_pointer ATTRIBUTE_UNUSED,
348 		  aout_symbol_type *cache_ptr,
349 		  bfd *abfd ATTRIBUTE_UNUSED)
350 {
351   int name_type;
352   int new_type;
353 
354   name_type = (cache_ptr->type);
355   new_type = 0;
356 
357   if ((name_type & HP_SYMTYPE_ALIGN) != 0)
358     {
359       /* iou_error ("aligned symbol encountered: %s", name);*/
360       name_type = 0;
361     }
362 
363   if (name_type == HP_SYMTYPE_FILENAME)
364     new_type = N_FN;
365   else
366     {
367       switch (name_type & HP_SYMTYPE_TYPE)
368 	{
369 	case HP_SYMTYPE_UNDEFINED:
370 	  new_type = N_UNDF;
371 	  break;
372 
373 	case HP_SYMTYPE_ABSOLUTE:
374 	  new_type = N_ABS;
375 	  break;
376 
377 	case HP_SYMTYPE_TEXT:
378 	  new_type = N_TEXT;
379 	  break;
380 
381 	case HP_SYMTYPE_DATA:
382 	  new_type = N_DATA;
383 	  break;
384 
385 	case HP_SYMTYPE_BSS:
386 	  new_type = N_BSS;
387 	  break;
388 
389 	case HP_SYMTYPE_COMMON:
390 	  new_type = N_COMM;
391 	  break;
392 
393 	default:
394 	  abort ();
395 	  break;
396 	}
397       if (name_type & HP_SYMTYPE_EXTERNAL)
398 	new_type |= N_EXT;
399 
400       if (name_type & HP_SECONDARY_SYMBOL)
401 	{
402 	  switch (new_type)
403 	    {
404 	    default:
405 	      abort ();
406 	    case N_UNDF | N_EXT:
407 	      /* If the value is nonzero, then just treat this as a
408                  common symbol.  I don't know if this is correct in
409                  all cases, but it is more correct than treating it as
410                  a weak undefined symbol.  */
411 	      if (cache_ptr->symbol.value == 0)
412 		new_type = N_WEAKU;
413 	      break;
414 	    case N_ABS | N_EXT:
415 	      new_type = N_WEAKA;
416 	      break;
417 	    case N_TEXT | N_EXT:
418 	      new_type = N_WEAKT;
419 	      break;
420 	    case N_DATA | N_EXT:
421 	      new_type = N_WEAKD;
422 	      break;
423 	    case N_BSS | N_EXT:
424 	      new_type = N_WEAKB;
425 	      break;
426 	    }
427 	}
428     }
429   cache_ptr->type = new_type;
430 
431 }
432 
433 /*
434 DESCRIPTION
435         Swaps the information in an executable header taken from a raw
436         byte stream memory image, into the internal exec_header
437         structure.
438 */
439 
440 void
NAME(aout,swap_exec_header_in)441 NAME (aout,swap_exec_header_in) (bfd *abfd,
442 				 struct external_exec *raw_bytes,
443 				 struct internal_exec *execp)
444 {
445   struct external_exec *bytes = (struct external_exec *) raw_bytes;
446 
447   /* The internal_exec structure has some fields that are unused in this
448      configuration (IE for i960), so ensure that all such uninitialized
449      fields are zero'd out.  There are places where two of these structs
450      are memcmp'd, and thus the contents do matter. */
451   memset (execp, 0, sizeof (struct internal_exec));
452   /* Now fill in fields in the execp, from the bytes in the raw data.  */
453   execp->a_info = H_GET_32 (abfd, bytes->e_info);
454   execp->a_text = GET_WORD (abfd, bytes->e_text);
455   execp->a_data = GET_WORD (abfd, bytes->e_data);
456   execp->a_bss = GET_WORD (abfd, bytes->e_bss);
457   execp->a_syms = GET_WORD (abfd, bytes->e_syms);
458   execp->a_entry = GET_WORD (abfd, bytes->e_entry);
459   execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
460   execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
461 
462   /***************************************************************/
463   /* check the header to see if it was generated by a bfd output */
464   /* this is detected rather bizarrely by requiring a bunch of   */
465   /* header fields to be zero and an old unused field (now used) */
466   /* to be set.                                                  */
467   /***************************************************************/
468   do
469     {
470       long syms;
471       struct aout_data_struct *rawptr;
472       bfd_size_type amt;
473 
474       if (H_GET_32 (abfd, bytes->e_passize) != 0)
475 	break;
476       if (H_GET_32 (abfd, bytes->e_syms) != 0)
477 	break;
478       if (H_GET_32 (abfd, bytes->e_supsize) != 0)
479 	break;
480 
481       syms = H_GET_32 (abfd, bytes->e_drelocs);
482       if (syms == 0)
483 	break;
484 
485       /* OK, we've passed the test as best as we can determine */
486       execp->a_syms = syms;
487 
488       /* allocate storage for where we will store this result */
489       amt = sizeof (*rawptr);
490       rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
491 
492       if (rawptr == NULL)
493 	return;
494       abfd->tdata.aout_data = rawptr;
495       obj_aout_subformat (abfd) = gnu_encap_format;
496     }
497   while (0);
498 }
499 
500 /* The hp symbol table is a bit different than other a.out targets.  Instead
501    of having an array of nlist items and an array of strings, hp's format
502    has them mixed together in one structure.  In addition, the strings are
503    not null terminated.  It looks something like this:
504 
505    nlist element 1
506    string1
507    nlist element 2
508    string2
509    ...
510 
511    The whole symbol table is read as one chunk and then we march thru it
512    and convert it to canonical form.  As we march thru the table, we copy
513    the nlist data into the internal form and we compact the strings and null
514    terminate them, using storage from the already allocated symbol table:
515 
516    string1
517    null
518    string2
519    null
520    ...
521 */
522 
523 bfd_boolean
MY(slurp_symbol_table)524 MY (slurp_symbol_table) (bfd *abfd)
525 {
526   bfd_size_type symbol_bytes;
527   struct external_nlist *syms;
528   struct external_nlist *sym_pointer;
529   struct external_nlist *sym_end;
530   char *strings;
531   aout_symbol_type *cached;
532   unsigned num_syms = 0;
533   bfd_size_type amt;
534 
535   /* If there's no work to be done, don't do any */
536   if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
537     return TRUE;
538   symbol_bytes = exec_hdr (abfd)->a_syms;
539 
540   amt = symbol_bytes + SYM_EXTRA_BYTES;
541   strings = (char *) bfd_alloc (abfd, amt);
542   if (!strings)
543     return FALSE;
544   syms = (struct external_nlist *) (strings + SYM_EXTRA_BYTES);
545   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
546       || bfd_bread (syms, symbol_bytes, abfd) != symbol_bytes)
547     {
548       bfd_release (abfd, syms);
549       return FALSE;
550     }
551 
552   sym_end = (struct external_nlist *) (((char *) syms) + symbol_bytes);
553 
554   /* first, march thru the table and figure out how many symbols there are */
555   for (sym_pointer = syms; sym_pointer < sym_end; sym_pointer++, num_syms++)
556     {
557       /* skip over the embedded symbol. */
558       sym_pointer = (struct external_nlist *) (((char *) sym_pointer) +
559 					       sym_pointer->e_length[0]);
560     }
561 
562   /* now that we know the symbol count, update the bfd header */
563   bfd_get_symcount (abfd) = num_syms;
564 
565   amt = num_syms;
566   amt *= sizeof (aout_symbol_type);
567   cached = (aout_symbol_type *) bfd_zalloc (abfd, amt);
568   if (cached == NULL && num_syms != 0)
569     return FALSE;
570 
571   /* as we march thru the hp symbol table, convert it into a list of
572      null terminated strings to hold the symbol names.  Make sure any
573      assignment to the strings pointer is done after we're thru using
574      the nlist so we don't overwrite anything important. */
575 
576   /* OK, now walk the new symtable, caching symbol properties */
577   {
578     aout_symbol_type *cache_ptr = cached;
579     /* Run through table and copy values */
580     for (sym_pointer = syms, cache_ptr = cached;
581 	 sym_pointer < sym_end; sym_pointer++, cache_ptr++)
582       {
583 	unsigned int length;
584 	cache_ptr->symbol.the_bfd = abfd;
585 	cache_ptr->symbol.value = GET_SWORD (abfd, sym_pointer->e_value);
586 	cache_ptr->desc = bfd_get_16 (abfd, sym_pointer->e_almod);
587 	cache_ptr->type = bfd_get_8 (abfd, sym_pointer->e_type);
588 	cache_ptr->symbol.udata.p = NULL;
589 	length = bfd_get_8 (abfd, sym_pointer->e_length);
590 	cache_ptr->other = length;	/* other not used, save length here */
591 
592 	convert_sym_type (sym_pointer, cache_ptr, abfd);
593 	if (!translate_from_native_sym_flags (abfd, cache_ptr))
594 	  return FALSE;
595 
596 	/********************************************************/
597 	/* for hpux, the 'length' value indicates the length of */
598 	/* the symbol name which follows the nlist entry.       */
599 	/********************************************************/
600 	if (length)
601 	  {
602 	    /**************************************************************/
603 	    /* the hp string is not null terminated so we create a new one*/
604 	    /* by copying the string to overlap the just vacated nlist    */
605 	    /* structure before it in memory.                             */
606 	    /**************************************************************/
607 	    cache_ptr->symbol.name = strings;
608 	    memcpy (strings, sym_pointer + 1, length);
609 	    strings[length] = '\0';
610 	    strings += length + 1;
611 	  }
612 	else
613 	  cache_ptr->symbol.name = (char *) NULL;
614 
615 	/* skip over the embedded symbol. */
616 	sym_pointer = (struct external_nlist *) (((char *) sym_pointer) +
617 						 length);
618       }
619   }
620 
621   obj_aout_symbols (abfd) = cached;
622 
623   return TRUE;
624 }
625 
626 void
MY(swap_std_reloc_in)627 MY (swap_std_reloc_in) (bfd *abfd,
628 			struct hp300hpux_reloc *bytes,
629 			arelent *cache_ptr,
630 			asymbol **symbols,
631 			bfd_size_type symcount ATTRIBUTE_UNUSED)
632 {
633   int r_index;
634   int r_extern = 0;
635   unsigned int r_length;
636   int r_pcrel = 0;
637   struct aoutdata *su = &(abfd->tdata.aout_data->a);
638 
639   cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
640   r_index = H_GET_16 (abfd, bytes->r_index);
641 
642   switch (bytes->r_type[0])
643     {
644     case HP_RSEGMENT_TEXT:
645       r_index = N_TEXT;
646       break;
647     case HP_RSEGMENT_DATA:
648       r_index = N_DATA;
649       break;
650     case HP_RSEGMENT_BSS:
651       r_index = N_BSS;
652       break;
653     case HP_RSEGMENT_EXTERNAL:
654       r_extern = 1;
655       break;
656     case HP_RSEGMENT_PCREL:
657       r_extern = 1;
658       r_pcrel = 1;
659       break;
660     case HP_RSEGMENT_RDLT:
661       break;
662     case HP_RSEGMENT_RPLT:
663       break;
664     case HP_RSEGMENT_NOOP:
665       break;
666     default:
667       abort ();
668       break;
669     }
670 
671   switch (bytes->r_length[0])
672     {
673     case HP_RLENGTH_BYTE:
674       r_length = 0;
675       break;
676     case HP_RLENGTH_WORD:
677       r_length = 1;
678       break;
679     case HP_RLENGTH_LONG:
680       r_length = 2;
681       break;
682     default:
683       abort ();
684       break;
685     }
686 
687   cache_ptr->howto = howto_table_std + r_length + 4 * r_pcrel;
688   /* FIXME-soon:  Roll baserel, jmptable, relative bits into howto setting */
689 
690   /* This macro uses the r_index value computed above */
691   if (r_pcrel && r_extern)
692     {
693       /* The GNU linker assumes any offset from beginning of section */
694       /* is already incorporated into the image while the HP linker  */
695       /* adds this in later.  Add it in now...                       */
696       MOVE_ADDRESS (-cache_ptr->address);
697     }
698   else
699     {
700       MOVE_ADDRESS (0);
701     }
702 }
703 
704 bfd_boolean
MY(slurp_reloc_table)705 MY (slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
706 {
707   bfd_size_type count;
708   bfd_size_type reloc_size;
709   void * relocs;
710   arelent *reloc_cache;
711   size_t each_size;
712   struct hp300hpux_reloc *rptr;
713   unsigned int counter;
714   arelent *cache_ptr;
715 
716   if (asect->relocation)
717     return TRUE;
718 
719   if (asect->flags & SEC_CONSTRUCTOR)
720     return TRUE;
721 
722   if (asect == obj_datasec (abfd))
723     {
724       reloc_size = exec_hdr (abfd)->a_drsize;
725       goto doit;
726     }
727 
728   if (asect == obj_textsec (abfd))
729     {
730       reloc_size = exec_hdr (abfd)->a_trsize;
731       goto doit;
732     }
733 
734   bfd_set_error (bfd_error_invalid_operation);
735   return FALSE;
736 
737 doit:
738   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
739     return FALSE;
740   each_size = obj_reloc_entry_size (abfd);
741 
742   count = reloc_size / each_size;
743 
744   reloc_cache = (arelent *) bfd_zalloc (abfd, count * sizeof (arelent));
745   if (!reloc_cache && count != 0)
746     return FALSE;
747 
748   relocs = bfd_alloc (abfd, reloc_size);
749   if (!relocs && reloc_size != 0)
750     {
751       bfd_release (abfd, reloc_cache);
752       return FALSE;
753     }
754 
755   if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
756     {
757       bfd_release (abfd, relocs);
758       bfd_release (abfd, reloc_cache);
759       return FALSE;
760     }
761 
762   rptr = (struct hp300hpux_reloc *) relocs;
763   counter = 0;
764   cache_ptr = reloc_cache;
765 
766   for (; counter < count; counter++, rptr++, cache_ptr++)
767     {
768       MY (swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols,
769 			      (bfd_size_type) bfd_get_symcount (abfd));
770     }
771 
772   bfd_release (abfd, relocs);
773   asect->relocation = reloc_cache;
774   asect->reloc_count = count;
775   return TRUE;
776 }
777 
778 /************************************************************************/
779 /* The following functions are identical to functions in aoutx.h except */
780 /* they refer to MY(func) rather than NAME(aout,func) and they also     */
781 /* call aout_32 versions if the input file was generated by gcc         */
782 /************************************************************************/
783 
784 long aout_32_canonicalize_symtab  (bfd *, asymbol **);
785 long aout_32_get_symtab_upper_bound  (bfd *);
786 long aout_32_canonicalize_reloc  (bfd *, sec_ptr, arelent **, asymbol **);
787 
788 long
MY(canonicalize_symtab)789 MY (canonicalize_symtab) (bfd *abfd, asymbol **location)
790 {
791   unsigned int counter = 0;
792   aout_symbol_type *symbase;
793 
794   if (obj_aout_subformat (abfd) == gnu_encap_format)
795     return aout_32_canonicalize_symtab (abfd, location);
796 
797   if (!MY (slurp_symbol_table) (abfd))
798     return -1;
799 
800   for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
801     *(location++) = (asymbol *) (symbase++);
802   *location++ = 0;
803   return bfd_get_symcount (abfd);
804 }
805 
806 long
MY(get_symtab_upper_bound)807 MY (get_symtab_upper_bound) (bfd *abfd)
808 {
809   if (obj_aout_subformat (abfd) == gnu_encap_format)
810     return aout_32_get_symtab_upper_bound (abfd);
811   if (!MY (slurp_symbol_table) (abfd))
812     return -1;
813 
814   return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
815 }
816 
817 long
MY(canonicalize_reloc)818 MY (canonicalize_reloc) (bfd *abfd,
819 			 sec_ptr section,
820 			 arelent **relptr,
821 			 asymbol **symbols)
822 {
823   arelent *tblptr = section->relocation;
824   unsigned int count;
825 
826   if (obj_aout_subformat (abfd) == gnu_encap_format)
827     return aout_32_canonicalize_reloc (abfd, section, relptr, symbols);
828 
829   if (!(tblptr || MY (slurp_reloc_table) (abfd, section, symbols)))
830     return -1;
831 
832   if (section->flags & SEC_CONSTRUCTOR)
833     {
834       arelent_chain *chain = section->constructor_chain;
835       for (count = 0; count < section->reloc_count; count++)
836 	{
837 	  *relptr++ = &chain->relent;
838 	  chain = chain->next;
839 	}
840     }
841   else
842     {
843       tblptr = section->relocation;
844 
845       for (count = 0; count++ < section->reloc_count;)
846 	{
847 	  *relptr++ = tblptr++;
848 	}
849     }
850   *relptr = 0;
851 
852   return section->reloc_count;
853 }
854 
855 #include "aout-target.h"
856