projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2000-02-25 H.J. Lu <hjl@gnu.org>
[deliverable/binutils-gdb.git] / bfd / som.c
CommitLineData
252b5132
RH		 1/* bfd back-end for HP PA-RISC SOM objects.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
4
5 Contributed by the Center for Software Science at the
6 University of Utah (pa-gdb-bugs@cs.utah.edu).
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
23 02111-1307, USA. */
24
25#include "bfd.h"
26#include "sysdep.h"
27
28#if defined (HOST_HPPAHPUX) || defined (HOST_HPPABSD) || defined (HOST_HPPAOSF) || defined(HOST_HPPAMPEIX)
29
30#include "libbfd.h"
31#include "som.h"
32
33#include <sys/param.h>
34#include <signal.h>
35#include <machine/reg.h>
36#include <sys/file.h>
37#include <ctype.h>
38
39/* Magic not defined in standard HP-UX header files until 8.0 */
40
41#ifndef CPU_PA_RISC1_0
42#define CPU_PA_RISC1_0 0x20B
43#endif /* CPU_PA_RISC1_0 */
44
45#ifndef CPU_PA_RISC1_1
46#define CPU_PA_RISC1_1 0x210
47#endif /* CPU_PA_RISC1_1 */
48
49#ifndef CPU_PA_RISC2_0
50#define CPU_PA_RISC2_0 0x214
51#endif /* CPU_PA_RISC2_0 */
52
53#ifndef _PA_RISC1_0_ID
54#define _PA_RISC1_0_ID CPU_PA_RISC1_0
55#endif /* _PA_RISC1_0_ID */
56
57#ifndef _PA_RISC1_1_ID
58#define _PA_RISC1_1_ID CPU_PA_RISC1_1
59#endif /* _PA_RISC1_1_ID */
60
61#ifndef _PA_RISC2_0_ID
62#define _PA_RISC2_0_ID CPU_PA_RISC2_0
63#endif /* _PA_RISC2_0_ID */
64
65#ifndef _PA_RISC_MAXID
66#define _PA_RISC_MAXID 0x2FF
67#endif /* _PA_RISC_MAXID */
68
69#ifndef _PA_RISC_ID
70#define _PA_RISC_ID(__m_num) \
71 (((__m_num) == _PA_RISC1_0_ID) || \
72 ((__m_num) >= _PA_RISC1_1_ID && (__m_num) <= _PA_RISC_MAXID))
73#endif /* _PA_RISC_ID */
74
75
76/* HIUX in it's infinite stupidity changed the names for several "well
77 known" constants. Work around such braindamage. Try the HPUX version
78 first, then the HIUX version, and finally provide a default. */
79#ifdef HPUX_AUX_ID
80#define EXEC_AUX_ID HPUX_AUX_ID
81#endif
82
83#if !defined (EXEC_AUX_ID) && defined (HIUX_AUX_ID)
84#define EXEC_AUX_ID HIUX_AUX_ID
85#endif
86
87#ifndef EXEC_AUX_ID
88#define EXEC_AUX_ID 0
89#endif
90
91/* Size (in chars) of the temporary buffers used during fixup and string
92 table writes. */
93
94#define SOM_TMP_BUFSIZE 8192
95
96/* Size of the hash table in archives. */
97#define SOM_LST_HASH_SIZE 31
98
99/* Max number of SOMs to be found in an archive. */
100#define SOM_LST_MODULE_LIMIT 1024
101
102/* Generic alignment macro. */
103#define SOM_ALIGN(val, alignment) \
104 (((val) + (alignment) - 1) & ~((alignment) - 1))
105
106/* SOM allows any one of the four previous relocations to be reused
107 with a "R_PREV_FIXUP" relocation entry. Since R_PREV_FIXUP
108 relocations are always a single byte, using a R_PREV_FIXUP instead
109 of some multi-byte relocation makes object files smaller.
110
111 Note one side effect of using a R_PREV_FIXUP is the relocation that
112 is being repeated moves to the front of the queue. */
113struct reloc_queue
114 {
115 unsigned char *reloc;
116 unsigned int size;
117 } reloc_queue[4];
118
119/* This fully describes the symbol types which may be attached to
120 an EXPORT or IMPORT directive. Only SOM uses this formation
121 (ELF has no need for it). */
122typedef enum
123{
124 SYMBOL_TYPE_UNKNOWN,
125 SYMBOL_TYPE_ABSOLUTE,
126 SYMBOL_TYPE_CODE,
127 SYMBOL_TYPE_DATA,
128 SYMBOL_TYPE_ENTRY,
129 SYMBOL_TYPE_MILLICODE,
130 SYMBOL_TYPE_PLABEL,
131 SYMBOL_TYPE_PRI_PROG,
132 SYMBOL_TYPE_SEC_PROG,
133} pa_symbol_type;
134
135struct section_to_type
136{
137 char *section;
138 char type;
139};
140
141/* Assorted symbol information that needs to be derived from the BFD symbol
142 and/or the BFD backend private symbol data. */
143struct som_misc_symbol_info
144{
145 unsigned int symbol_type;
146 unsigned int symbol_scope;
147 unsigned int arg_reloc;
148 unsigned int symbol_info;
149 unsigned int symbol_value;
150 unsigned int priv_level;
ba20314e 151 unsigned int secondary_def;
252b5132
RH		 152};
153
154/* Forward declarations */
155
156static boolean som_mkobject PARAMS ((bfd *));
157static const bfd_target * som_object_setup PARAMS ((bfd *,
158 struct header *,
159 struct som_exec_auxhdr *,
160 unsigned long));
161static boolean setup_sections PARAMS ((bfd *, struct header *, unsigned long));
162static const bfd_target * som_object_p PARAMS ((bfd *));
163static boolean som_write_object_contents PARAMS ((bfd *));
164static boolean som_slurp_string_table PARAMS ((bfd *));
165static unsigned int som_slurp_symbol_table PARAMS ((bfd *));
166static long som_get_symtab_upper_bound PARAMS ((bfd *));
167static long som_canonicalize_reloc PARAMS ((bfd *, sec_ptr,
168 arelent **, asymbol **));
169static long som_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr));
170static unsigned int som_set_reloc_info PARAMS ((unsigned char *, unsigned int,
171 arelent *, asection *,
172 asymbol **, boolean));
173static boolean som_slurp_reloc_table PARAMS ((bfd *, asection *,
174 asymbol **, boolean));
175static long som_get_symtab PARAMS ((bfd *, asymbol **));
176static asymbol * som_make_empty_symbol PARAMS ((bfd *));
177static void som_print_symbol PARAMS ((bfd *, PTR,
178 asymbol *, bfd_print_symbol_type));
179static boolean som_new_section_hook PARAMS ((bfd *, asection *));
180static boolean som_bfd_copy_private_symbol_data PARAMS ((bfd *, asymbol *,
181 bfd *, asymbol *));
182static boolean som_bfd_copy_private_section_data PARAMS ((bfd *, asection *,
183 bfd *, asection *));
184static boolean som_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
185#define som_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
186#define som_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
187static boolean som_bfd_is_local_label_name PARAMS ((bfd *, const char *));
188static boolean som_set_section_contents PARAMS ((bfd *, sec_ptr, PTR,
189 file_ptr, bfd_size_type));
190static boolean som_get_section_contents PARAMS ((bfd *, sec_ptr, PTR,
191 file_ptr, bfd_size_type));
192static boolean som_set_arch_mach PARAMS ((bfd *, enum bfd_architecture,
193 unsigned long));
194static boolean som_find_nearest_line PARAMS ((bfd *, asection *,
195 asymbol **, bfd_vma,
196 CONST char **,
197 CONST char **,
198 unsigned int *));
199static void som_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
200static asection * bfd_section_from_som_symbol PARAMS ((bfd *,
201 struct symbol_dictionary_record *));
202static int log2 PARAMS ((unsigned int));
203static bfd_reloc_status_type hppa_som_reloc PARAMS ((bfd *, arelent *,
204 asymbol *, PTR,
205 asection *, bfd *,
206 char **));
207static void som_initialize_reloc_queue PARAMS ((struct reloc_queue *));
208static void som_reloc_queue_insert PARAMS ((unsigned char *, unsigned int,
209 struct reloc_queue *));
210static void som_reloc_queue_fix PARAMS ((struct reloc_queue *, unsigned int));
211static int som_reloc_queue_find PARAMS ((unsigned char *, unsigned int,
212 struct reloc_queue *));
213static unsigned char * try_prev_fixup PARAMS ((bfd *, int *, unsigned char *,
214 unsigned int,
215 struct reloc_queue *));
216
217static unsigned char * som_reloc_skip PARAMS ((bfd *, unsigned int,
218 unsigned char *, unsigned int *,
219 struct reloc_queue *));
220static unsigned char * som_reloc_addend PARAMS ((bfd *, int, unsigned char *,
221 unsigned int *,
222 struct reloc_queue *));
223static unsigned char * som_reloc_call PARAMS ((bfd *, unsigned char *,
224 unsigned int *,
225 arelent *, int,
226 struct reloc_queue *));
227static unsigned long som_count_spaces PARAMS ((bfd *));
228static unsigned long som_count_subspaces PARAMS ((bfd *));
229static int compare_syms PARAMS ((const void *, const void *));
230static int compare_subspaces PARAMS ((const void *, const void *));
231static unsigned long som_compute_checksum PARAMS ((bfd *));
232static boolean som_prep_headers PARAMS ((bfd *));
233static int som_sizeof_headers PARAMS ((bfd *, boolean));
234static boolean som_finish_writing PARAMS ((bfd *));
235static boolean som_build_and_write_symbol_table PARAMS ((bfd *));
236static void som_prep_for_fixups PARAMS ((bfd *, asymbol **, unsigned long));
237static boolean som_write_fixups PARAMS ((bfd *, unsigned long, unsigned int *));
238static boolean som_write_space_strings PARAMS ((bfd *, unsigned long,
239 unsigned int *));
240static boolean som_write_symbol_strings PARAMS ((bfd *, unsigned long,
241 asymbol **, unsigned int,
242 unsigned *,
243 COMPUNIT *));
244static boolean som_begin_writing PARAMS ((bfd *));
245static reloc_howto_type * som_bfd_reloc_type_lookup
246 PARAMS ((bfd *, bfd_reloc_code_real_type));
247static char som_section_type PARAMS ((const char *));
248static int som_decode_symclass PARAMS ((asymbol *));
249static boolean som_bfd_count_ar_symbols PARAMS ((bfd *, struct lst_header *,
250 symindex *));
251
252static boolean som_bfd_fill_in_ar_symbols PARAMS ((bfd *, struct lst_header *,
253 carsym **syms));
254static boolean som_slurp_armap PARAMS ((bfd *));
255static boolean som_write_armap PARAMS ((bfd *, unsigned int, struct orl *,
256 unsigned int, int));
257static void som_bfd_derive_misc_symbol_info PARAMS ((bfd *, asymbol *,
258 struct som_misc_symbol_info *));
259static boolean som_bfd_prep_for_ar_write PARAMS ((bfd *, unsigned int *,
260 unsigned int *));
261static unsigned int som_bfd_ar_symbol_hash PARAMS ((asymbol *));
262static boolean som_bfd_ar_write_symbol_stuff PARAMS ((bfd *, unsigned int,
263 unsigned int,
264 struct lst_header,
265 unsigned int));
266static boolean som_is_space PARAMS ((asection *));
267static boolean som_is_subspace PARAMS ((asection *));
268static boolean som_is_container PARAMS ((asection *, asection *));
269static boolean som_bfd_free_cached_info PARAMS ((bfd *));
270static boolean som_bfd_link_split_section PARAMS ((bfd *, asection *));
271
272/* Map SOM section names to POSIX/BSD single-character symbol types.
273
274 This table includes all the standard subspaces as defined in the
275 current "PRO ABI for PA-RISC Systems", $UNWIND$ which for
276 some reason was left out, and sections specific to embedded stabs. */
277
278static const struct section_to_type stt[] = {
279 {"$TEXT$", 't'},
280 {"$SHLIB_INFO$", 't'},
281 {"$MILLICODE$", 't'},
282 {"$LIT$", 't'},
283 {"$CODE$", 't'},
284 {"$UNWIND_START$", 't'},
285 {"$UNWIND$", 't'},
286 {"$PRIVATE$", 'd'},
287 {"$PLT$", 'd'},
288 {"$SHLIB_DATA$", 'd'},
289 {"$DATA$", 'd'},
290 {"$SHORTDATA$", 'g'},
291 {"$DLT$", 'd'},
292 {"$GLOBAL$", 'g'},
293 {"$SHORTBSS$", 's'},
294 {"$BSS$", 'b'},
295 {"$GDB_STRINGS$", 'N'},
296 {"$GDB_SYMBOLS$", 'N'},
297 {0, 0}
298};
299
300/* About the relocation formatting table...
301
302 There are 256 entries in the table, one for each possible
303 relocation opcode available in SOM. We index the table by
304 the relocation opcode. The names and operations are those
305 defined by a.out_800 (4).
306
307 Right now this table is only used to count and perform minimal
308 processing on relocation streams so that they can be internalized
309 into BFD and symbolically printed by utilities. To make actual use
310 of them would be much more difficult, BFD's concept of relocations
311 is far too simple to handle SOM relocations. The basic assumption
312 that a relocation can be completely processed independent of other
313 relocations before an object file is written is invalid for SOM.
314
315 The SOM relocations are meant to be processed as a stream, they
316 specify copying of data from the input section to the output section
317 while possibly modifying the data in some manner. They also can
318 specify that a variable number of zeros or uninitialized data be
319 inserted on in the output segment at the current offset. Some
320 relocations specify that some previous relocation be re-applied at
321 the current location in the input/output sections. And finally a number
322 of relocations have effects on other sections (R_ENTRY, R_EXIT,
323 R_UNWIND_AUX and a variety of others). There isn't even enough room
324 in the BFD relocation data structure to store enough information to
325 perform all the relocations.
326
327 Each entry in the table has three fields.
328
329 The first entry is an index into this "class" of relocations. This
330 index can then be used as a variable within the relocation itself.
331
332 The second field is a format string which actually controls processing
333 of the relocation. It uses a simple postfix machine to do calculations
334 based on variables/constants found in the string and the relocation
335 stream.
336
337 The third field specifys whether or not this relocation may use
338 a constant (V) from the previous R_DATA_OVERRIDE rather than a constant
339 stored in the instruction.
340
341 Variables:
342
343 L = input space byte count
344 D = index into class of relocations
345 M = output space byte count
346 N = statement number (unused?)
347 O = stack operation
348 R = parameter relocation bits
349 S = symbol index
350 T = first 32 bits of stack unwind information
351 U = second 32 bits of stack unwind information
352 V = a literal constant (usually used in the next relocation)
353 P = a previous relocation
354
355 Lower case letters (starting with 'b') refer to following
356 bytes in the relocation stream. 'b' is the next 1 byte,
357 c is the next 2 bytes, d is the next 3 bytes, etc...
358 This is the variable part of the relocation entries that
359 makes our life a living hell.
360
361 numerical constants are also used in the format string. Note
362 the constants are represented in decimal.
363
364 '+', "*" and "=" represents the obvious postfix operators.
365 '<' represents a left shift.
366
367 Stack Operations:
368
369 Parameter Relocation Bits:
370
371 Unwind Entries:
372
373 Previous Relocations: The index field represents which in the queue
374 of 4 previous fixups should be re-applied.
375
376 Literal Constants: These are generally used to represent addend
377 parts of relocations when these constants are not stored in the
378 fields of the instructions themselves. For example the instruction
379 addil foo-$global$-0x1234 would use an override for "0x1234" rather
380 than storing it into the addil itself. */
381
382struct fixup_format
383{
384 int D;
385 char *format;
386};
387
388static const struct fixup_format som_fixup_formats[256] =
389{
390 /* R_NO_RELOCATION */
391 0, "LD1+4*=", /* 0x00 */
392 1, "LD1+4*=", /* 0x01 */
393 2, "LD1+4*=", /* 0x02 */
394 3, "LD1+4*=", /* 0x03 */
395 4, "LD1+4*=", /* 0x04 */
396 5, "LD1+4*=", /* 0x05 */
397 6, "LD1+4*=", /* 0x06 */
398 7, "LD1+4*=", /* 0x07 */
399 8, "LD1+4*=", /* 0x08 */
400 9, "LD1+4*=", /* 0x09 */
401 10, "LD1+4*=", /* 0x0a */
402 11, "LD1+4*=", /* 0x0b */
403 12, "LD1+4*=", /* 0x0c */
404 13, "LD1+4*=", /* 0x0d */
405 14, "LD1+4*=", /* 0x0e */
406 15, "LD1+4*=", /* 0x0f */
407 16, "LD1+4*=", /* 0x10 */
408 17, "LD1+4*=", /* 0x11 */
409 18, "LD1+4*=", /* 0x12 */
410 19, "LD1+4*=", /* 0x13 */
411 20, "LD1+4*=", /* 0x14 */
412 21, "LD1+4*=", /* 0x15 */
413 22, "LD1+4*=", /* 0x16 */
414 23, "LD1+4*=", /* 0x17 */
415 0, "LD8<b+1+4*=", /* 0x18 */
416 1, "LD8<b+1+4*=", /* 0x19 */
417 2, "LD8<b+1+4*=", /* 0x1a */
418 3, "LD8<b+1+4*=", /* 0x1b */
419 0, "LD16<c+1+4*=", /* 0x1c */
420 1, "LD16<c+1+4*=", /* 0x1d */
421 2, "LD16<c+1+4*=", /* 0x1e */
422 0, "Ld1+=", /* 0x1f */
423 /* R_ZEROES */
424 0, "Lb1+4*=", /* 0x20 */
425 1, "Ld1+=", /* 0x21 */
426 /* R_UNINIT */
427 0, "Lb1+4*=", /* 0x22 */
428 1, "Ld1+=", /* 0x23 */
429 /* R_RELOCATION */
430 0, "L4=", /* 0x24 */
431 /* R_DATA_ONE_SYMBOL */
432 0, "L4=Sb=", /* 0x25 */
433 1, "L4=Sd=", /* 0x26 */
434 /* R_DATA_PLEBEL */
435 0, "L4=Sb=", /* 0x27 */
436 1, "L4=Sd=", /* 0x28 */
437 /* R_SPACE_REF */
438 0, "L4=", /* 0x29 */
439 /* R_REPEATED_INIT */
440 0, "L4=Mb1+4*=", /* 0x2a */
441 1, "Lb4*=Mb1+L*=", /* 0x2b */
442 2, "Lb4*=Md1+4*=", /* 0x2c */
443 3, "Ld1+=Me1+=", /* 0x2d */
252b5132 444 0, "", /* 0x2e */
252b5132
RH		 445 0, "", /* 0x2f */
446 /* R_PCREL_CALL */
447 0, "L4=RD=Sb=", /* 0x30 */
448 1, "L4=RD=Sb=", /* 0x31 */
449 2, "L4=RD=Sb=", /* 0x32 */
450 3, "L4=RD=Sb=", /* 0x33 */
451 4, "L4=RD=Sb=", /* 0x34 */
452 5, "L4=RD=Sb=", /* 0x35 */
453 6, "L4=RD=Sb=", /* 0x36 */
454 7, "L4=RD=Sb=", /* 0x37 */
455 8, "L4=RD=Sb=", /* 0x38 */
456 9, "L4=RD=Sb=", /* 0x39 */
457 0, "L4=RD8<b+=Sb=",/* 0x3a */
458 1, "L4=RD8<b+=Sb=",/* 0x3b */
459 0, "L4=RD8<b+=Sd=",/* 0x3c */
460 1, "L4=RD8<b+=Sd=",/* 0x3d */
c1006781 461 /* R_SHORT_PCREL_MODE */
252b5132 462 0, "", /* 0x3e */
c1006781 463 /* R_LONG_PCREL_MODE */
252b5132
RH		 464 0, "", /* 0x3f */
465 /* R_ABS_CALL */
466 0, "L4=RD=Sb=", /* 0x40 */
467 1, "L4=RD=Sb=", /* 0x41 */
468 2, "L4=RD=Sb=", /* 0x42 */
469 3, "L4=RD=Sb=", /* 0x43 */
470 4, "L4=RD=Sb=", /* 0x44 */
471 5, "L4=RD=Sb=", /* 0x45 */
472 6, "L4=RD=Sb=", /* 0x46 */
473 7, "L4=RD=Sb=", /* 0x47 */
474 8, "L4=RD=Sb=", /* 0x48 */
475 9, "L4=RD=Sb=", /* 0x49 */
476 0, "L4=RD8<b+=Sb=",/* 0x4a */
477 1, "L4=RD8<b+=Sb=",/* 0x4b */
478 0, "L4=RD8<b+=Sd=",/* 0x4c */
479 1, "L4=RD8<b+=Sd=",/* 0x4d */
480 /* R_RESERVED */
481 0, "", /* 0x4e */
482 0, "", /* 0x4f */
483 /* R_DP_RELATIVE */
484 0, "L4=SD=", /* 0x50 */
485 1, "L4=SD=", /* 0x51 */
486 2, "L4=SD=", /* 0x52 */
487 3, "L4=SD=", /* 0x53 */
488 4, "L4=SD=", /* 0x54 */
489 5, "L4=SD=", /* 0x55 */
490 6, "L4=SD=", /* 0x56 */
491 7, "L4=SD=", /* 0x57 */
492 8, "L4=SD=", /* 0x58 */
493 9, "L4=SD=", /* 0x59 */
494 10, "L4=SD=", /* 0x5a */
495 11, "L4=SD=", /* 0x5b */
496 12, "L4=SD=", /* 0x5c */
497 13, "L4=SD=", /* 0x5d */
498 14, "L4=SD=", /* 0x5e */
499 15, "L4=SD=", /* 0x5f */
500 16, "L4=SD=", /* 0x60 */
501 17, "L4=SD=", /* 0x61 */
502 18, "L4=SD=", /* 0x62 */
503 19, "L4=SD=", /* 0x63 */
504 20, "L4=SD=", /* 0x64 */
505 21, "L4=SD=", /* 0x65 */
506 22, "L4=SD=", /* 0x66 */
507 23, "L4=SD=", /* 0x67 */
508 24, "L4=SD=", /* 0x68 */
509 25, "L4=SD=", /* 0x69 */
510 26, "L4=SD=", /* 0x6a */
511 27, "L4=SD=", /* 0x6b */
512 28, "L4=SD=", /* 0x6c */
513 29, "L4=SD=", /* 0x6d */
514 30, "L4=SD=", /* 0x6e */
515 31, "L4=SD=", /* 0x6f */
516 32, "L4=Sb=", /* 0x70 */
517 33, "L4=Sd=", /* 0x71 */
518 /* R_RESERVED */
519 0, "", /* 0x72 */
520 0, "", /* 0x73 */
521 0, "", /* 0x74 */
522 0, "", /* 0x75 */
523 0, "", /* 0x76 */
524 0, "", /* 0x77 */
525 /* R_DLT_REL */
526 0, "L4=Sb=", /* 0x78 */
527 1, "L4=Sd=", /* 0x79 */
528 /* R_RESERVED */
529 0, "", /* 0x7a */
530 0, "", /* 0x7b */
531 0, "", /* 0x7c */
532 0, "", /* 0x7d */
533 0, "", /* 0x7e */
534 0, "", /* 0x7f */
535 /* R_CODE_ONE_SYMBOL */
536 0, "L4=SD=", /* 0x80 */
537 1, "L4=SD=", /* 0x81 */
538 2, "L4=SD=", /* 0x82 */
539 3, "L4=SD=", /* 0x83 */
540 4, "L4=SD=", /* 0x84 */
541 5, "L4=SD=", /* 0x85 */
542 6, "L4=SD=", /* 0x86 */
543 7, "L4=SD=", /* 0x87 */
544 8, "L4=SD=", /* 0x88 */
545 9, "L4=SD=", /* 0x89 */
546 10, "L4=SD=", /* 0x8q */
547 11, "L4=SD=", /* 0x8b */
548 12, "L4=SD=", /* 0x8c */
549 13, "L4=SD=", /* 0x8d */
550 14, "L4=SD=", /* 0x8e */
551 15, "L4=SD=", /* 0x8f */
552 16, "L4=SD=", /* 0x90 */
553 17, "L4=SD=", /* 0x91 */
554 18, "L4=SD=", /* 0x92 */
555 19, "L4=SD=", /* 0x93 */
556 20, "L4=SD=", /* 0x94 */
557 21, "L4=SD=", /* 0x95 */
558 22, "L4=SD=", /* 0x96 */
559 23, "L4=SD=", /* 0x97 */
560 24, "L4=SD=", /* 0x98 */
561 25, "L4=SD=", /* 0x99 */
562 26, "L4=SD=", /* 0x9a */
563 27, "L4=SD=", /* 0x9b */
564 28, "L4=SD=", /* 0x9c */
565 29, "L4=SD=", /* 0x9d */
566 30, "L4=SD=", /* 0x9e */
567 31, "L4=SD=", /* 0x9f */
568 32, "L4=Sb=", /* 0xa0 */
569 33, "L4=Sd=", /* 0xa1 */
570 /* R_RESERVED */
571 0, "", /* 0xa2 */
572 0, "", /* 0xa3 */
573 0, "", /* 0xa4 */
574 0, "", /* 0xa5 */
575 0, "", /* 0xa6 */
576 0, "", /* 0xa7 */
577 0, "", /* 0xa8 */
578 0, "", /* 0xa9 */
579 0, "", /* 0xaa */
580 0, "", /* 0xab */
581 0, "", /* 0xac */
582 0, "", /* 0xad */
583 /* R_MILLI_REL */
584 0, "L4=Sb=", /* 0xae */
585 1, "L4=Sd=", /* 0xaf */
586 /* R_CODE_PLABEL */
587 0, "L4=Sb=", /* 0xb0 */
588 1, "L4=Sd=", /* 0xb1 */
589 /* R_BREAKPOINT */
590 0, "L4=", /* 0xb2 */
591 /* R_ENTRY */
592 0, "Te=Ue=", /* 0xb3 */
593 1, "Uf=", /* 0xb4 */
594 /* R_ALT_ENTRY */
595 0, "", /* 0xb5 */
596 /* R_EXIT */
597 0, "", /* 0xb6 */
598 /* R_BEGIN_TRY */
599 0, "", /* 0xb7 */
600 /* R_END_TRY */
601 0, "R0=", /* 0xb8 */
602 1, "Rb4*=", /* 0xb9 */
603 2, "Rd4*=", /* 0xba */
604 /* R_BEGIN_BRTAB */
605 0, "", /* 0xbb */
606 /* R_END_BRTAB */
607 0, "", /* 0xbc */
608 /* R_STATEMENT */
609 0, "Nb=", /* 0xbd */
610 1, "Nc=", /* 0xbe */
611 2, "Nd=", /* 0xbf */
612 /* R_DATA_EXPR */
613 0, "L4=", /* 0xc0 */
614 /* R_CODE_EXPR */
615 0, "L4=", /* 0xc1 */
616 /* R_FSEL */
617 0, "", /* 0xc2 */
618 /* R_LSEL */
619 0, "", /* 0xc3 */
620 /* R_RSEL */
621 0, "", /* 0xc4 */
622 /* R_N_MODE */
623 0, "", /* 0xc5 */
624 /* R_S_MODE */
625 0, "", /* 0xc6 */
626 /* R_D_MODE */
627 0, "", /* 0xc7 */
628 /* R_R_MODE */
629 0, "", /* 0xc8 */
630 /* R_DATA_OVERRIDE */
631 0, "V0=", /* 0xc9 */
632 1, "Vb=", /* 0xca */
633 2, "Vc=", /* 0xcb */
634 3, "Vd=", /* 0xcc */
635 4, "Ve=", /* 0xcd */
636 /* R_TRANSLATED */
637 0, "", /* 0xce */
832fc202
JL		 638 /* R_AUX_UNWIND */
639 0, "Sd=Vf=Ef=", /* 0xcf */
252b5132
RH		 640 /* R_COMP1 */
641 0, "Ob=", /* 0xd0 */
642 /* R_COMP2 */
643 0, "Ob=Sd=", /* 0xd1 */
644 /* R_COMP3 */
645 0, "Ob=Ve=", /* 0xd2 */
646 /* R_PREV_FIXUP */
647 0, "P", /* 0xd3 */
648 1, "P", /* 0xd4 */
649 2, "P", /* 0xd5 */
650 3, "P", /* 0xd6 */
651 /* R_SEC_STMT */
652 0, "", /* 0xd7 */
653 /* R_N0SEL */
654 0, "", /* 0xd8 */
655 /* R_N1SEL */
656 0, "", /* 0xd9 */
657 /* R_LINETAB */
832fc202 658 0, "Eb=Sd=Ve=", /* 0xda */
252b5132 659 /* R_LINETAB_ESC */
832fc202 660 0, "Eb=Mb=", /* 0xdb */
252b5132
RH		 661 /* R_LTP_OVERRIDE */
662 0, "", /* 0xdc */
663 /* R_COMMENT */
832fc202 664 0, "Ob=Ve=", /* 0xdd */
252b5132
RH		 665 /* R_RESERVED */
666 0, "", /* 0xde */
667 0, "", /* 0xdf */
668 0, "", /* 0xe0 */
669 0, "", /* 0xe1 */
670 0, "", /* 0xe2 */
671 0, "", /* 0xe3 */
672 0, "", /* 0xe4 */
673 0, "", /* 0xe5 */
674 0, "", /* 0xe6 */
675 0, "", /* 0xe7 */
676 0, "", /* 0xe8 */
677 0, "", /* 0xe9 */
678 0, "", /* 0xea */
679 0, "", /* 0xeb */
680 0, "", /* 0xec */
681 0, "", /* 0xed */
682 0, "", /* 0xee */
683 0, "", /* 0xef */
684 0, "", /* 0xf0 */
685 0, "", /* 0xf1 */
686 0, "", /* 0xf2 */
687 0, "", /* 0xf3 */
688 0, "", /* 0xf4 */
689 0, "", /* 0xf5 */
690 0, "", /* 0xf6 */
691 0, "", /* 0xf7 */
692 0, "", /* 0xf8 */
693 0, "", /* 0xf9 */
694 0, "", /* 0xfa */
695 0, "", /* 0xfb */
696 0, "", /* 0xfc */
697 0, "", /* 0xfd */
698 0, "", /* 0xfe */
699 0, "", /* 0xff */
700};
701
702static const int comp1_opcodes[] =
703{
704 0x00,
705 0x40,
706 0x41,
707 0x42,
708 0x43,
709 0x44,
710 0x45,
711 0x46,
712 0x47,
713 0x48,
714 0x49,
715 0x4a,
716 0x4b,
717 0x60,
718 0x80,
719 0xa0,
720 0xc0,
721 -1
722};
723
724static const int comp2_opcodes[] =
725{
726 0x00,
727 0x80,
728 0x82,
729 0xc0,
730 -1
731};
732
733static const int comp3_opcodes[] =
734{
735 0x00,
736 0x02,
737 -1
738};
739
740/* These apparently are not in older versions of hpux reloc.h (hpux7). */
741#ifndef R_DLT_REL
742#define R_DLT_REL 0x78
743#endif
744
745#ifndef R_AUX_UNWIND
746#define R_AUX_UNWIND 0xcf
747#endif
748
749#ifndef R_SEC_STMT
750#define R_SEC_STMT 0xd7
751#endif
752
753/* And these first appeared in hpux10. */
754#ifndef R_SHORT_PCREL_MODE
2667095f 755#define NO_PCREL_MODES
252b5132
RH		 756#define R_SHORT_PCREL_MODE 0x3e
757#endif
758
759#ifndef R_LONG_PCREL_MODE
760#define R_LONG_PCREL_MODE 0x3f
761#endif
762
763#ifndef R_N0SEL
764#define R_N0SEL 0xd8
765#endif
766
767#ifndef R_N1SEL
768#define R_N1SEL 0xd9
769#endif
770
771#ifndef R_LINETAB
772#define R_LINETAB 0xda
773#endif
774
775#ifndef R_LINETAB_ESC
776#define R_LINETAB_ESC 0xdb
777#endif
778
779#ifndef R_LTP_OVERRIDE
780#define R_LTP_OVERRIDE 0xdc
781#endif
782
783#ifndef R_COMMENT
784#define R_COMMENT 0xdd
785#endif
786
787static reloc_howto_type som_hppa_howto_table[] =
788{
789 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
790 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
791 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
792 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
793 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
794 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
795 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
796 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
797 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
798 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
799 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
800 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
801 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
802 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
803 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
804 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
805 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
806 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
807 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
808 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
809 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
810 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
811 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
812 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
813 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
814 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
815 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
816 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
817 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
818 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
819 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
820 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
821 {R_ZEROES, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ZEROES"},
822 {R_ZEROES, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ZEROES"},
823 {R_UNINIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_UNINIT"},
824 {R_UNINIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_UNINIT"},
825 {R_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RELOCATION"},
826 {R_DATA_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_ONE_SYMBOL"},
827 {R_DATA_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_ONE_SYMBOL"},
828 {R_DATA_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_PLABEL"},
829 {R_DATA_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_PLABEL"},
830 {R_SPACE_REF, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_SPACE_REF"},
831 {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
832 {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
833 {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
834 {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
835 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
836 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
837 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
838 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
839 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
840 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
841 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
842 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
843 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
844 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
845 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
846 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
847 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
848 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
849 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
850 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
851 {R_SHORT_PCREL_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_SHORT_PCREL_MODE"},
852 {R_LONG_PCREL_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LONG_PCREL_MODE"},
853 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
854 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
855 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
856 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
857 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
858 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
859 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
860 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
861 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
862 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
863 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
864 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
865 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
866 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
867 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
868 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
869 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
870 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
871 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
872 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
873 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
874 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
875 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
876 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
877 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
878 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
879 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
880 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
881 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
882 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
883 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
884 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
885 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
886 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
887 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
888 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
889 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
890 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
891 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
892 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
893 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
894 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
895 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
896 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
897 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
898 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
899 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
900 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
901 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
902 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
903 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
904 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
905 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
906 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
907 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
908 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
909 {R_DLT_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DLT_REL"},
910 {R_DLT_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DLT_REL"},
911 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
912 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
913 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
914 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
915 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
916 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
917 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
918 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
919 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
920 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
921 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
922 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
923 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
924 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
925 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
926 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
927 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
928 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
929 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
930 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
931 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
932 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
933 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
934 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
935 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
936 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
937 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
938 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
939 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
940 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
941 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
942 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
943 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
944 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
945 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
946 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
947 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
948 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
949 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
950 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
951 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
952 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
953 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
954 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
955 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
956 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
957 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
958 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
959 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
960 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
961 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
962 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
963 {R_MILLI_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_MILLI_REL"},
964 {R_MILLI_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_MILLI_REL"},
965 {R_CODE_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_PLABEL"},
966 {R_CODE_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_PLABEL"},
967 {R_BREAKPOINT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_BREAKPOINT"},
968 {R_ENTRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ENTRY"},
969 {R_ENTRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ENTRY"},
970 {R_ALT_ENTRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ALT_ENTRY"},
971 {R_EXIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_EXIT"},
972 {R_BEGIN_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_BEGIN_TRY"},
973 {R_END_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_TRY"},
974 {R_END_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_TRY"},
975 {R_END_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_TRY"},
976 {R_BEGIN_BRTAB, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_BEGIN_BRTAB"},
977 {R_END_BRTAB, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_BRTAB"},
978 {R_STATEMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_STATEMENT"},
979 {R_STATEMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_STATEMENT"},
980 {R_STATEMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_STATEMENT"},
981 {R_DATA_EXPR, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_EXPR"},
982 {R_CODE_EXPR, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_EXPR"},
983 {R_FSEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_FSEL"},
984 {R_LSEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LSEL"},
985 {R_RSEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RSEL"},
986 {R_N_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_N_MODE"},
987 {R_S_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_S_MODE"},
988 {R_D_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_D_MODE"},
989 {R_R_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_R_MODE"},
990 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
991 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
992 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
993 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
994 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
995 {R_TRANSLATED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_TRANSLATED"},
996 {R_AUX_UNWIND, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_AUX_UNWIND"},
997 {R_COMP1, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMP1"},
998 {R_COMP2, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMP2"},
999 {R_COMP3, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMP3"},
1000 {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
1001 {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
1002 {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
1003 {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
1004 {R_SEC_STMT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_SEC_STMT"},
1005 {R_N0SEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_N0SEL"},
1006 {R_N1SEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_N1SEL"},
1007 {R_LINETAB, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LINETAB"},
1008 {R_LINETAB_ESC, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LINETAB_ESC"},
1009 {R_LTP_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LTP_OVERRIDE"},
1010 {R_COMMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMMENT"},
1011 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1012 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1013 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1014 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1015 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1016 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1017 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1018 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1019 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1020 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1021 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1022 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1023 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1024 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1025 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1026 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1027 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1028 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1029 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1030 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1031 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1032 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1033 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1034 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1035 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1036 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1037 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1038 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1039 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1040 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1041 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1042 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1043 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1044 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"}};
1045
1046/* Initialize the SOM relocation queue. By definition the queue holds
1047 the last four multibyte fixups. */
1048
1049static void
1050som_initialize_reloc_queue (queue)
1051 struct reloc_queue *queue;
1052{
1053 queue[0].reloc = NULL;
1054 queue[0].size = 0;
1055 queue[1].reloc = NULL;
1056 queue[1].size = 0;
1057 queue[2].reloc = NULL;
1058 queue[2].size = 0;
1059 queue[3].reloc = NULL;
1060 queue[3].size = 0;
1061}
1062
1063/* Insert a new relocation into the relocation queue. */
1064
1065static void
1066som_reloc_queue_insert (p, size, queue)
1067 unsigned char *p;
1068 unsigned int size;
1069 struct reloc_queue *queue;
1070{
1071 queue[3].reloc = queue[2].reloc;
1072 queue[3].size = queue[2].size;
1073 queue[2].reloc = queue[1].reloc;
1074 queue[2].size = queue[1].size;
1075 queue[1].reloc = queue[0].reloc;
1076 queue[1].size = queue[0].size;
1077 queue[0].reloc = p;
1078 queue[0].size = size;
1079}
1080
1081/* When an entry in the relocation queue is reused, the entry moves
1082 to the front of the queue. */
1083
1084static void
1085som_reloc_queue_fix (queue, index)
1086 struct reloc_queue *queue;
1087 unsigned int index;
1088{
1089 if (index == 0)
1090 return;
1091
1092 if (index == 1)
1093 {
1094 unsigned char *tmp1 = queue[0].reloc;
1095 unsigned int tmp2 = queue[0].size;
1096 queue[0].reloc = queue[1].reloc;
1097 queue[0].size = queue[1].size;
1098 queue[1].reloc = tmp1;
1099 queue[1].size = tmp2;
1100 return;
1101 }
1102
1103 if (index == 2)
1104 {
1105 unsigned char *tmp1 = queue[0].reloc;
1106 unsigned int tmp2 = queue[0].size;
1107 queue[0].reloc = queue[2].reloc;
1108 queue[0].size = queue[2].size;
1109 queue[2].reloc = queue[1].reloc;
1110 queue[2].size = queue[1].size;
1111 queue[1].reloc = tmp1;
1112 queue[1].size = tmp2;
1113 return;
1114 }
1115
1116 if (index == 3)
1117 {
1118 unsigned char *tmp1 = queue[0].reloc;
1119 unsigned int tmp2 = queue[0].size;
1120 queue[0].reloc = queue[3].reloc;
1121 queue[0].size = queue[3].size;
1122 queue[3].reloc = queue[2].reloc;
1123 queue[3].size = queue[2].size;
1124 queue[2].reloc = queue[1].reloc;
1125 queue[2].size = queue[1].size;
1126 queue[1].reloc = tmp1;
1127 queue[1].size = tmp2;
1128 return;
1129 }
1130 abort();
1131}
1132
1133/* Search for a particular relocation in the relocation queue. */
1134
1135static int
1136som_reloc_queue_find (p, size, queue)
1137 unsigned char *p;
1138 unsigned int size;
1139 struct reloc_queue *queue;
1140{
1141 if (queue[0].reloc && !memcmp (p, queue[0].reloc, size)
1142 && size == queue[0].size)
1143 return 0;
1144 if (queue[1].reloc && !memcmp (p, queue[1].reloc, size)
1145 && size == queue[1].size)
1146 return 1;
1147 if (queue[2].reloc && !memcmp (p, queue[2].reloc, size)
1148 && size == queue[2].size)
1149 return 2;
1150 if (queue[3].reloc && !memcmp (p, queue[3].reloc, size)
1151 && size == queue[3].size)
1152 return 3;
1153 return -1;
1154}
1155
1156static unsigned char *
1157try_prev_fixup (abfd, subspace_reloc_sizep, p, size, queue)
1158 bfd *abfd;
1159 int *subspace_reloc_sizep;
1160 unsigned char *p;
1161 unsigned int size;
1162 struct reloc_queue *queue;
1163{
1164 int queue_index = som_reloc_queue_find (p, size, queue);
1165
1166 if (queue_index != -1)
1167 {
1168 /* Found this in a previous fixup. Undo the fixup we
1169 just built and use R_PREV_FIXUP instead. We saved
1170 a total of size - 1 bytes in the fixup stream. */
1171 bfd_put_8 (abfd, R_PREV_FIXUP + queue_index, p);
1172 p += 1;
1173 *subspace_reloc_sizep += 1;
1174 som_reloc_queue_fix (queue, queue_index);
1175 }
1176 else
1177 {
1178 som_reloc_queue_insert (p, size, queue);
1179 *subspace_reloc_sizep += size;
1180 p += size;
1181 }
1182 return p;
1183}
1184
1185/* Emit the proper R_NO_RELOCATION fixups to map the next SKIP
1186 bytes without any relocation. Update the size of the subspace
1187 relocation stream via SUBSPACE_RELOC_SIZE_P; also return the
1188 current pointer into the relocation stream. */
1189
1190static unsigned char *
1191som_reloc_skip (abfd, skip, p, subspace_reloc_sizep, queue)
1192 bfd *abfd;
1193 unsigned int skip;
1194 unsigned char *p;
1195 unsigned int *subspace_reloc_sizep;
1196 struct reloc_queue *queue;
1197{
1198 /* Use a 4 byte R_NO_RELOCATION entry with a maximal value
1199 then R_PREV_FIXUPs to get the difference down to a
1200 reasonable size. */
1201 if (skip >= 0x1000000)
1202 {
1203 skip -= 0x1000000;
1204 bfd_put_8 (abfd, R_NO_RELOCATION + 31, p);
1205 bfd_put_8 (abfd, 0xff, p + 1);
1206 bfd_put_16 (abfd, 0xffff, p + 2);
1207 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue);
1208 while (skip >= 0x1000000)
1209 {
1210 skip -= 0x1000000;
1211 bfd_put_8 (abfd, R_PREV_FIXUP, p);
1212 p++;
1213 *subspace_reloc_sizep += 1;
1214 /* No need to adjust queue here since we are repeating the
1215 most recent fixup. */
1216 }
1217 }
1218
1219 /* The difference must be less than 0x1000000. Use one
1220 more R_NO_RELOCATION entry to get to the right difference. */
1221 if ((skip & 3) == 0 && skip <= 0xc0000 && skip > 0)
1222 {
1223 /* Difference can be handled in a simple single-byte
1224 R_NO_RELOCATION entry. */
1225 if (skip <= 0x60)
1226 {
1227 bfd_put_8 (abfd, R_NO_RELOCATION + (skip >> 2) - 1, p);
1228 *subspace_reloc_sizep += 1;
1229 p++;
1230 }
1231 /* Handle it with a two byte R_NO_RELOCATION entry. */
1232 else if (skip <= 0x1000)
1233 {
1234 bfd_put_8 (abfd, R_NO_RELOCATION + 24 + (((skip >> 2) - 1) >> 8), p);
1235 bfd_put_8 (abfd, (skip >> 2) - 1, p + 1);
1236 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue);
1237 }
1238 /* Handle it with a three byte R_NO_RELOCATION entry. */
1239 else
1240 {
1241 bfd_put_8 (abfd, R_NO_RELOCATION + 28 + (((skip >> 2) - 1) >> 16), p);
1242 bfd_put_16 (abfd, (skip >> 2) - 1, p + 1);
1243 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue);
1244 }
1245 }
1246 /* Ugh. Punt and use a 4 byte entry. */
1247 else if (skip > 0)
1248 {
1249 bfd_put_8 (abfd, R_NO_RELOCATION + 31, p);
1250 bfd_put_8 (abfd, (skip - 1) >> 16, p + 1);
1251 bfd_put_16 (abfd, skip - 1, p + 2);
1252 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue);
1253 }
1254 return p;
1255}
1256
1257/* Emit the proper R_DATA_OVERRIDE fixups to handle a nonzero addend
1258 from a BFD relocation. Update the size of the subspace relocation
1259 stream via SUBSPACE_RELOC_SIZE_P; also return the current pointer
1260 into the relocation stream. */
1261
1262static unsigned char *
1263som_reloc_addend (abfd, addend, p, subspace_reloc_sizep, queue)
1264 bfd *abfd;
1265 int addend;
1266 unsigned char *p;
1267 unsigned int *subspace_reloc_sizep;
1268 struct reloc_queue *queue;
1269{
1270 if ((unsigned)(addend) + 0x80 < 0x100)
1271 {
1272 bfd_put_8 (abfd, R_DATA_OVERRIDE + 1, p);
1273 bfd_put_8 (abfd, addend, p + 1);
1274 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue);
1275 }
1276 else if ((unsigned) (addend) + 0x8000 < 0x10000)
1277 {
1278 bfd_put_8 (abfd, R_DATA_OVERRIDE + 2, p);
1279 bfd_put_16 (abfd, addend, p + 1);
1280 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue);
1281 }
1282 else if ((unsigned) (addend) + 0x800000 < 0x1000000)
1283 {
1284 bfd_put_8 (abfd, R_DATA_OVERRIDE + 3, p);
1285 bfd_put_8 (abfd, addend >> 16, p + 1);
1286 bfd_put_16 (abfd, addend, p + 2);
1287 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue);
1288 }
1289 else
1290 {
1291 bfd_put_8 (abfd, R_DATA_OVERRIDE + 4, p);
1292 bfd_put_32 (abfd, addend, p + 1);
1293 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 5, queue);
1294 }
1295 return p;
1296}
1297
1298/* Handle a single function call relocation. */
1299
1300static unsigned char *
1301som_reloc_call (abfd, p, subspace_reloc_sizep, bfd_reloc, sym_num, queue)
1302 bfd *abfd;
1303 unsigned char *p;
1304 unsigned int *subspace_reloc_sizep;
1305 arelent *bfd_reloc;
1306 int sym_num;
1307 struct reloc_queue *queue;
1308{
1309 int arg_bits = HPPA_R_ARG_RELOC (bfd_reloc->addend);
1310 int rtn_bits = arg_bits & 0x3;
1311 int type, done = 0;
1312
1313 /* You'll never believe all this is necessary to handle relocations
1314 for function calls. Having to compute and pack the argument
1315 relocation bits is the real nightmare.
1316
1317 If you're interested in how this works, just forget it. You really
1318 do not want to know about this braindamage. */
1319
1320 /* First see if this can be done with a "simple" relocation. Simple
1321 relocations have a symbol number < 0x100 and have simple encodings
1322 of argument relocations. */
1323
1324 if (sym_num < 0x100)
1325 {
1326 switch (arg_bits)
1327 {
1328 case 0:
1329 case 1:
1330 type = 0;
1331 break;
1332 case 1 << 8:
1333 case 1 << 8 | 1:
1334 type = 1;
1335 break;
1336 case 1 << 8 | 1 << 6:
1337 case 1 << 8 | 1 << 6 | 1:
1338 type = 2;
1339 break;
1340 case 1 << 8 | 1 << 6 | 1 << 4:
1341 case 1 << 8 | 1 << 6 | 1 << 4 | 1:
1342 type = 3;
1343 break;
1344 case 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2:
1345 case 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2 | 1:
1346 type = 4;
1347 break;
1348 default:
1349 /* Not one of the easy encodings. This will have to be
1350 handled by the more complex code below. */
1351 type = -1;
1352 break;
1353 }
1354 if (type != -1)
1355 {
1356 /* Account for the return value too. */
1357 if (rtn_bits)
1358 type += 5;
1359
1360 /* Emit a 2 byte relocation. Then see if it can be handled
1361 with a relocation which is already in the relocation queue. */
1362 bfd_put_8 (abfd, bfd_reloc->howto->type + type, p);
1363 bfd_put_8 (abfd, sym_num, p + 1);
1364 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue);
1365 done = 1;
1366 }
1367 }
1368
1369 /* If this could not be handled with a simple relocation, then do a hard
1370 one. Hard relocations occur if the symbol number was too high or if
1371 the encoding of argument relocation bits is too complex. */
1372 if (! done)
1373 {
1374 /* Don't ask about these magic sequences. I took them straight
1375 from gas-1.36 which took them from the a.out man page. */
1376 type = rtn_bits;
1377 if ((arg_bits >> 6 & 0xf) == 0xe)
1378 type += 9 * 40;
1379 else
1380 type += (3 * (arg_bits >> 8 & 3) + (arg_bits >> 6 & 3)) * 40;
1381 if ((arg_bits >> 2 & 0xf) == 0xe)
1382 type += 9 * 4;
1383 else
1384 type += (3 * (arg_bits >> 4 & 3) + (arg_bits >> 2 & 3)) * 4;
1385
1386 /* Output the first two bytes of the relocation. These describe
1387 the length of the relocation and encoding style. */
1388 bfd_put_8 (abfd, bfd_reloc->howto->type + 10
1389 + 2 * (sym_num >= 0x100) + (type >= 0x100),
1390 p);
1391 bfd_put_8 (abfd, type, p + 1);
1392
1393 /* Now output the symbol index and see if this bizarre relocation
1394 just happened to be in the relocation queue. */
1395 if (sym_num < 0x100)
1396 {
1397 bfd_put_8 (abfd, sym_num, p + 2);
1398 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue);
1399 }
1400 else
1401 {
1402 bfd_put_8 (abfd, sym_num >> 16, p + 2);
1403 bfd_put_16 (abfd, sym_num, p + 3);
1404 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 5, queue);
1405 }
1406 }
1407 return p;
1408}
1409
1410
1411/* Return the logarithm of X, base 2, considering X unsigned.
1412 Abort -1 if X is not a power or two or is zero. */
1413
1414static int
1415log2 (x)
1416 unsigned int x;
1417{
1418 int log = 0;
1419
1420 /* Test for 0 or a power of 2. */
1421 if (x == 0 || x != (x & -x))
1422 return -1;
1423
1424 while ((x >>= 1) != 0)
1425 log++;
1426 return log;
1427}
1428
1429static bfd_reloc_status_type
1430hppa_som_reloc (abfd, reloc_entry, symbol_in, data,
1431 input_section, output_bfd, error_message)
1432 bfd *abfd;
1433 arelent *reloc_entry;
1434 asymbol *symbol_in;
1435 PTR data;
1436 asection *input_section;
1437 bfd *output_bfd;
1438 char **error_message;
1439{
1440 if (output_bfd)
1441 {
1442 reloc_entry->address += input_section->output_offset;
1443 return bfd_reloc_ok;
1444 }
1445 return bfd_reloc_ok;
1446}
1447
1448/* Given a generic HPPA relocation type, the instruction format,
1449 and a field selector, return one or more appropriate SOM relocations. */
1450
1451int **
1452hppa_som_gen_reloc_type (abfd, base_type, format, field, sym_diff, sym)
1453 bfd *abfd;
1454 int base_type;
1455 int format;
1456 enum hppa_reloc_field_selector_type_alt field;
1457 int sym_diff;
1458 asymbol *sym;
1459{
1460 int *final_type, **final_types;
1461
1462 final_types = (int **) bfd_alloc (abfd, sizeof (int *) * 6);
1463 final_type = (int *) bfd_alloc (abfd, sizeof (int));
1464 if (!final_types || !final_type)
1465 return NULL;
1466
1467 /* The field selector may require additional relocations to be
1468 generated. It's impossible to know at this moment if additional
1469 relocations will be needed, so we make them. The code to actually
1470 write the relocation/fixup stream is responsible for removing
1471 any redundant relocations. */
1472 switch (field)
1473 {
1474 case e_fsel:
1475 case e_psel:
1476 case e_lpsel:
1477 case e_rpsel:
1478 final_types[0] = final_type;
1479 final_types[1] = NULL;
1480 final_types[2] = NULL;
1481 *final_type = base_type;
1482 break;
1483
1484 case e_tsel:
1485 case e_ltsel:
1486 case e_rtsel:
1487 final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1488 if (!final_types[0])
1489 return NULL;
1490 if (field == e_tsel)
1491 *final_types[0] = R_FSEL;
1492 else if (field == e_ltsel)
1493 *final_types[0] = R_LSEL;
1494 else
1495 *final_types[0] = R_RSEL;
1496 final_types[1] = final_type;
1497 final_types[2] = NULL;
1498 *final_type = base_type;
1499 break;
1500
1501 case e_lssel:
1502 case e_rssel:
1503 final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1504 if (!final_types[0])
1505 return NULL;
1506 *final_types[0] = R_S_MODE;
1507 final_types[1] = final_type;
1508 final_types[2] = NULL;
1509 *final_type = base_type;
1510 break;
1511
1512 case e_lsel:
1513 case e_rsel:
1514 final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1515 if (!final_types[0])
1516 return NULL;
1517 *final_types[0] = R_N_MODE;
1518 final_types[1] = final_type;
1519 final_types[2] = NULL;
1520 *final_type = base_type;
1521 break;
1522
1523 case e_ldsel:
1524 case e_rdsel:
1525 final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1526 if (!final_types[0])
1527 return NULL;
1528 *final_types[0] = R_D_MODE;
1529 final_types[1] = final_type;
1530 final_types[2] = NULL;
1531 *final_type = base_type;
1532 break;
1533
1534 case e_lrsel:
1535 case e_rrsel:
1536 final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1537 if (!final_types[0])
1538 return NULL;
1539 *final_types[0] = R_R_MODE;
1540 final_types[1] = final_type;
1541 final_types[2] = NULL;
1542 *final_type = base_type;
1543 break;
1544
1545 case e_nsel:
1546 final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1547 if (!final_types[0])
1548 return NULL;
1549 *final_types[0] = R_N1SEL;
1550 final_types[1] = final_type;
1551 final_types[2] = NULL;
1552 *final_type = base_type;
1553 break;
1554
1555 case e_nlsel:
1556 case e_nlrsel:
1557 final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1558 if (!final_types[0])
1559 return NULL;
1560 *final_types[0] = R_N0SEL;
1561 final_types[1] = (int *) bfd_alloc (abfd, sizeof (int));
1562 if (!final_types[1])
1563 return NULL;
1564 if (field == e_nlsel)
1565 *final_types[1] = R_N_MODE;
1566 else
1567 *final_types[1] = R_R_MODE;
1568 final_types[2] = final_type;
1569 final_types[3] = NULL;
1570 *final_type = base_type;
1571 break;
1572 }
1573
1574 switch (base_type)
1575 {
1576 case R_HPPA:
1577 /* The difference of two symbols needs *very* special handling. */
1578 if (sym_diff)
1579 {
1580 final_types[0] = (int *)bfd_alloc (abfd, sizeof (int));
1581 final_types[1] = (int *)bfd_alloc (abfd, sizeof (int));
1582 final_types[2] = (int *)bfd_alloc (abfd, sizeof (int));
1583 final_types[3] = (int *)bfd_alloc (abfd, sizeof (int));
1584 if (!final_types[0] || !final_types[1] || !final_types[2])
1585 return NULL;
1586 if (field == e_fsel)
1587 *final_types[0] = R_FSEL;
1588 else if (field == e_rsel)
1589 *final_types[0] = R_RSEL;
1590 else if (field == e_lsel)
1591 *final_types[0] = R_LSEL;
1592 *final_types[1] = R_COMP2;
1593 *final_types[2] = R_COMP2;
1594 *final_types[3] = R_COMP1;
1595 final_types[4] = final_type;
1596 if (format == 32)
1597 *final_types[4] = R_DATA_EXPR;
1598 else
1599 *final_types[4] = R_CODE_EXPR;
1600 final_types[5] = NULL;
1601 break;
1602 }
1603 /* PLABELs get their own relocation type. */
1604 else if (field == e_psel
1605 || field == e_lpsel
1606 || field == e_rpsel)
1607 {
1608 /* A PLABEL relocation that has a size of 32 bits must
1609 be a R_DATA_PLABEL. All others are R_CODE_PLABELs. */
1610 if (format == 32)
1611 *final_type = R_DATA_PLABEL;
1612 else
1613 *final_type = R_CODE_PLABEL;
1614 }
1615 /* PIC stuff. */
1616 else if (field == e_tsel
1617 || field == e_ltsel
1618 || field == e_rtsel)
1619 *final_type = R_DLT_REL;
1620 /* A relocation in the data space is always a full 32bits. */
1621 else if (format == 32)
1622 {
1623 *final_type = R_DATA_ONE_SYMBOL;
1624
1625 /* If there's no SOM symbol type associated with this BFD
1626 symbol, then set the symbol type to ST_DATA.
1627
1628 Only do this if the type is going to default later when
1629 we write the object file.
1630
1631 This is done so that the linker never encounters an
1632 R_DATA_ONE_SYMBOL reloc involving an ST_CODE symbol.
1633
1634 This allows the compiler to generate exception handling
1635 tables.
1636
1637 Note that one day we may need to also emit BEGIN_BRTAB and
1638 END_BRTAB to prevent the linker from optimizing away insns
1639 in exception handling regions. */
1640 if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN
1641 && (sym->flags & BSF_SECTION_SYM) == 0
1642 && (sym->flags & BSF_FUNCTION) == 0
1643 && ! bfd_is_com_section (sym->section))
1644 som_symbol_data (sym)->som_type = SYMBOL_TYPE_DATA;
1645 }
1646 break;
1647
1648
1649 case R_HPPA_GOTOFF:
1650 /* More PLABEL special cases. */
1651 if (field == e_psel
1652 || field == e_lpsel
1653 || field == e_rpsel)
1654 *final_type = R_DATA_PLABEL;
1655 break;
1656
1657 case R_HPPA_COMPLEX:
1658 /* The difference of two symbols needs *very* special handling. */
1659 if (sym_diff)
1660 {
1661 final_types[0] = (int *)bfd_alloc (abfd, sizeof (int));
1662 final_types[1] = (int *)bfd_alloc (abfd, sizeof (int));
1663 final_types[2] = (int *)bfd_alloc (abfd, sizeof (int));
1664 final_types[3] = (int *)bfd_alloc (abfd, sizeof (int));
1665 if (!final_types[0] || !final_types[1] || !final_types[2])
1666 return NULL;
1667 if (field == e_fsel)
1668 *final_types[0] = R_FSEL;
1669 else if (field == e_rsel)
1670 *final_types[0] = R_RSEL;
1671 else if (field == e_lsel)
1672 *final_types[0] = R_LSEL;
1673 *final_types[1] = R_COMP2;
1674 *final_types[2] = R_COMP2;
1675 *final_types[3] = R_COMP1;
1676 final_types[4] = final_type;
1677 if (format == 32)
1678 *final_types[4] = R_DATA_EXPR;
1679 else
1680 *final_types[4] = R_CODE_EXPR;
1681 final_types[5] = NULL;
1682 break;
1683 }
1684 else
1685 break;
1686
1687 case R_HPPA_NONE:
1688 case R_HPPA_ABS_CALL:
252b5132
RH		 1689 /* Right now we can default all these. */
1690 break;
2667095f
JL		 1691
1692 case R_HPPA_PCREL_CALL:
1693 {
1694#ifndef NO_PCREL_MODES
1695 /* If we have short and long pcrel modes, then generate the proper
1696 mode selector, then the pcrel relocation. Redundant selectors
1697 will be eliminted as the relocs are sized and emitted. */
1698 final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1699 if (!final_types[0])
1700 return NULL;
1701 if (format == 17)
1702 *final_types[0] = R_SHORT_PCREL_MODE;
1703 else
1704 *final_types[0] = R_LONG_PCREL_MODE;
1705 final_types[1] = final_type;
1706 final_types[2] = NULL;
1707 *final_type = base_type;
1708#endif
1709 break;
1710 }
252b5132
RH		 1711 }
1712 return final_types;
1713}
1714
1715/* Return the address of the correct entry in the PA SOM relocation
1716 howto table. */
1717
1718/*ARGSUSED*/
1719static reloc_howto_type *
1720som_bfd_reloc_type_lookup (abfd, code)
1721 bfd *abfd;
1722 bfd_reloc_code_real_type code;
1723{
1724 if ((int) code < (int) R_NO_RELOCATION + 255)
1725 {
1726 BFD_ASSERT ((int) som_hppa_howto_table[(int) code].type == (int) code);
1727 return &som_hppa_howto_table[(int) code];
1728 }
1729
1730 return (reloc_howto_type *) 0;
1731}
1732
1733/* Perform some initialization for an object. Save results of this
1734 initialization in the BFD. */
1735
1736static const bfd_target *
1737som_object_setup (abfd, file_hdrp, aux_hdrp, current_offset)
1738 bfd *abfd;
1739 struct header *file_hdrp;
1740 struct som_exec_auxhdr *aux_hdrp;
1741 unsigned long current_offset;
1742{
1743 asection *section;
1744 int found;
1745
1746 /* som_mkobject will set bfd_error if som_mkobject fails. */
1747 if (som_mkobject (abfd) != true)
1748 return 0;
1749
1750 /* Set BFD flags based on what information is available in the SOM. */
1751 abfd->flags = BFD_NO_FLAGS;
1752 if (file_hdrp->symbol_total)
1753 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
1754
1755 switch (file_hdrp->a_magic)
1756 {
1757 case DEMAND_MAGIC:
1758 abfd->flags |= (D_PAGED | WP_TEXT | EXEC_P);
1759 break;
1760 case SHARE_MAGIC:
1761 abfd->flags |= (WP_TEXT | EXEC_P);
1762 break;
1763 case EXEC_MAGIC:
1764 abfd->flags |= (EXEC_P);
1765 break;
1766 case RELOC_MAGIC:
1767 abfd->flags |= HAS_RELOC;
1768 break;
1769#ifdef SHL_MAGIC
1770 case SHL_MAGIC:
1771#endif
1772#ifdef DL_MAGIC
1773 case DL_MAGIC:
1774#endif
1775 abfd->flags |= DYNAMIC;
1776 break;
1777
1778 default:
1779 break;
1780 }
1781
1782 /* Allocate space to hold the saved exec header information. */
1783 obj_som_exec_data (abfd) = (struct som_exec_data *)
1784 bfd_zalloc (abfd, sizeof (struct som_exec_data ));
1785 if (obj_som_exec_data (abfd) == NULL)
1786 return NULL;
1787
1788 /* The braindamaged OSF1 linker switched exec_flags and exec_entry!
1789
1790 We used to identify OSF1 binaries based on NEW_VERSION_ID, but
1791 apparently the latest HPUX linker is using NEW_VERSION_ID now.
1792
1793 It's about time, OSF has used the new id since at least 1992;
1794 HPUX didn't start till nearly 1995!.
1795
1796 The new approach examines the entry field. If it's zero or not 4
1797 byte aligned then it's not a proper code address and we guess it's
1798 really the executable flags. */
1799 found = 0;
1800 for (section = abfd->sections; section; section = section->next)
1801 {
1802 if ((section->flags & SEC_CODE) == 0)
1803 continue;
1804 if (aux_hdrp->exec_entry >= section->vma
1805 && aux_hdrp->exec_entry < section->vma + section->_cooked_size)
1806 found = 1;
1807 }
1808 if (aux_hdrp->exec_entry == 0
1809 || (aux_hdrp->exec_entry & 0x3) != 0
1810 || ! found)
1811 {
1812 bfd_get_start_address (abfd) = aux_hdrp->exec_flags;
1813 obj_som_exec_data (abfd)->exec_flags = aux_hdrp->exec_entry;
1814 }
1815 else
1816 {
1817 bfd_get_start_address (abfd) = aux_hdrp->exec_entry + current_offset;
1818 obj_som_exec_data (abfd)->exec_flags = aux_hdrp->exec_flags;
1819 }
1820
1821 bfd_default_set_arch_mach (abfd, bfd_arch_hppa, pa10);
1822 bfd_get_symcount (abfd) = file_hdrp->symbol_total;
1823
1824 /* Initialize the saved symbol table and string table to NULL.
1825 Save important offsets and sizes from the SOM header into
1826 the BFD. */
1827 obj_som_stringtab (abfd) = (char *) NULL;
1828 obj_som_symtab (abfd) = (som_symbol_type *) NULL;
1829 obj_som_sorted_syms (abfd) = NULL;
1830 obj_som_stringtab_size (abfd) = file_hdrp->symbol_strings_size;
1831 obj_som_sym_filepos (abfd) = file_hdrp->symbol_location + current_offset;
1832 obj_som_str_filepos (abfd) = (file_hdrp->symbol_strings_location
1833 + current_offset);
1834 obj_som_reloc_filepos (abfd) = (file_hdrp->fixup_request_location
1835 + current_offset);
1836 obj_som_exec_data (abfd)->system_id = file_hdrp->system_id;
1837
1838 return abfd->xvec;
1839}
1840
1841/* Convert all of the space and subspace info into BFD sections. Each space
1842 contains a number of subspaces, which in turn describe the mapping between
1843 regions of the exec file, and the address space that the program runs in.
1844 BFD sections which correspond to spaces will overlap the sections for the
1845 associated subspaces. */
1846
1847static boolean
1848setup_sections (abfd, file_hdr, current_offset)
1849 bfd *abfd;
1850 struct header *file_hdr;
1851 unsigned long current_offset;
1852{
1853 char *space_strings;
1854 unsigned int space_index, i;
1855 unsigned int total_subspaces = 0;
1856 asection **subspace_sections, *section;
1857
1858 /* First, read in space names */
1859
1860 space_strings = bfd_malloc (file_hdr->space_strings_size);
1861 if (!space_strings && file_hdr->space_strings_size != 0)
1862 goto error_return;
1863
1864 if (bfd_seek (abfd, current_offset + file_hdr->space_strings_location,
1865 SEEK_SET) < 0)
1866 goto error_return;
1867 if (bfd_read (space_strings, 1, file_hdr->space_strings_size, abfd)
1868 != file_hdr->space_strings_size)
1869 goto error_return;
1870
1871 /* Loop over all of the space dictionaries, building up sections */
1872 for (space_index = 0; space_index < file_hdr->space_total; space_index++)
1873 {
1874 struct space_dictionary_record space;
1875 struct subspace_dictionary_record subspace, save_subspace;
1876 int subspace_index;
1877 asection *space_asect;
1878 char *newname;
1879
1880 /* Read the space dictionary element */
1881 if (bfd_seek (abfd,
1882 (current_offset + file_hdr->space_location
1883 + space_index * sizeof space),
1884 SEEK_SET) < 0)
1885 goto error_return;
1886 if (bfd_read (&space, 1, sizeof space, abfd) != sizeof space)
1887 goto error_return;
1888
1889 /* Setup the space name string */
1890 space.name.n_name = space.name.n_strx + space_strings;
1891
1892 /* Make a section out of it */
1893 newname = bfd_alloc (abfd, strlen (space.name.n_name) + 1);
1894 if (!newname)
1895 goto error_return;
1896 strcpy (newname, space.name.n_name);
1897
1898 space_asect = bfd_make_section_anyway (abfd, newname);
1899 if (!space_asect)
1900 goto error_return;
1901
1902 if (space.is_loadable == 0)
1903 space_asect->flags |= SEC_DEBUGGING;
1904
1905 /* Set up all the attributes for the space. */
1906 if (bfd_som_set_section_attributes (space_asect, space.is_defined,
1907 space.is_private, space.sort_key,
1908 space.space_number) == false)
1909 goto error_return;
1910
1911 /* If the space has no subspaces, then we're done. */
1912 if (space.subspace_quantity == 0)
1913 continue;
1914
1915 /* Now, read in the first subspace for this space */
1916 if (bfd_seek (abfd,
1917 (current_offset + file_hdr->subspace_location
1918 + space.subspace_index * sizeof subspace),
1919 SEEK_SET) < 0)
1920 goto error_return;
1921 if (bfd_read (&subspace, 1, sizeof subspace, abfd) != sizeof subspace)
1922 goto error_return;
1923 /* Seek back to the start of the subspaces for loop below */
1924 if (bfd_seek (abfd,
1925 (current_offset + file_hdr->subspace_location
1926 + space.subspace_index * sizeof subspace),
1927 SEEK_SET) < 0)
1928 goto error_return;
1929
1930 /* Setup the start address and file loc from the first subspace record */
1931 space_asect->vma = subspace.subspace_start;
1932 space_asect->filepos = subspace.file_loc_init_value + current_offset;
1933 space_asect->alignment_power = log2 (subspace.alignment);
1934 if (space_asect->alignment_power == -1)
1935 goto error_return;
1936
1937 /* Initialize save_subspace so we can reliably determine if this
1938 loop placed any useful values into it. */
1939 memset (&save_subspace, 0, sizeof (struct subspace_dictionary_record));
1940
1941 /* Loop over the rest of the subspaces, building up more sections */
1942 for (subspace_index = 0; subspace_index < space.subspace_quantity;
1943 subspace_index++)
1944 {
1945 asection *subspace_asect;
1946
1947 /* Read in the next subspace */
1948 if (bfd_read (&subspace, 1, sizeof subspace, abfd)
1949 != sizeof subspace)
1950 goto error_return;
1951
1952 /* Setup the subspace name string */
1953 subspace.name.n_name = subspace.name.n_strx + space_strings;
1954
1955 newname = bfd_alloc (abfd, strlen (subspace.name.n_name) + 1);
1956 if (!newname)
1957 goto error_return;
1958 strcpy (newname, subspace.name.n_name);
1959
1960 /* Make a section out of this subspace */
1961 subspace_asect = bfd_make_section_anyway (abfd, newname);
1962 if (!subspace_asect)
1963 goto error_return;
1964
1965 /* Store private information about the section. */
1966 if (bfd_som_set_subsection_attributes (subspace_asect, space_asect,
1967 subspace.access_control_bits,
1968 subspace.sort_key,
1969 subspace.quadrant) == false)
1970 goto error_return;
1971
1972 /* Keep an easy mapping between subspaces and sections.
1973 Note we do not necessarily read the subspaces in the
1974 same order in which they appear in the object file.
1975
1976 So to make the target index come out correctly, we
1977 store the location of the subspace header in target
1978 index, then sort using the location of the subspace
1979 header as the key. Then we can assign correct
1980 subspace indices. */
1981 total_subspaces++;
1982 subspace_asect->target_index = bfd_tell (abfd) - sizeof (subspace);
1983
1984 /* Set SEC_READONLY and SEC_CODE/SEC_DATA as specified
1985 by the access_control_bits in the subspace header. */
1986 switch (subspace.access_control_bits >> 4)
1987 {
1988 /* Readonly data. */
1989 case 0x0:
1990 subspace_asect->flags |= SEC_DATA | SEC_READONLY;
1991 break;
1992
1993 /* Normal data. */
1994 case 0x1:
1995 subspace_asect->flags |= SEC_DATA;
1996 break;
1997
1998 /* Readonly code and the gateways.
1999 Gateways have other attributes which do not map
2000 into anything BFD knows about. */
2001 case 0x2:
2002 case 0x4:
2003 case 0x5:
2004 case 0x6:
2005 case 0x7:
2006 subspace_asect->flags |= SEC_CODE | SEC_READONLY;
2007 break;
2008
2009 /* dynamic (writable) code. */
2010 case 0x3:
2011 subspace_asect->flags |= SEC_CODE;
2012 break;
2013 }
2014
2015 if (subspace.dup_common || subspace.is_common)
2016 subspace_asect->flags |= SEC_IS_COMMON;
2017 else if (subspace.subspace_length > 0)
2018 subspace_asect->flags |= SEC_HAS_CONTENTS;
2019
2020 if (subspace.is_loadable)
2021 subspace_asect->flags |= SEC_ALLOC | SEC_LOAD;
2022 else
2023 subspace_asect->flags |= SEC_DEBUGGING;
2024
2025 if (subspace.code_only)
2026 subspace_asect->flags |= SEC_CODE;
2027
2028 /* Both file_loc_init_value and initialization_length will
2029 be zero for a BSS like subspace. */
2030 if (subspace.file_loc_init_value == 0
2031 && subspace.initialization_length == 0)
2032 subspace_asect->flags &= ~(SEC_DATA | SEC_LOAD | SEC_HAS_CONTENTS);
2033
2034 /* This subspace has relocations.
2035 The fixup_request_quantity is a byte count for the number of
2036 entries in the relocation stream; it is not the actual number
2037 of relocations in the subspace. */
2038 if (subspace.fixup_request_quantity != 0)
2039 {
2040 subspace_asect->flags |= SEC_RELOC;
2041 subspace_asect->rel_filepos = subspace.fixup_request_index;
2042 som_section_data (subspace_asect)->reloc_size
2043 = subspace.fixup_request_quantity;
2044 /* We can not determine this yet. When we read in the
2045 relocation table the correct value will be filled in. */
2046 subspace_asect->reloc_count = -1;
2047 }
2048
2049 /* Update save_subspace if appropriate. */
2050 if (subspace.file_loc_init_value > save_subspace.file_loc_init_value)
2051 save_subspace = subspace;
2052
2053 subspace_asect->vma = subspace.subspace_start;
2054 subspace_asect->_cooked_size = subspace.subspace_length;
2055 subspace_asect->_raw_size = subspace.subspace_length;
2056 subspace_asect->filepos = (subspace.file_loc_init_value
2057 + current_offset);
2058 subspace_asect->alignment_power = log2 (subspace.alignment);
2059 if (subspace_asect->alignment_power == -1)
2060 goto error_return;
2061 }
2062
2063 /* This can happen for a .o which defines symbols in otherwise
2064 empty subspaces. */
2065 if (!save_subspace.file_loc_init_value)
2066 {
2067 space_asect->_cooked_size = 0;
2068 space_asect->_raw_size = 0;
2069 }
2070 else
2071 {
2072 /* Setup the sizes for the space section based upon the info in the
2073 last subspace of the space. */
2074 space_asect->_cooked_size = (save_subspace.subspace_start
2075 - space_asect->vma
2076 + save_subspace.subspace_length);
2077 space_asect->_raw_size = (save_subspace.file_loc_init_value
2078 - space_asect->filepos
2079 + save_subspace.initialization_length);
2080 }
2081 }
2082 /* Now that we've read in all the subspace records, we need to assign
2083 a target index to each subspace. */
2084 subspace_sections = (asection **) bfd_malloc (total_subspaces
2085 * sizeof (asection *));
2086 if (subspace_sections == NULL)
2087 goto error_return;
2088
2089 for (i = 0, section = abfd->sections; section; section = section->next)
2090 {
2091 if (!som_is_subspace (section))
2092 continue;
2093
2094 subspace_sections[i] = section;
2095 i++;
2096 }
2097 qsort (subspace_sections, total_subspaces,
2098 sizeof (asection *), compare_subspaces);
2099
2100 /* subspace_sections is now sorted in the order in which the subspaces
2101 appear in the object file. Assign an index to each one now. */
2102 for (i = 0; i < total_subspaces; i++)
2103 subspace_sections[i]->target_index = i;
2104
2105 if (space_strings != NULL)
2106 free (space_strings);
2107
2108 if (subspace_sections != NULL)
2109 free (subspace_sections);
2110
2111 return true;
2112
2113 error_return:
2114 if (space_strings != NULL)
2115 free (space_strings);
2116
2117 if (subspace_sections != NULL)
2118 free (subspace_sections);
2119 return false;
2120}
2121
2122/* Read in a SOM object and make it into a BFD. */
2123
2124static const bfd_target *
2125som_object_p (abfd)
2126 bfd *abfd;
2127{
2128 struct header file_hdr;
2129 struct som_exec_auxhdr aux_hdr;
2130 unsigned long current_offset = 0;
2131 struct lst_header lst_header;
2132 struct som_entry som_entry;
2133#define ENTRY_SIZE sizeof(struct som_entry)
2134
2135 if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
2136 {
2137 if (bfd_get_error () != bfd_error_system_call)
2138 bfd_set_error (bfd_error_wrong_format);
2139 return 0;
2140 }
2141
2142 if (!_PA_RISC_ID (file_hdr.system_id))
2143 {
2144 bfd_set_error (bfd_error_wrong_format);
2145 return 0;
2146 }
2147
2148 switch (file_hdr.a_magic)
2149 {
2150 case RELOC_MAGIC:
2151 case EXEC_MAGIC:
2152 case SHARE_MAGIC:
2153 case DEMAND_MAGIC:
2154#ifdef DL_MAGIC
2155 case DL_MAGIC:
2156#endif
2157#ifdef SHL_MAGIC
2158 case SHL_MAGIC:
2159#endif
2160#ifdef SHARED_MAGIC_CNX
2161 case SHARED_MAGIC_CNX:
2162#endif
2163 break;
2164
2165#ifdef EXECLIBMAGIC
2166 case EXECLIBMAGIC:
2167 /* Read the lst header and determine where the SOM directory begins */
2168
2169 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) < 0)
2170 {
2171 if (bfd_get_error () != bfd_error_system_call)
2172 bfd_set_error (bfd_error_wrong_format);
2173 return 0;
2174 }
2175
2176 if (bfd_read ((PTR) & lst_header, 1, SLSTHDR, abfd) != SLSTHDR)
2177 {
2178 if (bfd_get_error () != bfd_error_system_call)
2179 bfd_set_error (bfd_error_wrong_format);
2180 return 0;
2181 }
2182
2183 /* Position to and read the first directory entry */
2184
2185 if (bfd_seek (abfd, lst_header.dir_loc, SEEK_SET) < 0)
2186 {
2187 if (bfd_get_error () != bfd_error_system_call)
2188 bfd_set_error (bfd_error_wrong_format);
2189 return 0;
2190 }
2191
2192 if (bfd_read ((PTR) & som_entry, 1, ENTRY_SIZE, abfd) != ENTRY_SIZE)
2193 {
2194 if (bfd_get_error () != bfd_error_system_call)
2195 bfd_set_error (bfd_error_wrong_format);
2196 return 0;
2197 }
2198
2199 /* Now position to the first SOM */
2200
2201 if (bfd_seek (abfd, som_entry.location, SEEK_SET) < 0)
2202 {
2203 if (bfd_get_error () != bfd_error_system_call)
2204 bfd_set_error (bfd_error_wrong_format);
2205 return 0;
2206 }
2207
2208 current_offset = som_entry.location;
2209
2210 /* And finally, re-read the som header */
2211
2212 if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
2213 {
2214 if (bfd_get_error () != bfd_error_system_call)
2215 bfd_set_error (bfd_error_wrong_format);
2216 return 0;
2217 }
2218
2219 break;
2220#endif
2221
2222 default:
2223 bfd_set_error (bfd_error_wrong_format);
2224 return 0;
2225 }
2226
2227 if (file_hdr.version_id != VERSION_ID
2228 && file_hdr.version_id != NEW_VERSION_ID)
2229 {
2230 bfd_set_error (bfd_error_wrong_format);
2231 return 0;
2232 }
2233
2234 /* If the aux_header_size field in the file header is zero, then this
2235 object is an incomplete executable (a .o file). Do not try to read
2236 a non-existant auxiliary header. */
2237 memset (&aux_hdr, 0, sizeof (struct som_exec_auxhdr));
2238 if (file_hdr.aux_header_size != 0)
2239 {
2240 if (bfd_read ((PTR) & aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
2241 {
2242 if (bfd_get_error () != bfd_error_system_call)
2243 bfd_set_error (bfd_error_wrong_format);
2244 return 0;
2245 }
2246 }
2247
2248 if (!setup_sections (abfd, &file_hdr, current_offset))
2249 {
2250 /* setup_sections does not bubble up a bfd error code. */
2251 bfd_set_error (bfd_error_bad_value);
2252 return 0;
2253 }
2254
2255 /* This appears to be a valid SOM object. Do some initialization. */
2256 return som_object_setup (abfd, &file_hdr, &aux_hdr, current_offset);
2257}
2258
2259/* Create a SOM object. */
2260
2261static boolean
2262som_mkobject (abfd)
2263 bfd *abfd;
2264{
2265 /* Allocate memory to hold backend information. */
2266 abfd->tdata.som_data = (struct som_data_struct *)
2267 bfd_zalloc (abfd, sizeof (struct som_data_struct));
2268 if (abfd->tdata.som_data == NULL)
2269 return false;
2270 return true;
2271}
2272
2273/* Initialize some information in the file header. This routine makes
2274 not attempt at doing the right thing for a full executable; it
2275 is only meant to handle relocatable objects. */
2276
2277static boolean
2278som_prep_headers (abfd)
2279 bfd *abfd;
2280{
2281 struct header *file_hdr;
2282 asection *section;
2283
2284 /* Make and attach a file header to the BFD. */
2285 file_hdr = (struct header *) bfd_zalloc (abfd, sizeof (struct header));
2286 if (file_hdr == NULL)
2287 return false;
2288 obj_som_file_hdr (abfd) = file_hdr;
2289
2290 if (abfd->flags & (EXEC_P | DYNAMIC))
2291 {
2292
2293 /* Make and attach an exec header to the BFD. */
2294 obj_som_exec_hdr (abfd) = (struct som_exec_auxhdr *)
2295 bfd_zalloc (abfd, sizeof (struct som_exec_auxhdr));
2296 if (obj_som_exec_hdr (abfd) == NULL)
2297 return false;
2298
2299 if (abfd->flags & D_PAGED)
2300 file_hdr->a_magic = DEMAND_MAGIC;
2301 else if (abfd->flags & WP_TEXT)
2302 file_hdr->a_magic = SHARE_MAGIC;
2303#ifdef SHL_MAGIC
2304 else if (abfd->flags & DYNAMIC)
2305 file_hdr->a_magic = SHL_MAGIC;
2306#endif
2307 else
2308 file_hdr->a_magic = EXEC_MAGIC;
2309 }
2310 else
2311 file_hdr->a_magic = RELOC_MAGIC;
2312
2313 /* Only new format SOM is supported. */
2314 file_hdr->version_id = NEW_VERSION_ID;
2315
2316 /* These fields are optional, and embedding timestamps is not always
2317 a wise thing to do, it makes comparing objects during a multi-stage
2318 bootstrap difficult. */
2319 file_hdr->file_time.secs = 0;
2320 file_hdr->file_time.nanosecs = 0;
2321
2322 file_hdr->entry_space = 0;
2323 file_hdr->entry_subspace = 0;
2324 file_hdr->entry_offset = 0;
2325 file_hdr->presumed_dp = 0;
2326
2327 /* Now iterate over the sections translating information from
2328 BFD sections to SOM spaces/subspaces. */
2329
2330 for (section = abfd->sections; section != NULL; section = section->next)
2331 {
2332 /* Ignore anything which has not been marked as a space or
2333 subspace. */
2334 if (!som_is_space (section) && !som_is_subspace (section))
2335 continue;
2336
2337 if (som_is_space (section))
2338 {
2339 /* Allocate space for the space dictionary. */
2340 som_section_data (section)->space_dict
2341 = (struct space_dictionary_record *)
2342 bfd_zalloc (abfd, sizeof (struct space_dictionary_record));
2343 if (som_section_data (section)->space_dict == NULL)
2344 return false;
2345 /* Set space attributes. Note most attributes of SOM spaces
2346 are set based on the subspaces it contains. */
2347 som_section_data (section)->space_dict->loader_fix_index = -1;
2348 som_section_data (section)->space_dict->init_pointer_index = -1;
2349
2350 /* Set more attributes that were stuffed away in private data. */
2351 som_section_data (section)->space_dict->sort_key =
2352 som_section_data (section)->copy_data->sort_key;
2353 som_section_data (section)->space_dict->is_defined =
2354 som_section_data (section)->copy_data->is_defined;
2355 som_section_data (section)->space_dict->is_private =
2356 som_section_data (section)->copy_data->is_private;
2357 som_section_data (section)->space_dict->space_number =
2358 som_section_data (section)->copy_data->space_number;
2359 }
2360 else
2361 {
2362 /* Allocate space for the subspace dictionary. */
2363 som_section_data (section)->subspace_dict
2364 = (struct subspace_dictionary_record *)
2365 bfd_zalloc (abfd, sizeof (struct subspace_dictionary_record));
2366 if (som_section_data (section)->subspace_dict == NULL)
2367 return false;
2368
2369 /* Set subspace attributes. Basic stuff is done here, additional
2370 attributes are filled in later as more information becomes
2371 available. */
2372 if (section->flags & SEC_IS_COMMON)
2373 {
2374 som_section_data (section)->subspace_dict->dup_common = 1;
2375 som_section_data (section)->subspace_dict->is_common = 1;
2376 }
2377
2378 if (section->flags & SEC_ALLOC)
2379 som_section_data (section)->subspace_dict->is_loadable = 1;
2380
2381 if (section->flags & SEC_CODE)
2382 som_section_data (section)->subspace_dict->code_only = 1;
2383
2384 som_section_data (section)->subspace_dict->subspace_start =
2385 section->vma;
2386 som_section_data (section)->subspace_dict->subspace_length =
2387 bfd_section_size (abfd, section);
2388 som_section_data (section)->subspace_dict->initialization_length =
2389 bfd_section_size (abfd, section);
2390 som_section_data (section)->subspace_dict->alignment =
2391 1 << section->alignment_power;
2392
2393 /* Set more attributes that were stuffed away in private data. */
2394 som_section_data (section)->subspace_dict->sort_key =
2395 som_section_data (section)->copy_data->sort_key;
2396 som_section_data (section)->subspace_dict->access_control_bits =
2397 som_section_data (section)->copy_data->access_control_bits;
2398 som_section_data (section)->subspace_dict->quadrant =
2399 som_section_data (section)->copy_data->quadrant;
2400 }
2401 }
2402 return true;
2403}
2404
2405/* Return true if the given section is a SOM space, false otherwise. */
2406
2407static boolean
2408som_is_space (section)
2409 asection *section;
2410{
2411 /* If no copy data is available, then it's neither a space nor a
2412 subspace. */
2413 if (som_section_data (section)->copy_data == NULL)
2414 return false;
2415
2416 /* If the containing space isn't the same as the given section,
2417 then this isn't a space. */
2418 if (som_section_data (section)->copy_data->container != section
2419 && (som_section_data (section)->copy_data->container->output_section
2420 != section))
2421 return false;
2422
2423 /* OK. Must be a space. */
2424 return true;
2425}
2426
2427/* Return true if the given section is a SOM subspace, false otherwise. */
2428
2429static boolean
2430som_is_subspace (section)
2431 asection *section;
2432{
2433 /* If no copy data is available, then it's neither a space nor a
2434 subspace. */
2435 if (som_section_data (section)->copy_data == NULL)
2436 return false;
2437
2438 /* If the containing space is the same as the given section,
2439 then this isn't a subspace. */
2440 if (som_section_data (section)->copy_data->container == section
2441 || (som_section_data (section)->copy_data->container->output_section
2442 == section))
2443 return false;
2444
2445 /* OK. Must be a subspace. */
2446 return true;
2447}
2448
2449/* Return true if the given space containins the given subspace. It
2450 is safe to assume space really is a space, and subspace really
2451 is a subspace. */
2452
2453static boolean
2454som_is_container (space, subspace)
2455 asection *space, *subspace;
2456{
2457 return (som_section_data (subspace)->copy_data->container == space
2458 || (som_section_data (subspace)->copy_data->container->output_section
2459 == space));
2460}
2461
2462/* Count and return the number of spaces attached to the given BFD. */
2463
2464static unsigned long
2465som_count_spaces (abfd)
2466 bfd *abfd;
2467{
2468 int count = 0;
2469 asection *section;
2470
2471 for (section = abfd->sections; section != NULL; section = section->next)
2472 count += som_is_space (section);
2473
2474 return count;
2475}
2476
2477/* Count the number of subspaces attached to the given BFD. */
2478
2479static unsigned long
2480som_count_subspaces (abfd)
2481 bfd *abfd;
2482{
2483 int count = 0;
2484 asection *section;
2485
2486 for (section = abfd->sections; section != NULL; section = section->next)
2487 count += som_is_subspace (section);
2488
2489 return count;
2490}
2491
2492/* Return -1, 0, 1 indicating the relative ordering of sym1 and sym2.
2493
2494 We desire symbols to be ordered starting with the symbol with the
2495 highest relocation count down to the symbol with the lowest relocation
2496 count. Doing so compacts the relocation stream. */
2497
2498static int
2499compare_syms (arg1, arg2)
2500 const PTR arg1;
2501 const PTR arg2;
2502
2503{
2504 asymbol **sym1 = (asymbol **) arg1;
2505 asymbol **sym2 = (asymbol **) arg2;
2506 unsigned int count1, count2;
2507
2508 /* Get relocation count for each symbol. Note that the count
2509 is stored in the udata pointer for section symbols! */
2510 if ((*sym1)->flags & BSF_SECTION_SYM)
2511 count1 = (*sym1)->udata.i;
2512 else
2513 count1 = som_symbol_data (*sym1)->reloc_count;
2514
2515 if ((*sym2)->flags & BSF_SECTION_SYM)
2516 count2 = (*sym2)->udata.i;
2517 else
2518 count2 = som_symbol_data (*sym2)->reloc_count;
2519
2520 /* Return the appropriate value. */
2521 if (count1 < count2)
2522 return 1;
2523 else if (count1 > count2)
2524 return -1;
2525 return 0;
2526}
2527
2528/* Return -1, 0, 1 indicating the relative ordering of subspace1
2529 and subspace. */
2530
2531static int
2532compare_subspaces (arg1, arg2)
2533 const PTR arg1;
2534 const PTR arg2;
2535
2536{
2537 asection **subspace1 = (asection **) arg1;
2538 asection **subspace2 = (asection **) arg2;
2539 unsigned int count1, count2;
2540
2541 if ((*subspace1)->target_index < (*subspace2)->target_index)
2542 return -1;
2543 else if ((*subspace2)->target_index < (*subspace1)->target_index)
2544 return 1;
2545 else
2546 return 0;
2547}
2548
2549/* Perform various work in preparation for emitting the fixup stream. */
2550
2551static void
2552som_prep_for_fixups (abfd, syms, num_syms)
2553 bfd *abfd;
2554 asymbol **syms;
2555 unsigned long num_syms;
2556{
2557 int i;
2558 asection *section;
2559 asymbol **sorted_syms;
2560
2561 /* Most SOM relocations involving a symbol have a length which is
2562 dependent on the index of the symbol. So symbols which are
2563 used often in relocations should have a small index. */
2564
2565 /* First initialize the counters for each symbol. */
2566 for (i = 0; i < num_syms; i++)
2567 {
2568 /* Handle a section symbol; these have no pointers back to the
2569 SOM symbol info. So we just use the udata field to hold the
2570 relocation count. */
2571 if (som_symbol_data (syms[i]) == NULL
2572 || syms[i]->flags & BSF_SECTION_SYM)
2573 {
2574 syms[i]->flags |= BSF_SECTION_SYM;
2575 syms[i]->udata.i = 0;
2576 }
2577 else
2578 som_symbol_data (syms[i])->reloc_count = 0;
2579 }
2580
2581 /* Now that the counters are initialized, make a weighted count
2582 of how often a given symbol is used in a relocation. */
2583 for (section = abfd->sections; section != NULL; section = section->next)
2584 {
2585 int i;
2586
2587 /* Does this section have any relocations? */
2588 if (section->reloc_count <= 0)
2589 continue;
2590
2591 /* Walk through each relocation for this section. */
2592 for (i = 1; i < section->reloc_count; i++)
2593 {
2594 arelent *reloc = section->orelocation[i];
2595 int scale;
2596
2597 /* A relocation against a symbol in the *ABS* section really
2598 does not have a symbol. Likewise if the symbol isn't associated
2599 with any section. */
2600 if (reloc->sym_ptr_ptr == NULL
2601 || bfd_is_abs_section ((*reloc->sym_ptr_ptr)->section))
2602 continue;
2603
2604 /* Scaling to encourage symbols involved in R_DP_RELATIVE
2605 and R_CODE_ONE_SYMBOL relocations to come first. These
2606 two relocations have single byte versions if the symbol
2607 index is very small. */
2608 if (reloc->howto->type == R_DP_RELATIVE
2609 || reloc->howto->type == R_CODE_ONE_SYMBOL)
2610 scale = 2;
2611 else
2612 scale = 1;
2613
2614 /* Handle section symbols by storing the count in the udata
2615 field. It will not be used and the count is very important
2616 for these symbols. */
2617 if ((*reloc->sym_ptr_ptr)->flags & BSF_SECTION_SYM)
2618 {
2619 (*reloc->sym_ptr_ptr)->udata.i =
2620 (*reloc->sym_ptr_ptr)->udata.i + scale;
2621 continue;
2622 }
2623
2624 /* A normal symbol. Increment the count. */
2625 som_symbol_data (*reloc->sym_ptr_ptr)->reloc_count += scale;
2626 }
2627 }
2628
2629 /* Sort a copy of the symbol table, rather than the canonical
2630 output symbol table. */
2631 sorted_syms = (asymbol **) bfd_zalloc (abfd, num_syms * sizeof (asymbol *));
2632 memcpy (sorted_syms, syms, num_syms * sizeof (asymbol *));
2633 qsort (sorted_syms, num_syms, sizeof (asymbol *), compare_syms);
2634 obj_som_sorted_syms (abfd) = sorted_syms;
2635
2636 /* Compute the symbol indexes, they will be needed by the relocation
2637 code. */
2638 for (i = 0; i < num_syms; i++)
2639 {
2640 /* A section symbol. Again, there is no pointer to backend symbol
2641 information, so we reuse the udata field again. */
2642 if (sorted_syms[i]->flags & BSF_SECTION_SYM)
2643 sorted_syms[i]->udata.i = i;
2644 else
2645 som_symbol_data (sorted_syms[i])->index = i;
2646 }
2647}
2648
2649static boolean
2650som_write_fixups (abfd, current_offset, total_reloc_sizep)
2651 bfd *abfd;
2652 unsigned long current_offset;
2653 unsigned int *total_reloc_sizep;
2654{
2655 unsigned int i, j;
2656 /* Chunk of memory that we can use as buffer space, then throw
2657 away. */
2658 unsigned char tmp_space[SOM_TMP_BUFSIZE];
2659 unsigned char *p;
2660 unsigned int total_reloc_size = 0;
2661 unsigned int subspace_reloc_size = 0;
2662 unsigned int num_spaces = obj_som_file_hdr (abfd)->space_total;
2663 asection *section = abfd->sections;
2664
2665 memset (tmp_space, 0, SOM_TMP_BUFSIZE);
2666 p = tmp_space;
2667
2668 /* All the fixups for a particular subspace are emitted in a single
2669 stream. All the subspaces for a particular space are emitted
2670 as a single stream.
2671
2672 So, to get all the locations correct one must iterate through all the
2673 spaces, for each space iterate through its subspaces and output a
2674 fixups stream. */
2675 for (i = 0; i < num_spaces; i++)
2676 {
2677 asection *subsection;
2678
2679 /* Find a space. */
2680 while (!som_is_space (section))
2681 section = section->next;
2682
2683 /* Now iterate through each of its subspaces. */
2684 for (subsection = abfd->sections;
2685 subsection != NULL;
2686 subsection = subsection->next)
2687 {
2688 int reloc_offset, current_rounding_mode;
2667095f
JL		 2689#ifndef NO_PCREL_MODES
2690 int current_call_mode;
2691#endif
252b5132
RH		 2692
2693 /* Find a subspace of this space. */
2694 if (!som_is_subspace (subsection)
2695 || !som_is_container (section, subsection))
2696 continue;
2697
2698 /* If this subspace does not have real data, then we are
2699 finised with it. */
2700 if ((subsection->flags & SEC_HAS_CONTENTS) == 0)
2701 {
2702 som_section_data (subsection)->subspace_dict->fixup_request_index
2703 = -1;
2704 continue;
2705 }
2706
2707 /* This subspace has some relocations. Put the relocation stream
2708 index into the subspace record. */
2709 som_section_data (subsection)->subspace_dict->fixup_request_index
2710 = total_reloc_size;
2711
2712 /* To make life easier start over with a clean slate for
2713 each subspace. Seek to the start of the relocation stream
2714 for this subspace in preparation for writing out its fixup
2715 stream. */
2716 if (bfd_seek (abfd, current_offset + total_reloc_size, SEEK_SET) < 0)
2717 return false;
2718
2719 /* Buffer space has already been allocated. Just perform some
2720 initialization here. */
2721 p = tmp_space;
2722 subspace_reloc_size = 0;
2723 reloc_offset = 0;
2724 som_initialize_reloc_queue (reloc_queue);
2725 current_rounding_mode = R_N_MODE;
2667095f
JL		 2726#ifndef NO_PCREL_MODES
2727 current_call_mode = R_SHORT_PCREL_MODE;
2728#endif
252b5132
RH		 2729
2730 /* Translate each BFD relocation into one or more SOM
2731 relocations. */
2732 for (j = 0; j < subsection->reloc_count; j++)
2733 {
2734 arelent *bfd_reloc = subsection->orelocation[j];
2735 unsigned int skip;
2736 int sym_num;
2737
2738 /* Get the symbol number. Remember it's stored in a
2739 special place for section symbols. */
2740 if ((*bfd_reloc->sym_ptr_ptr)->flags & BSF_SECTION_SYM)
2741 sym_num = (*bfd_reloc->sym_ptr_ptr)->udata.i;
2742 else
2743 sym_num = som_symbol_data (*bfd_reloc->sym_ptr_ptr)->index;
2744
2745 /* If there is not enough room for the next couple relocations,
2746 then dump the current buffer contents now. Also reinitialize
2747 the relocation queue.
2748
2749 No single BFD relocation could ever translate into more
2750 than 100 bytes of SOM relocations (20bytes is probably the
2751 upper limit, but leave lots of space for growth). */
2752 if (p - tmp_space + 100 > SOM_TMP_BUFSIZE)
2753 {
2754 if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
2755 != p - tmp_space)
2756 return false;
2757
2758 p = tmp_space;
2759 som_initialize_reloc_queue (reloc_queue);
2760 }
2761
2762 /* Emit R_NO_RELOCATION fixups to map any bytes which were
2763 skipped. */
2764 skip = bfd_reloc->address - reloc_offset;
2765 p = som_reloc_skip (abfd, skip, p,
2766 &subspace_reloc_size, reloc_queue);
2767
2768 /* Update reloc_offset for the next iteration.
2769
2770 Many relocations do not consume input bytes. They
2771 are markers, or set state necessary to perform some
2772 later relocation. */
2773 switch (bfd_reloc->howto->type)
2774 {
2775 case R_ENTRY:
2776 case R_ALT_ENTRY:
2777 case R_EXIT:
2778 case R_N_MODE:
2779 case R_S_MODE:
2780 case R_D_MODE:
2781 case R_R_MODE:
2782 case R_FSEL:
2783 case R_LSEL:
2784 case R_RSEL:
2785 case R_COMP1:
2786 case R_COMP2:
2787 case R_BEGIN_BRTAB:
2788 case R_END_BRTAB:
2789 case R_BEGIN_TRY:
2790 case R_END_TRY:
2791 case R_N0SEL:
2792 case R_N1SEL:
2667095f
JL		 2793#ifndef NO_PCREL_MODES
2794 case R_SHORT_PCREL_MODE:
2795 case R_LONG_PCREL_MODE:
2796#endif
252b5132
RH		 2797 reloc_offset = bfd_reloc->address;
2798 break;
2799
2800 default:
2801 reloc_offset = bfd_reloc->address + 4;
2802 break;
2803 }
2804
2805 /* Now the actual relocation we care about. */
2806 switch (bfd_reloc->howto->type)
2807 {
2808 case R_PCREL_CALL:
2809 case R_ABS_CALL:
2810 p = som_reloc_call (abfd, p, &subspace_reloc_size,
2811 bfd_reloc, sym_num, reloc_queue);
2812 break;
2813
2814 case R_CODE_ONE_SYMBOL:
2815 case R_DP_RELATIVE:
2816 /* Account for any addend. */
2817 if (bfd_reloc->addend)
2818 p = som_reloc_addend (abfd, bfd_reloc->addend, p,
2819 &subspace_reloc_size, reloc_queue);
2820
2821 if (sym_num < 0x20)
2822 {
2823 bfd_put_8 (abfd, bfd_reloc->howto->type + sym_num, p);
2824 subspace_reloc_size += 1;
2825 p += 1;
2826 }
2827 else if (sym_num < 0x100)
2828 {
2829 bfd_put_8 (abfd, bfd_reloc->howto->type + 32, p);
2830 bfd_put_8 (abfd, sym_num, p + 1);
2831 p = try_prev_fixup (abfd, &subspace_reloc_size, p,
2832 2, reloc_queue);
2833 }
2834 else if (sym_num < 0x10000000)
2835 {
2836 bfd_put_8 (abfd, bfd_reloc->howto->type + 33, p);
2837 bfd_put_8 (abfd, sym_num >> 16, p + 1);
2838 bfd_put_16 (abfd, sym_num, p + 2);
2839 p = try_prev_fixup (abfd, &subspace_reloc_size,
2840 p, 4, reloc_queue);
2841 }
2842 else
2843 abort ();
2844 break;
2845
2846 case R_DATA_ONE_SYMBOL:
2847 case R_DATA_PLABEL:
2848 case R_CODE_PLABEL:
2849 case R_DLT_REL:
2850 /* Account for any addend using R_DATA_OVERRIDE. */
2851 if (bfd_reloc->howto->type != R_DATA_ONE_SYMBOL
2852 && bfd_reloc->addend)
2853 p = som_reloc_addend (abfd, bfd_reloc->addend, p,
2854 &subspace_reloc_size, reloc_queue);
2855
2856 if (sym_num < 0x100)
2857 {
2858 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2859 bfd_put_8 (abfd, sym_num, p + 1);
2860 p = try_prev_fixup (abfd, &subspace_reloc_size, p,
2861 2, reloc_queue);
2862 }
2863 else if (sym_num < 0x10000000)
2864 {
2865 bfd_put_8 (abfd, bfd_reloc->howto->type + 1, p);
2866 bfd_put_8 (abfd, sym_num >> 16, p + 1);
2867 bfd_put_16 (abfd, sym_num, p + 2);
2868 p = try_prev_fixup (abfd, &subspace_reloc_size,
2869 p, 4, reloc_queue);
2870 }
2871 else
2872 abort ();
2873 break;
2874
2875 case R_ENTRY:
2876 {
2877 int tmp;
2878 arelent *tmp_reloc = NULL;
2879 bfd_put_8 (abfd, R_ENTRY, p);
2880
2881 /* R_ENTRY relocations have 64 bits of associated
2882 data. Unfortunately the addend field of a bfd
2883 relocation is only 32 bits. So, we split up
2884 the 64bit unwind information and store part in
2885 the R_ENTRY relocation, and the rest in the R_EXIT
2886 relocation. */
2887 bfd_put_32 (abfd, bfd_reloc->addend, p + 1);
2888
2889 /* Find the next R_EXIT relocation. */
2890 for (tmp = j; tmp < subsection->reloc_count; tmp++)
2891 {
2892 tmp_reloc = subsection->orelocation[tmp];
2893 if (tmp_reloc->howto->type == R_EXIT)
2894 break;
2895 }
2896
2897 if (tmp == subsection->reloc_count)
2898 abort ();
2899
2900 bfd_put_32 (abfd, tmp_reloc->addend, p + 5);
2901 p = try_prev_fixup (abfd, &subspace_reloc_size,
2902 p, 9, reloc_queue);
2903 break;
2904 }
2905
2906 case R_N_MODE:
2907 case R_S_MODE:
2908 case R_D_MODE:
2909 case R_R_MODE:
2910 /* If this relocation requests the current rounding
2911 mode, then it is redundant. */
2912 if (bfd_reloc->howto->type != current_rounding_mode)
2913 {
2914 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2915 subspace_reloc_size += 1;
2916 p += 1;
2917 current_rounding_mode = bfd_reloc->howto->type;
2918 }
2919 break;
2920
2667095f
JL		 2921#ifndef NO_PCREL_MODES
2922 case R_LONG_PCREL_MODE:
2923 case R_SHORT_PCREL_MODE:
2924 if (bfd_reloc->howto->type != current_call_mode)
2925 {
2926 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2927 subspace_reloc_size += 1;
2928 p += 1;
2929 current_call_mode = bfd_reloc->howto->type;
2930 }
2931 break;
2932#endif
2933
252b5132
RH		 2934 case R_EXIT:
2935 case R_ALT_ENTRY:
2936 case R_FSEL:
2937 case R_LSEL:
2938 case R_RSEL:
2939 case R_BEGIN_BRTAB:
2940 case R_END_BRTAB:
2941 case R_BEGIN_TRY:
2942 case R_N0SEL:
2943 case R_N1SEL:
2944 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2945 subspace_reloc_size += 1;
2946 p += 1;
2947 break;
2948
2949 case R_END_TRY:
2950 /* The end of a exception handling region. The reloc's
2951 addend contains the offset of the exception handling
2952 code. */
2953 if (bfd_reloc->addend == 0)
2954 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2955 else if (bfd_reloc->addend < 1024)
2956 {
2957 bfd_put_8 (abfd, bfd_reloc->howto->type + 1, p);
2958 bfd_put_8 (abfd, bfd_reloc->addend / 4, p + 1);
2959 p = try_prev_fixup (abfd, &subspace_reloc_size,
2960 p, 2, reloc_queue);
2961 }
2962 else
2963 {
2964 bfd_put_8 (abfd, bfd_reloc->howto->type + 2, p);
2965 bfd_put_8 (abfd, (bfd_reloc->addend / 4) >> 16, p + 1);
2966 bfd_put_16 (abfd, bfd_reloc->addend / 4, p + 2);
2967 p = try_prev_fixup (abfd, &subspace_reloc_size,
2968 p, 4, reloc_queue);
2969 }
2970 break;
2971
2972 case R_COMP1:
2973 /* The only time we generate R_COMP1, R_COMP2 and
2974 R_CODE_EXPR relocs is for the difference of two
2975 symbols. Hence we can cheat here. */
2976 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2977 bfd_put_8 (abfd, 0x44, p + 1);
2978 p = try_prev_fixup (abfd, &subspace_reloc_size,
2979 p, 2, reloc_queue);
2980 break;
2981
2982 case R_COMP2:
2983 /* The only time we generate R_COMP1, R_COMP2 and
2984 R_CODE_EXPR relocs is for the difference of two
2985 symbols. Hence we can cheat here. */
2986 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2987 bfd_put_8 (abfd, 0x80, p + 1);
2988 bfd_put_8 (abfd, sym_num >> 16, p + 2);
2989 bfd_put_16 (abfd, sym_num, p + 3);
2990 p = try_prev_fixup (abfd, &subspace_reloc_size,
2991 p, 5, reloc_queue);
2992 break;
2993
2994 case R_CODE_EXPR:
2995 case R_DATA_EXPR:
2996 /* The only time we generate R_COMP1, R_COMP2 and
2997 R_CODE_EXPR relocs is for the difference of two
2998 symbols. Hence we can cheat here. */
2999 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
3000 subspace_reloc_size += 1;
3001 p += 1;
3002 break;
3003
3004 /* Put a "R_RESERVED" relocation in the stream if
3005 we hit something we do not understand. The linker
3006 will complain loudly if this ever happens. */
3007 default:
3008 bfd_put_8 (abfd, 0xff, p);
3009 subspace_reloc_size += 1;
3010 p += 1;
3011 break;
3012 }
3013 }
3014
3015 /* Last BFD relocation for a subspace has been processed.
3016 Map the rest of the subspace with R_NO_RELOCATION fixups. */
3017 p = som_reloc_skip (abfd, bfd_section_size (abfd, subsection)
3018 - reloc_offset,
3019 p, &subspace_reloc_size, reloc_queue);
3020
3021 /* Scribble out the relocations. */
3022 if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
3023 != p - tmp_space)
3024 return false;
3025 p = tmp_space;
3026
3027 total_reloc_size += subspace_reloc_size;
3028 som_section_data (subsection)->subspace_dict->fixup_request_quantity
3029 = subspace_reloc_size;
3030 }
3031 section = section->next;
3032 }
3033 *total_reloc_sizep = total_reloc_size;
3034 return true;
3035}
3036
3037/* Write out the space/subspace string table. */
3038
3039static boolean
3040som_write_space_strings (abfd, current_offset, string_sizep)
3041 bfd *abfd;
3042 unsigned long current_offset;
3043 unsigned int *string_sizep;
3044{
3045 /* Chunk of memory that we can use as buffer space, then throw
3046 away. */
3047 unsigned char tmp_space[SOM_TMP_BUFSIZE];
3048 unsigned char *p;
3049 unsigned int strings_size = 0;
3050 asection *section;
3051
3052 memset (tmp_space, 0, SOM_TMP_BUFSIZE);
3053 p = tmp_space;
3054
3055 /* Seek to the start of the space strings in preparation for writing
3056 them out. */
3057 if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
3058 return false;
3059
3060 /* Walk through all the spaces and subspaces (order is not important)
3061 building up and writing string table entries for their names. */
3062 for (section = abfd->sections; section != NULL; section = section->next)
3063 {
3064 int length;
3065
3066 /* Only work with space/subspaces; avoid any other sections
3067 which might have been made (.text for example). */
3068 if (!som_is_space (section) && !som_is_subspace (section))
3069 continue;
3070
3071 /* Get the length of the space/subspace name. */
3072 length = strlen (section->name);
3073
3074 /* If there is not enough room for the next entry, then dump the
3075 current buffer contents now. Each entry will take 4 bytes to
3076 hold the string length + the string itself + null terminator. */
3077 if (p - tmp_space + 5 + length > SOM_TMP_BUFSIZE)
3078 {
3079 if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
3080 != p - tmp_space)
3081 return false;
3082 /* Reset to beginning of the buffer space. */
3083 p = tmp_space;
3084 }
3085
3086 /* First element in a string table entry is the length of the
3087 string. Alignment issues are already handled. */
3088 bfd_put_32 (abfd, length, p);
3089 p += 4;
3090 strings_size += 4;
3091
3092 /* Record the index in the space/subspace records. */
3093 if (som_is_space (section))
3094 som_section_data (section)->space_dict->name.n_strx = strings_size;
3095 else
3096 som_section_data (section)->subspace_dict->name.n_strx = strings_size;
3097
3098 /* Next comes the string itself + a null terminator. */
3099 strcpy (p, section->name);
3100 p += length + 1;
3101 strings_size += length + 1;
3102
3103 /* Always align up to the next word boundary. */
3104 while (strings_size % 4)
3105 {
3106 bfd_put_8 (abfd, 0, p);
3107 p++;
3108 strings_size++;
3109 }
3110 }
3111
3112 /* Done with the space/subspace strings. Write out any information
3113 contained in a partial block. */
3114 if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
3115 return false;
3116 *string_sizep = strings_size;
3117 return true;
3118}
3119
3120/* Write out the symbol string table. */
3121
3122static boolean
3123som_write_symbol_strings (abfd, current_offset, syms, num_syms, string_sizep,
3124 compilation_unit)
3125 bfd *abfd;
3126 unsigned long current_offset;
3127 asymbol **syms;
3128 unsigned int num_syms;
3129 unsigned int *string_sizep;
3130 COMPUNIT *compilation_unit;
3131{
3132 unsigned int i;
3133
3134 /* Chunk of memory that we can use as buffer space, then throw
3135 away. */
3136 unsigned char tmp_space[SOM_TMP_BUFSIZE];
3137 unsigned char *p;
3138 unsigned int strings_size = 0;
3139 unsigned char *comp[4];
3140
3141 /* This gets a bit gruesome because of the compilation unit. The
3142 strings within the compilation unit are part of the symbol
3143 strings, but don't have symbol_dictionary entries. So, manually
3144 write them and update the compliation unit header. On input, the
3145 compilation unit header contains local copies of the strings.
3146 Move them aside. */
3147 if (compilation_unit)
3148 {
3149 comp[0] = compilation_unit->name.n_name;
3150 comp[1] = compilation_unit->language_name.n_name;
3151 comp[2] = compilation_unit->product_id.n_name;
3152 comp[3] = compilation_unit->version_id.n_name;
3153 }
3154
3155 memset (tmp_space, 0, SOM_TMP_BUFSIZE);
3156 p = tmp_space;
3157
3158 /* Seek to the start of the space strings in preparation for writing
3159 them out. */
3160 if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
3161 return false;
3162
3163 if (compilation_unit)
3164 {
3165 for (i = 0; i < 4; i++)
3166 {
3167 int length = strlen (comp[i]);
3168
3169 /* If there is not enough room for the next entry, then dump
3170 the current buffer contents now. */
3171 if (p - tmp_space + 5 + length > SOM_TMP_BUFSIZE)
3172 {
3173 if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
3174 != p - tmp_space)
3175 return false;
3176 /* Reset to beginning of the buffer space. */
3177 p = tmp_space;
3178 }
3179
3180 /* First element in a string table entry is the length of
3181 the string. This must always be 4 byte aligned. This is
3182 also an appropriate time to fill in the string index
3183 field in the symbol table entry. */
3184 bfd_put_32 (abfd, length, p);
3185 strings_size += 4;
3186 p += 4;
3187
3188 /* Next comes the string itself + a null terminator. */
3189 strcpy (p, comp[i]);
3190
3191 switch (i)
3192 {
3193 case 0:
3194 obj_som_compilation_unit (abfd)->name.n_strx = strings_size;
3195 break;
3196 case 1:
3197 obj_som_compilation_unit (abfd)->language_name.n_strx =
3198 strings_size;
3199 break;
3200 case 2:
3201 obj_som_compilation_unit (abfd)->product_id.n_strx =
3202 strings_size;
3203 break;
3204 case 3:
3205 obj_som_compilation_unit (abfd)->version_id.n_strx =
3206 strings_size;
3207 break;
3208 }
3209
3210 p += length + 1;
3211 strings_size += length + 1;
3212
3213 /* Always align up to the next word boundary. */
3214 while (strings_size % 4)
3215 {
3216 bfd_put_8 (abfd, 0, p);
3217 strings_size++;
3218 p++;
3219 }
3220 }
3221 }
3222
3223 for (i = 0; i < num_syms; i++)
3224 {
3225 int length = strlen (syms[i]->name);
3226
3227 /* If there is not enough room for the next entry, then dump the
3228 current buffer contents now. */
3229 if (p - tmp_space + 5 + length > SOM_TMP_BUFSIZE)
3230 {
3231 if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
3232 != p - tmp_space)
3233 return false;
3234 /* Reset to beginning of the buffer space. */
3235 p = tmp_space;
3236 }
3237
3238 /* First element in a string table entry is the length of the
3239 string. This must always be 4 byte aligned. This is also
3240 an appropriate time to fill in the string index field in the
3241 symbol table entry. */
3242 bfd_put_32 (abfd, length, p);
3243 strings_size += 4;
3244 p += 4;
3245
3246 /* Next comes the string itself + a null terminator. */
3247 strcpy (p, syms[i]->name);
3248
3249 som_symbol_data(syms[i])->stringtab_offset = strings_size;
3250 p += length + 1;
3251 strings_size += length + 1;
3252
3253 /* Always align up to the next word boundary. */
3254 while (strings_size % 4)
3255 {
3256 bfd_put_8 (abfd, 0, p);
3257 strings_size++;
3258 p++;
3259 }
3260 }
3261
3262 /* Scribble out any partial block. */
3263 if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
3264 return false;
3265
3266 *string_sizep = strings_size;
3267 return true;
3268}
3269
3270/* Compute variable information to be placed in the SOM headers,
3271 space/subspace dictionaries, relocation streams, etc. Begin
3272 writing parts of the object file. */
3273
3274static boolean
3275som_begin_writing (abfd)
3276 bfd *abfd;
3277{
3278 unsigned long current_offset = 0;
3279 int strings_size = 0;
3280 unsigned int total_reloc_size = 0;
3281 unsigned long num_spaces, num_subspaces, i;
3282 asection *section;
3283 unsigned int total_subspaces = 0;
3284 struct som_exec_auxhdr *exec_header = NULL;
3285
3286 /* The file header will always be first in an object file,
3287 everything else can be in random locations. To keep things
3288 "simple" BFD will lay out the object file in the manner suggested
3289 by the PRO ABI for PA-RISC Systems. */
3290
3291 /* Before any output can really begin offsets for all the major
3292 portions of the object file must be computed. So, starting
3293 with the initial file header compute (and sometimes write)
3294 each portion of the object file. */
3295
3296 /* Make room for the file header, it's contents are not complete
3297 yet, so it can not be written at this time. */
3298 current_offset += sizeof (struct header);
3299
3300 /* Any auxiliary headers will follow the file header. Right now
3301 we support only the copyright and version headers. */
3302 obj_som_file_hdr (abfd)->aux_header_location = current_offset;
3303 obj_som_file_hdr (abfd)->aux_header_size = 0;
3304 if (abfd->flags & (EXEC_P | DYNAMIC))
3305 {
3306 /* Parts of the exec header will be filled in later, so
3307 delay writing the header itself. Fill in the defaults,
3308 and write it later. */
3309 current_offset += sizeof (struct som_exec_auxhdr);
3310 obj_som_file_hdr (abfd)->aux_header_size
3311 += sizeof (struct som_exec_auxhdr);
3312 exec_header = obj_som_exec_hdr (abfd);
3313 exec_header->som_auxhdr.type = EXEC_AUX_ID;
3314 exec_header->som_auxhdr.length = 40;
3315 }
3316 if (obj_som_version_hdr (abfd) != NULL)
3317 {
3318 unsigned int len;
3319
3320 if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
3321 return false;
3322
3323 /* Write the aux_id structure and the string length. */
3324 len = sizeof (struct aux_id) + sizeof (unsigned int);
3325 obj_som_file_hdr (abfd)->aux_header_size += len;
3326 current_offset += len;
3327 if (bfd_write ((PTR) obj_som_version_hdr (abfd), len, 1, abfd) != len)
3328 return false;
3329
3330 /* Write the version string. */
3331 len = obj_som_version_hdr (abfd)->header_id.length - sizeof (int);
3332 obj_som_file_hdr (abfd)->aux_header_size += len;
3333 current_offset += len;
3334 if (bfd_write ((PTR) obj_som_version_hdr (abfd)->user_string,
3335 len, 1, abfd) != len)
3336 return false;
3337 }
3338
3339 if (obj_som_copyright_hdr (abfd) != NULL)
3340 {
3341 unsigned int len;
3342
3343 if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
3344 return false;
3345
3346 /* Write the aux_id structure and the string length. */
3347 len = sizeof (struct aux_id) + sizeof (unsigned int);
3348 obj_som_file_hdr (abfd)->aux_header_size += len;
3349 current_offset += len;
3350 if (bfd_write ((PTR) obj_som_copyright_hdr (abfd), len, 1, abfd) != len)
3351 return false;
3352
3353 /* Write the copyright string. */
3354 len = obj_som_copyright_hdr (abfd)->header_id.length - sizeof (int);
3355 obj_som_file_hdr (abfd)->aux_header_size += len;
3356 current_offset += len;
3357 if (bfd_write ((PTR) obj_som_copyright_hdr (abfd)->copyright,
3358 len, 1, abfd) != len)
3359 return false;
3360 }
3361
3362 /* Next comes the initialization pointers; we have no initialization
3363 pointers, so current offset does not change. */
3364 obj_som_file_hdr (abfd)->init_array_location = current_offset;
3365 obj_som_file_hdr (abfd)->init_array_total = 0;
3366
3367 /* Next are the space records. These are fixed length records.
3368
3369 Count the number of spaces to determine how much room is needed
3370 in the object file for the space records.
3371
3372 The names of the spaces are stored in a separate string table,
3373 and the index for each space into the string table is computed
3374 below. Therefore, it is not possible to write the space headers
3375 at this time. */
3376 num_spaces = som_count_spaces (abfd);
3377 obj_som_file_hdr (abfd)->space_location = current_offset;
3378 obj_som_file_hdr (abfd)->space_total = num_spaces;
3379 current_offset += num_spaces * sizeof (struct space_dictionary_record);
3380
3381 /* Next are the subspace records. These are fixed length records.
3382
3383 Count the number of subspaes to determine how much room is needed
3384 in the object file for the subspace records.
3385
3386 A variety if fields in the subspace record are still unknown at
3387 this time (index into string table, fixup stream location/size, etc). */
3388 num_subspaces = som_count_subspaces (abfd);
3389 obj_som_file_hdr (abfd)->subspace_location = current_offset;
3390 obj_som_file_hdr (abfd)->subspace_total = num_subspaces;
3391 current_offset += num_subspaces * sizeof (struct subspace_dictionary_record);
3392
3393 /* Next is the string table for the space/subspace names. We will
3394 build and write the string table on the fly. At the same time
3395 we will fill in the space/subspace name index fields. */
3396
3397 /* The string table needs to be aligned on a word boundary. */
3398 if (current_offset % 4)
3399 current_offset += (4 - (current_offset % 4));
3400
3401 /* Mark the offset of the space/subspace string table in the
3402 file header. */
3403 obj_som_file_hdr (abfd)->space_strings_location = current_offset;
3404
3405 /* Scribble out the space strings. */
3406 if (som_write_space_strings (abfd, current_offset, &strings_size) == false)
3407 return false;
3408
3409 /* Record total string table size in the header and update the
3410 current offset. */
3411 obj_som_file_hdr (abfd)->space_strings_size = strings_size;
3412 current_offset += strings_size;
3413
3414 /* Next is the compilation unit. */
3415 obj_som_file_hdr (abfd)->compiler_location = current_offset;
3416 obj_som_file_hdr (abfd)->compiler_total = 0;
3417 if (obj_som_compilation_unit (abfd))
3418 {
3419 obj_som_file_hdr (abfd)->compiler_total = 1;
3420 current_offset += COMPUNITSZ;
3421 }
3422
3423 /* Now compute the file positions for the loadable subspaces, taking
3424 care to make sure everything stays properly aligned. */
3425
3426 section = abfd->sections;
3427 for (i = 0; i < num_spaces; i++)
3428 {
3429 asection *subsection;
3430 int first_subspace;
3431 unsigned int subspace_offset = 0;
3432
3433 /* Find a space. */
3434 while (!som_is_space (section))
3435 section = section->next;
3436
3437 first_subspace = 1;
3438 /* Now look for all its subspaces. */
3439 for (subsection = abfd->sections;
3440 subsection != NULL;
3441 subsection = subsection->next)
3442 {
3443
3444 if (!som_is_subspace (subsection)
3445 || !som_is_container (section, subsection)
3446 || (subsection->flags & SEC_ALLOC) == 0)
3447 continue;
3448
3449 /* If this is the first subspace in the space, and we are
3450 building an executable, then take care to make sure all
3451 the alignments are correct and update the exec header. */
3452 if (first_subspace
3453 && (abfd->flags & (EXEC_P | DYNAMIC)))
3454 {
3455 /* Demand paged executables have each space aligned to a
3456 page boundary. Sharable executables (write-protected
3457 text) have just the private (aka data & bss) space aligned
3458 to a page boundary. Ugh. Not true for HPUX.
3459
3460 The HPUX kernel requires the text to always be page aligned
3461 within the file regardless of the executable's type. */
3462 if (abfd->flags & (D_PAGED | DYNAMIC)
3463 || (subsection->flags & SEC_CODE)
3464 || ((abfd->flags & WP_TEXT)
3465 && (subsection->flags & SEC_DATA)))
3466 current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
3467
3468 /* Update the exec header. */
3469 if (subsection->flags & SEC_CODE && exec_header->exec_tfile == 0)
3470 {
3471 exec_header->exec_tmem = section->vma;
3472 exec_header->exec_tfile = current_offset;
3473 }
3474 if (subsection->flags & SEC_DATA && exec_header->exec_dfile == 0)
3475 {
3476 exec_header->exec_dmem = section->vma;
3477 exec_header->exec_dfile = current_offset;
3478 }
3479
3480 /* Keep track of exactly where we are within a particular
3481 space. This is necessary as the braindamaged HPUX
3482 loader will create holes between subspaces *and*
3483 subspace alignments are *NOT* preserved. What a crock. */
3484 subspace_offset = subsection->vma;
3485
3486 /* Only do this for the first subspace within each space. */
3487 first_subspace = 0;
3488 }
3489 else if (abfd->flags & (EXEC_P | DYNAMIC))
3490 {
3491 /* The braindamaged HPUX loader may have created a hole
3492 between two subspaces. It is *not* sufficient to use
3493 the alignment specifications within the subspaces to
3494 account for these holes -- I've run into at least one
3495 case where the loader left one code subspace unaligned
3496 in a final executable.
3497
3498 To combat this we keep a current offset within each space,
3499 and use the subspace vma fields to detect and preserve
3500 holes. What a crock!
3501
3502 ps. This is not necessary for unloadable space/subspaces. */
3503 current_offset += subsection->vma - subspace_offset;
3504 if (subsection->flags & SEC_CODE)
3505 exec_header->exec_tsize += subsection->vma - subspace_offset;
3506 else
3507 exec_header->exec_dsize += subsection->vma - subspace_offset;
3508 subspace_offset += subsection->vma - subspace_offset;
3509 }
3510
3511
3512 subsection->target_index = total_subspaces++;
3513 /* This is real data to be loaded from the file. */
3514 if (subsection->flags & SEC_LOAD)
3515 {
3516 /* Update the size of the code & data. */
3517 if (abfd->flags & (EXEC_P | DYNAMIC)
3518 && subsection->flags & SEC_CODE)
3519 exec_header->exec_tsize += subsection->_cooked_size;
3520 else if (abfd->flags & (EXEC_P | DYNAMIC)
3521 && subsection->flags & SEC_DATA)
3522 exec_header->exec_dsize += subsection->_cooked_size;
3523 som_section_data (subsection)->subspace_dict->file_loc_init_value
3524 = current_offset;
3525 subsection->filepos = current_offset;
3526 current_offset += bfd_section_size (abfd, subsection);
3527 subspace_offset += bfd_section_size (abfd, subsection);
3528 }
3529 /* Looks like uninitialized data. */
3530 else
3531 {
3532 /* Update the size of the bss section. */
3533 if (abfd->flags & (EXEC_P | DYNAMIC))
3534 exec_header->exec_bsize += subsection->_cooked_size;
3535
3536 som_section_data (subsection)->subspace_dict->file_loc_init_value
3537 = 0;
3538 som_section_data (subsection)->subspace_dict->
3539 initialization_length = 0;
3540 }
3541 }
3542 /* Goto the next section. */
3543 section = section->next;
3544 }
3545
3546 /* Finally compute the file positions for unloadable subspaces.
3547 If building an executable, start the unloadable stuff on its
3548 own page. */
3549
3550 if (abfd->flags & (EXEC_P | DYNAMIC))
3551 current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
3552
3553 obj_som_file_hdr (abfd)->unloadable_sp_location = current_offset;
3554 section = abfd->sections;
3555 for (i = 0; i < num_spaces; i++)
3556 {
3557 asection *subsection;
3558
3559 /* Find a space. */
3560 while (!som_is_space (section))
3561 section = section->next;
3562
3563 if (abfd->flags & (EXEC_P | DYNAMIC))
3564 current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
3565
3566 /* Now look for all its subspaces. */
3567 for (subsection = abfd->sections;
3568 subsection != NULL;
3569 subsection = subsection->next)
3570 {
3571
3572 if (!som_is_subspace (subsection)
3573 || !som_is_container (section, subsection)
3574 || (subsection->flags & SEC_ALLOC) != 0)
3575 continue;
3576
3577 subsection->target_index = total_subspaces++;
3578 /* This is real data to be loaded from the file. */
3579 if ((subsection->flags & SEC_LOAD) == 0)
3580 {
3581 som_section_data (subsection)->subspace_dict->file_loc_init_value
3582 = current_offset;
3583 subsection->filepos = current_offset;
3584 current_offset += bfd_section_size (abfd, subsection);
3585 }
3586 /* Looks like uninitialized data. */
3587 else
3588 {
3589 som_section_data (subsection)->subspace_dict->file_loc_init_value
3590 = 0;
3591 som_section_data (subsection)->subspace_dict->
3592 initialization_length = bfd_section_size (abfd, subsection);
3593 }
3594 }
3595 /* Goto the next section. */
3596 section = section->next;
3597 }
3598
3599 /* If building an executable, then make sure to seek to and write
3600 one byte at the end of the file to make sure any necessary
3601 zeros are filled in. Ugh. */
3602 if (abfd->flags & (EXEC_P | DYNAMIC))
3603 current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
3604 if (bfd_seek (abfd, current_offset - 1, SEEK_SET) < 0)
3605 return false;
3606 if (bfd_write ((PTR) "", 1, 1, abfd) != 1)
3607 return false;
3608
3609 obj_som_file_hdr (abfd)->unloadable_sp_size
3610 = current_offset - obj_som_file_hdr (abfd)->unloadable_sp_location;
3611
3612 /* Loader fixups are not supported in any way shape or form. */
3613 obj_som_file_hdr (abfd)->loader_fixup_location = 0;
3614 obj_som_file_hdr (abfd)->loader_fixup_total = 0;
3615
3616 /* Done. Store the total size of the SOM so far. */
3617 obj_som_file_hdr (abfd)->som_length = current_offset;
3618
3619 return true;
3620}
3621
3622/* Finally, scribble out the various headers to the disk. */
3623
3624static boolean
3625som_finish_writing (abfd)
3626 bfd *abfd;
3627{
3628 int num_spaces = som_count_spaces (abfd);
3629 asymbol **syms = bfd_get_outsymbols (abfd);
3630 int i, num_syms, strings_size;
3631 int subspace_index = 0;
3632 file_ptr location;
3633 asection *section;
3634 unsigned long current_offset;
3635 unsigned int total_reloc_size;
3636
3637 /* Next is the symbol table. These are fixed length records.
3638
3639 Count the number of symbols to determine how much room is needed
3640 in the object file for the symbol table.
3641
3642 The names of the symbols are stored in a separate string table,
3643 and the index for each symbol name into the string table is computed
3644 below. Therefore, it is not possible to write the symbol table
3645 at this time.
3646
3647 These used to be output before the subspace contents, but they
3648 were moved here to work around a stupid bug in the hpux linker
3649 (fixed in hpux10). */
3650 current_offset = obj_som_file_hdr (abfd)->som_length;
3651
3652 /* Make sure we're on a word boundary. */
3653 if (current_offset % 4)
3654 current_offset += (4 - (current_offset % 4));
3655
3656 num_syms = bfd_get_symcount (abfd);
3657 obj_som_file_hdr (abfd)->symbol_location = current_offset;
3658 obj_som_file_hdr (abfd)->symbol_total = num_syms;
3659 current_offset += num_syms * sizeof (struct symbol_dictionary_record);
3660
3661 /* Next are the symbol strings.
3662 Align them to a word boundary. */
3663 if (current_offset % 4)
3664 current_offset += (4 - (current_offset % 4));
3665 obj_som_file_hdr (abfd)->symbol_strings_location = current_offset;
3666
3667 /* Scribble out the symbol strings. */
3668 if (som_write_symbol_strings (abfd, current_offset, syms,
3669 num_syms, &strings_size,
3670 obj_som_compilation_unit (abfd))
3671 == false)
3672 return false;
3673
3674 /* Record total string table size in header and update the
3675 current offset. */
3676 obj_som_file_hdr (abfd)->symbol_strings_size = strings_size;
3677 current_offset += strings_size;
3678
3679 /* Do prep work before handling fixups. */
3680 som_prep_for_fixups (abfd,
3681 bfd_get_outsymbols (abfd),
3682 bfd_get_symcount (abfd));
3683
3684 /* At the end of the file is the fixup stream which starts on a
3685 word boundary. */
3686 if (current_offset % 4)
3687 current_offset += (4 - (current_offset % 4));
3688 obj_som_file_hdr (abfd)->fixup_request_location = current_offset;
3689
3690 /* Write the fixups and update fields in subspace headers which
3691 relate to the fixup stream. */
3692 if (som_write_fixups (abfd, current_offset, &total_reloc_size) == false)
3693 return false;
3694
3695 /* Record the total size of the fixup stream in the file header. */
3696 obj_som_file_hdr (abfd)->fixup_request_total = total_reloc_size;
3697
3698 /* Done. Store the total size of the SOM. */
3699 obj_som_file_hdr (abfd)->som_length = current_offset + total_reloc_size;
3700
3701 /* Now that the symbol table information is complete, build and
3702 write the symbol table. */
3703 if (som_build_and_write_symbol_table (abfd) == false)
3704 return false;
3705
3706 /* Subspaces are written first so that we can set up information
3707 about them in their containing spaces as the subspace is written. */
3708
3709 /* Seek to the start of the subspace dictionary records. */
3710 location = obj_som_file_hdr (abfd)->subspace_location;
3711 if (bfd_seek (abfd, location, SEEK_SET) < 0)
3712 return false;
3713
3714 section = abfd->sections;
3715 /* Now for each loadable space write out records for its subspaces. */
3716 for (i = 0; i < num_spaces; i++)
3717 {
3718 asection *subsection;
3719
3720 /* Find a space. */
3721 while (!som_is_space (section))
3722 section = section->next;
3723
3724 /* Now look for all its subspaces. */
3725 for (subsection = abfd->sections;
3726 subsection != NULL;
3727 subsection = subsection->next)
3728 {
3729
3730 /* Skip any section which does not correspond to a space
3731 or subspace. Or does not have SEC_ALLOC set (and therefore
3732 has no real bits on the disk). */
3733 if (!som_is_subspace (subsection)
3734 || !som_is_container (section, subsection)
3735 || (subsection->flags & SEC_ALLOC) == 0)
3736 continue;
3737
3738 /* If this is the first subspace for this space, then save
3739 the index of the subspace in its containing space. Also
3740 set "is_loadable" in the containing space. */
3741
3742 if (som_section_data (section)->space_dict->subspace_quantity == 0)
3743 {
3744 som_section_data (section)->space_dict->is_loadable = 1;
3745 som_section_data (section)->space_dict->subspace_index
3746 = subspace_index;
3747 }
3748
3749 /* Increment the number of subspaces seen and the number of
3750 subspaces contained within the current space. */
3751 subspace_index++;
3752 som_section_data (section)->space_dict->subspace_quantity++;
3753
3754 /* Mark the index of the current space within the subspace's
3755 dictionary record. */
3756 som_section_data (subsection)->subspace_dict->space_index = i;
3757
3758 /* Dump the current subspace header. */
3759 if (bfd_write ((PTR) som_section_data (subsection)->subspace_dict,
3760 sizeof (struct subspace_dictionary_record), 1, abfd)
3761 != sizeof (struct subspace_dictionary_record))
3762 return false;
3763 }
3764 /* Goto the next section. */
3765 section = section->next;
3766 }
3767
3768 /* Now repeat the process for unloadable subspaces. */
3769 section = abfd->sections;
3770 /* Now for each space write out records for its subspaces. */
3771 for (i = 0; i < num_spaces; i++)
3772 {
3773 asection *subsection;
3774
3775 /* Find a space. */
3776 while (!som_is_space (section))
3777 section = section->next;
3778
3779 /* Now look for all its subspaces. */
3780 for (subsection = abfd->sections;
3781 subsection != NULL;
3782 subsection = subsection->next)
3783 {
3784
3785 /* Skip any section which does not correspond to a space or
3786 subspace, or which SEC_ALLOC set (and therefore handled
3787 in the loadable spaces/subspaces code above). */
3788
3789 if (!som_is_subspace (subsection)
3790 || !som_is_container (section, subsection)
3791 || (subsection->flags & SEC_ALLOC) != 0)
3792 continue;
3793
3794 /* If this is the first subspace for this space, then save
3795 the index of the subspace in its containing space. Clear
3796 "is_loadable". */
3797
3798 if (som_section_data (section)->space_dict->subspace_quantity == 0)
3799 {
3800 som_section_data (section)->space_dict->is_loadable = 0;
3801 som_section_data (section)->space_dict->subspace_index
3802 = subspace_index;
3803 }
3804
3805 /* Increment the number of subspaces seen and the number of
3806 subspaces contained within the current space. */
3807 som_section_data (section)->space_dict->subspace_quantity++;
3808 subspace_index++;
3809
3810 /* Mark the index of the current space within the subspace's
3811 dictionary record. */
3812 som_section_data (subsection)->subspace_dict->space_index = i;
3813
3814 /* Dump this subspace header. */
3815 if (bfd_write ((PTR) som_section_data (subsection)->subspace_dict,
3816 sizeof (struct subspace_dictionary_record), 1, abfd)
3817 != sizeof (struct subspace_dictionary_record))
3818 return false;
3819 }
3820 /* Goto the next section. */
3821 section = section->next;
3822 }
3823
3824 /* All the subspace dictiondary records are written, and all the
3825 fields are set up in the space dictionary records.
3826
3827 Seek to the right location and start writing the space
3828 dictionary records. */
3829 location = obj_som_file_hdr (abfd)->space_location;
3830 if (bfd_seek (abfd, location, SEEK_SET) < 0)
3831 return false;
3832
3833 section = abfd->sections;
3834 for (i = 0; i < num_spaces; i++)
3835 {
3836
3837 /* Find a space. */
3838 while (!som_is_space (section))
3839 section = section->next;
3840
3841 /* Dump its header */
3842 if (bfd_write ((PTR) som_section_data (section)->space_dict,
3843 sizeof (struct space_dictionary_record), 1, abfd)
3844 != sizeof (struct space_dictionary_record))
3845 return false;
3846
3847 /* Goto the next section. */
3848 section = section->next;
3849 }
3850
3851 /* Write the compilation unit record if there is one. */
3852 if (obj_som_compilation_unit (abfd))
3853 {
3854 location = obj_som_file_hdr (abfd)->compiler_location;
3855 if (bfd_seek (abfd, location, SEEK_SET) < 0)
3856 return false;
3857
3858 if (bfd_write ((PTR) obj_som_compilation_unit (abfd),
3859 COMPUNITSZ, 1, abfd) != COMPUNITSZ)
3860 return false;
3861 }
3862
3863 /* Setting of the system_id has to happen very late now that copying of
3864 BFD private data happens *after* section contents are set. */
3865 if (abfd->flags & (EXEC_P | DYNAMIC))
3866 obj_som_file_hdr(abfd)->system_id = obj_som_exec_data (abfd)->system_id;
3867 else if (bfd_get_mach (abfd) == pa20)
3868 obj_som_file_hdr(abfd)->system_id = CPU_PA_RISC2_0;
3869 else if (bfd_get_mach (abfd) == pa11)
3870 obj_som_file_hdr(abfd)->system_id = CPU_PA_RISC1_1;
3871 else
3872 obj_som_file_hdr(abfd)->system_id = CPU_PA_RISC1_0;
3873
3874 /* Compute the checksum for the file header just before writing
3875 the header to disk. */
3876 obj_som_file_hdr (abfd)->checksum = som_compute_checksum (abfd);
3877
3878 /* Only thing left to do is write out the file header. It is always
3879 at location zero. Seek there and write it. */
3880 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) < 0)
3881 return false;
3882 if (bfd_write ((PTR) obj_som_file_hdr (abfd),
3883 sizeof (struct header), 1, abfd)
3884 != sizeof (struct header))
3885 return false;
3886
3887 /* Now write the exec header. */
3888 if (abfd->flags & (EXEC_P | DYNAMIC))
3889 {
3890 long tmp, som_length;
3891 struct som_exec_auxhdr *exec_header;
3892
3893 exec_header = obj_som_exec_hdr (abfd);
3894 exec_header->exec_entry = bfd_get_start_address (abfd);
3895 exec_header->exec_flags = obj_som_exec_data (abfd)->exec_flags;
3896
3897 /* Oh joys. Ram some of the BSS data into the DATA section
3898 to be compatable with how the hp linker makes objects
3899 (saves memory space). */
3900 tmp = exec_header->exec_dsize;
3901 tmp = SOM_ALIGN (tmp, PA_PAGESIZE);
3902 exec_header->exec_bsize -= (tmp - exec_header->exec_dsize);
3903 if (exec_header->exec_bsize < 0)
3904 exec_header->exec_bsize = 0;
3905 exec_header->exec_dsize = tmp;
3906
3907 /* Now perform some sanity checks. The idea is to catch bogons now and
3908 inform the user, instead of silently generating a bogus file. */
3909 som_length = obj_som_file_hdr (abfd)->som_length;
3910 if (exec_header->exec_tfile + exec_header->exec_tsize > som_length
3911 || exec_header->exec_dfile + exec_header->exec_dsize > som_length)
3912 {
3913 bfd_set_error (bfd_error_bad_value);
3914 return false;
3915 }
3916
3917 if (bfd_seek (abfd, obj_som_file_hdr (abfd)->aux_header_location,
3918 SEEK_SET) < 0)
3919 return false;
3920
3921 if (bfd_write ((PTR) exec_header, AUX_HDR_SIZE, 1, abfd)
3922 != AUX_HDR_SIZE)
3923 return false;
3924 }
3925 return true;
3926}
3927
3928/* Compute and return the checksum for a SOM file header. */
3929
3930static unsigned long
3931som_compute_checksum (abfd)
3932 bfd *abfd;
3933{
3934 unsigned long checksum, count, i;
3935 unsigned long *buffer = (unsigned long *) obj_som_file_hdr (abfd);
3936
3937 checksum = 0;
3938 count = sizeof (struct header) / sizeof (unsigned long);
3939 for (i = 0; i < count; i++)
3940 checksum ^= *(buffer + i);
3941
3942 return checksum;
3943}
3944
3945static void
3946som_bfd_derive_misc_symbol_info (abfd, sym, info)
3947 bfd *abfd;
3948 asymbol *sym;
3949 struct som_misc_symbol_info *info;
3950{
3951 /* Initialize. */
3952 memset (info, 0, sizeof (struct som_misc_symbol_info));
3953
3954 /* The HP SOM linker requires detailed type information about
3955 all symbols (including undefined symbols!). Unfortunately,
3956 the type specified in an import/export statement does not
3957 always match what the linker wants. Severe braindamage. */
3958
3959 /* Section symbols will not have a SOM symbol type assigned to
3960 them yet. Assign all section symbols type ST_DATA. */
3961 if (sym->flags & BSF_SECTION_SYM)
3962 info->symbol_type = ST_DATA;
3963 else
3964 {
3965 /* Common symbols must have scope SS_UNSAT and type
3966 ST_STORAGE or the linker will choke. */
3967 if (bfd_is_com_section (sym->section))
3968 {
3969 info->symbol_scope = SS_UNSAT;
3970 info->symbol_type = ST_STORAGE;
3971 }
3972
3973 /* It is possible to have a symbol without an associated
3974 type. This happens if the user imported the symbol
3975 without a type and the symbol was never defined
3976 locally. If BSF_FUNCTION is set for this symbol, then
3977 assign it type ST_CODE (the HP linker requires undefined
3978 external functions to have type ST_CODE rather than ST_ENTRY). */
3979 else if ((som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN
3980 || som_symbol_data (sym)->som_type == SYMBOL_TYPE_CODE)
3981 && bfd_is_und_section (sym->section)
3982 && sym->flags & BSF_FUNCTION)
3983 info->symbol_type = ST_CODE;
3984
3985 /* Handle function symbols which were defined in this file.
3986 They should have type ST_ENTRY. Also retrieve the argument
3987 relocation bits from the SOM backend information. */
3988 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_ENTRY
3989 || (som_symbol_data (sym)->som_type == SYMBOL_TYPE_CODE
3990 && (sym->flags & BSF_FUNCTION))
3991 || (som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN
3992 && (sym->flags & BSF_FUNCTION)))
3993 {
3994 info->symbol_type = ST_ENTRY;
3995 info->arg_reloc = som_symbol_data (sym)->tc_data.ap.hppa_arg_reloc;
3996 info->priv_level= som_symbol_data (sym)->tc_data.ap.hppa_priv_level;
3997 }
3998
3999 /* For unknown symbols set the symbol's type based on the symbol's
4000 section (ST_DATA for DATA sections, ST_CODE for CODE sections). */
4001 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN)
4002 {
4003 if (sym->section->flags & SEC_CODE)
4004 info->symbol_type = ST_CODE;
4005 else
4006 info->symbol_type = ST_DATA;
4007 }
4008
4009 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN)
4010 info->symbol_type = ST_DATA;
4011
4012 /* From now on it's a very simple mapping. */
4013 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_ABSOLUTE)
4014 info->symbol_type = ST_ABSOLUTE;
4015 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_CODE)
4016 info->symbol_type = ST_CODE;
4017 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_DATA)
4018 info->symbol_type = ST_DATA;
4019 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_MILLICODE)
4020 info->symbol_type = ST_MILLICODE;
4021 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_PLABEL)
4022 info->symbol_type = ST_PLABEL;
4023 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_PRI_PROG)
4024 info->symbol_type = ST_PRI_PROG;
4025 else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_SEC_PROG)
4026 info->symbol_type = ST_SEC_PROG;
4027 }
4028
4029 /* Now handle the symbol's scope. Exported data which is not
4030 in the common section has scope SS_UNIVERSAL. Note scope
4031 of common symbols was handled earlier! */
4032 if (bfd_is_und_section (sym->section))
4033 info->symbol_scope = SS_UNSAT;
4034 else if (sym->flags & BSF_EXPORT && ! bfd_is_com_section (sym->section))
4035 info->symbol_scope = SS_UNIVERSAL;
4036 /* Anything else which is not in the common section has scope
4037 SS_LOCAL. */
4038 else if (! bfd_is_com_section (sym->section))
4039 info->symbol_scope = SS_LOCAL;
4040
4041 /* Now set the symbol_info field. It has no real meaning
4042 for undefined or common symbols, but the HP linker will
4043 choke if it's not set to some "reasonable" value. We
4044 use zero as a reasonable value. */
4045 if (bfd_is_com_section (sym->section)
4046 || bfd_is_und_section (sym->section)
4047 || bfd_is_abs_section (sym->section))
4048 info->symbol_info = 0;
4049 /* For all other symbols, the symbol_info field contains the
4050 subspace index of the space this symbol is contained in. */
4051 else
4052 info->symbol_info = sym->section->target_index;
4053
4054 /* Set the symbol's value. */
4055 info->symbol_value = sym->value + sym->section->vma;
ba20314e
CM		 4056
4057 /* The secondary_def field is for weak symbols. */
4058 if (sym->flags & BSF_WEAK)
4059 info->secondary_def = true;
4060 else
4061 info->secondary_def = false;
4062
252b5132
RH		 4063}
4064
4065/* Build and write, in one big chunk, the entire symbol table for
4066 this BFD. */
4067
4068static boolean
4069som_build_and_write_symbol_table (abfd)
4070 bfd *abfd;
4071{
4072 unsigned int num_syms = bfd_get_symcount (abfd);
4073 file_ptr symtab_location = obj_som_file_hdr (abfd)->symbol_location;
4074 asymbol **bfd_syms = obj_som_sorted_syms (abfd);
4075 struct symbol_dictionary_record *som_symtab = NULL;
4076 int i, symtab_size;
4077
4078 /* Compute total symbol table size and allocate a chunk of memory
4079 to hold the symbol table as we build it. */
4080 symtab_size = num_syms * sizeof (struct symbol_dictionary_record);
4081 som_symtab = (struct symbol_dictionary_record *) bfd_malloc (symtab_size);
4082 if (som_symtab == NULL && symtab_size != 0)
4083 goto error_return;
4084 memset (som_symtab, 0, symtab_size);
4085
4086 /* Walk over each symbol. */
4087 for (i = 0; i < num_syms; i++)
4088 {
4089 struct som_misc_symbol_info info;
4090
4091 /* This is really an index into the symbol strings table.
4092 By the time we get here, the index has already been
4093 computed and stored into the name field in the BFD symbol. */
4094 som_symtab[i].name.n_strx = som_symbol_data(bfd_syms[i])->stringtab_offset;
4095
4096 /* Derive SOM information from the BFD symbol. */
4097 som_bfd_derive_misc_symbol_info (abfd, bfd_syms[i], &info);
4098
4099 /* Now use it. */
4100 som_symtab[i].symbol_type = info.symbol_type;
4101 som_symtab[i].symbol_scope = info.symbol_scope;
4102 som_symtab[i].arg_reloc = info.arg_reloc;
4103 som_symtab[i].symbol_info = info.symbol_info;
4104 som_symtab[i].xleast = 3;
4105 som_symtab[i].symbol_value = info.symbol_value | info.priv_level;
ba20314e 4106 som_symtab[i].secondary_def = info.secondary_def;
252b5132
RH		 4107 }
4108
4109 /* Everything is ready, seek to the right location and
4110 scribble out the symbol table. */
4111 if (bfd_seek (abfd, symtab_location, SEEK_SET) != 0)
4112 return false;
4113
4114 if (bfd_write ((PTR) som_symtab, symtab_size, 1, abfd) != symtab_size)
4115 goto error_return;
4116
4117 if (som_symtab != NULL)
4118 free (som_symtab);
4119 return true;
4120 error_return:
4121 if (som_symtab != NULL)
4122 free (som_symtab);
4123 return false;
4124}
4125
4126/* Write an object in SOM format. */
4127
4128static boolean
4129som_write_object_contents (abfd)
4130 bfd *abfd;
4131{
4132 if (abfd->output_has_begun == false)
4133 {
4134 /* Set up fixed parts of the file, space, and subspace headers.
4135 Notify the world that output has begun. */
4136 som_prep_headers (abfd);
4137 abfd->output_has_begun = true;
4138 /* Start writing the object file. This include all the string
4139 tables, fixup streams, and other portions of the object file. */
4140 som_begin_writing (abfd);
4141 }
4142
4143 return (som_finish_writing (abfd));
4144}
4145
4146\f
4147/* Read and save the string table associated with the given BFD. */
4148
4149static boolean
4150som_slurp_string_table (abfd)
4151 bfd *abfd;
4152{
4153 char *stringtab;
4154
4155 /* Use the saved version if its available. */
4156 if (obj_som_stringtab (abfd) != NULL)
4157 return true;
4158
4159 /* I don't think this can currently happen, and I'm not sure it should
4160 really be an error, but it's better than getting unpredictable results
4161 from the host's malloc when passed a size of zero. */
4162 if (obj_som_stringtab_size (abfd) == 0)
4163 {
4164 bfd_set_error (bfd_error_no_symbols);
4165 return false;
4166 }
4167
4168 /* Allocate and read in the string table. */
4169 stringtab = bfd_malloc (obj_som_stringtab_size (abfd));
4170 if (stringtab == NULL)
4171 return false;
4172 memset (stringtab, 0, obj_som_stringtab_size (abfd));
4173
4174 if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) < 0)
4175 return false;
4176
4177 if (bfd_read (stringtab, obj_som_stringtab_size (abfd), 1, abfd)
4178 != obj_som_stringtab_size (abfd))
4179 return false;
4180
4181 /* Save our results and return success. */
4182 obj_som_stringtab (abfd) = stringtab;
4183 return true;
4184}
4185
4186/* Return the amount of data (in bytes) required to hold the symbol
4187 table for this object. */
4188
4189static long
4190som_get_symtab_upper_bound (abfd)
4191 bfd *abfd;
4192{
4193 if (!som_slurp_symbol_table (abfd))
4194 return -1;
4195
4196 return (bfd_get_symcount (abfd) + 1) * (sizeof (asymbol *));
4197}
4198
4199/* Convert from a SOM subspace index to a BFD section. */
4200
4201static asection *
4202bfd_section_from_som_symbol (abfd, symbol)
4203 bfd *abfd;
4204 struct symbol_dictionary_record *symbol;
4205{
4206 asection *section;
4207
4208 /* The meaning of the symbol_info field changes for functions
4209 within executables. So only use the quick symbol_info mapping for
4210 incomplete objects and non-function symbols in executables. */
4211 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4212 || (symbol->symbol_type != ST_ENTRY
4213 && symbol->symbol_type != ST_PRI_PROG
4214 && symbol->symbol_type != ST_SEC_PROG
4215 && symbol->symbol_type != ST_MILLICODE))
4216 {
4217 unsigned int index = symbol->symbol_info;
4218 for (section = abfd->sections; section != NULL; section = section->next)
4219 if (section->target_index == index && som_is_subspace (section))
4220 return section;
4221
4222 /* Could be a symbol from an external library (such as an OMOS
4223 shared library). Don't abort. */
4224 return bfd_abs_section_ptr;
4225
4226 }
4227 else
4228 {
4229 unsigned int value = symbol->symbol_value;
4230
4231 /* For executables we will have to use the symbol's address and
4232 find out what section would contain that address. Yuk. */
4233 for (section = abfd->sections; section; section = section->next)
4234 {
4235 if (value >= section->vma
4236 && value <= section->vma + section->_cooked_size
4237 && som_is_subspace (section))
4238 return section;
4239 }
4240
4241 /* Could be a symbol from an external library (such as an OMOS
4242 shared library). Don't abort. */
4243 return bfd_abs_section_ptr;
4244
4245 }
4246}
4247
4248/* Read and save the symbol table associated with the given BFD. */
4249
4250static unsigned int
4251som_slurp_symbol_table (abfd)
4252 bfd *abfd;
4253{
4254 int symbol_count = bfd_get_symcount (abfd);
4255 int symsize = sizeof (struct symbol_dictionary_record);
4256 char *stringtab;
4257 struct symbol_dictionary_record *buf = NULL, *bufp, *endbufp;
4258 som_symbol_type *sym, *symbase;
4259
4260 /* Return saved value if it exists. */
4261 if (obj_som_symtab (abfd) != NULL)
4262 goto successful_return;
4263
4264 /* Special case. This is *not* an error. */
4265 if (symbol_count == 0)
4266 goto successful_return;
4267
4268 if (!som_slurp_string_table (abfd))
4269 goto error_return;
4270
4271 stringtab = obj_som_stringtab (abfd);
4272
4273 symbase = ((som_symbol_type *)
4274 bfd_malloc (symbol_count * sizeof (som_symbol_type)));
4275 if (symbase == NULL)
4276 goto error_return;
4277 memset (symbase, 0, symbol_count * sizeof (som_symbol_type));
4278
4279 /* Read in the external SOM representation. */
4280 buf = bfd_malloc (symbol_count * symsize);
4281 if (buf == NULL && symbol_count * symsize != 0)
4282 goto error_return;
4283 if (bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET) < 0)
4284 goto error_return;
4285 if (bfd_read (buf, symbol_count * symsize, 1, abfd)
4286 != symbol_count * symsize)
4287 goto error_return;
4288
4289 /* Iterate over all the symbols and internalize them. */
4290 endbufp = buf + symbol_count;
4291 for (bufp = buf, sym = symbase; bufp < endbufp; ++bufp)
4292 {
4293
4294 /* I don't think we care about these. */
4295 if (bufp->symbol_type == ST_SYM_EXT
4296 || bufp->symbol_type == ST_ARG_EXT)
4297 continue;
4298
4299 /* Set some private data we care about. */
4300 if (bufp->symbol_type == ST_NULL)
4301 som_symbol_data (sym)->som_type = SYMBOL_TYPE_UNKNOWN;
4302 else if (bufp->symbol_type == ST_ABSOLUTE)
4303 som_symbol_data (sym)->som_type = SYMBOL_TYPE_ABSOLUTE;
4304 else if (bufp->symbol_type == ST_DATA)
4305 som_symbol_data (sym)->som_type = SYMBOL_TYPE_DATA;
4306 else if (bufp->symbol_type == ST_CODE)
4307 som_symbol_data (sym)->som_type = SYMBOL_TYPE_CODE;
4308 else if (bufp->symbol_type == ST_PRI_PROG)
4309 som_symbol_data (sym)->som_type = SYMBOL_TYPE_PRI_PROG;
4310 else if (bufp->symbol_type == ST_SEC_PROG)
4311 som_symbol_data (sym)->som_type = SYMBOL_TYPE_SEC_PROG;
4312 else if (bufp->symbol_type == ST_ENTRY)
4313 som_symbol_data (sym)->som_type = SYMBOL_TYPE_ENTRY;
4314 else if (bufp->symbol_type == ST_MILLICODE)
4315 som_symbol_data (sym)->som_type = SYMBOL_TYPE_MILLICODE;
4316 else if (bufp->symbol_type == ST_PLABEL)
4317 som_symbol_data (sym)->som_type = SYMBOL_TYPE_PLABEL;
4318 else
4319 som_symbol_data (sym)->som_type = SYMBOL_TYPE_UNKNOWN;
4320 som_symbol_data (sym)->tc_data.ap.hppa_arg_reloc = bufp->arg_reloc;
4321
4322 /* Some reasonable defaults. */
4323 sym->symbol.the_bfd = abfd;
4324 sym->symbol.name = bufp->name.n_strx + stringtab;
4325 sym->symbol.value = bufp->symbol_value;
4326 sym->symbol.section = 0;
4327 sym->symbol.flags = 0;
4328
4329 switch (bufp->symbol_type)
4330 {
4331 case ST_ENTRY:
4332 case ST_MILLICODE:
4333 sym->symbol.flags |= BSF_FUNCTION;
4334 som_symbol_data (sym)->tc_data.ap.hppa_priv_level =
4335 sym->symbol.value & 0x3;
4336 sym->symbol.value &= ~0x3;
4337 break;
4338
4339 case ST_STUB:
4340 case ST_CODE:
4341 case ST_PRI_PROG:
4342 case ST_SEC_PROG:
4343 som_symbol_data (sym)->tc_data.ap.hppa_priv_level =
4344 sym->symbol.value & 0x3;
4345 sym->symbol.value &= ~0x3;
7da1b175 4346 /* If the symbol's scope is SS_UNSAT, then these are
252b5132
RH		 4347 undefined function symbols. */
4348 if (bufp->symbol_scope == SS_UNSAT)
4349 sym->symbol.flags |= BSF_FUNCTION;
4350
4351
4352 default:
4353 break;
4354 }
4355
4356 /* Handle scoping and section information. */
4357 switch (bufp->symbol_scope)
4358 {
4359 /* symbol_info field is undefined for SS_EXTERNAL and SS_UNSAT symbols,
4360 so the section associated with this symbol can't be known. */
4361 case SS_EXTERNAL:
4362 if (bufp->symbol_type != ST_STORAGE)
4363 sym->symbol.section = bfd_und_section_ptr;
4364 else
4365 sym->symbol.section = bfd_com_section_ptr;
4366 sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
4367 break;
4368
4369 case SS_UNSAT:
4370 if (bufp->symbol_type != ST_STORAGE)
4371 sym->symbol.section = bfd_und_section_ptr;
4372 else
4373 sym->symbol.section = bfd_com_section_ptr;
4374 break;
4375
4376 case SS_UNIVERSAL:
4377 sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
4378 sym->symbol.section = bfd_section_from_som_symbol (abfd, bufp);
4379 sym->symbol.value -= sym->symbol.section->vma;
4380 break;
4381
4382#if 0
4383 /* SS_GLOBAL and SS_LOCAL are two names for the same thing.
4384 Sound dumb? It is. */
4385 case SS_GLOBAL:
4386#endif
4387 case SS_LOCAL:
4388 sym->symbol.flags |= BSF_LOCAL;
4389 sym->symbol.section = bfd_section_from_som_symbol (abfd, bufp);
4390 sym->symbol.value -= sym->symbol.section->vma;
4391 break;
4392 }
4393
ba20314e
CM		 4394 /* Check for a weak symbol. */
4395 if (bufp->secondary_def)
4396 sym->symbol.flags |= BSF_WEAK;
4397
252b5132
RH		 4398 /* Mark section symbols and symbols used by the debugger.
4399 Note $START$ is a magic code symbol, NOT a section symbol. */
4400 if (sym->symbol.name[0] == '$'
4401 && sym->symbol.name[strlen (sym->symbol.name) - 1] == '$'
4402 && !strcmp (sym->symbol.name, sym->symbol.section->name))
4403 sym->symbol.flags |= BSF_SECTION_SYM;
4404 else if (!strncmp (sym->symbol.name, "L$0\002", 4))
4405 {
4406 sym->symbol.flags |= BSF_SECTION_SYM;
4407 sym->symbol.name = sym->symbol.section->name;
4408 }
4409 else if (!strncmp (sym->symbol.name, "L$0\001", 4))
4410 sym->symbol.flags |= BSF_DEBUGGING;
4411
4412 /* Note increment at bottom of loop, since we skip some symbols
4413 we can not include it as part of the for statement. */
4414 sym++;
4415 }
4416
4417 /* We modify the symbol count to record the number of BFD symbols we
4418 created. */
4419 bfd_get_symcount (abfd) = sym - symbase;
4420
4421 /* Save our results and return success. */
4422 obj_som_symtab (abfd) = symbase;
4423 successful_return:
4424 if (buf != NULL)
4425 free (buf);
4426 return (true);
4427
4428 error_return:
4429 if (buf != NULL)
4430 free (buf);
4431 return false;
4432}
4433
4434/* Canonicalize a SOM symbol table. Return the number of entries
4435 in the symbol table. */
4436
4437static long
4438som_get_symtab (abfd, location)
4439 bfd *abfd;
4440 asymbol **location;
4441{
4442 int i;
4443 som_symbol_type *symbase;
4444
4445 if (!som_slurp_symbol_table (abfd))
4446 return -1;
4447
4448 i = bfd_get_symcount (abfd);
4449 symbase = obj_som_symtab (abfd);
4450
4451 for (; i > 0; i--, location++, symbase++)
4452 *location = &symbase->symbol;
4453
4454 /* Final null pointer. */
4455 *location = 0;
4456 return (bfd_get_symcount (abfd));
4457}
4458
4459/* Make a SOM symbol. There is nothing special to do here. */
4460
4461static asymbol *
4462som_make_empty_symbol (abfd)
4463 bfd *abfd;
4464{
4465 som_symbol_type *new =
4466 (som_symbol_type *) bfd_zalloc (abfd, sizeof (som_symbol_type));
4467 if (new == NULL)
4468 return 0;
4469 new->symbol.the_bfd = abfd;
4470
4471 return &new->symbol;
4472}
4473
4474/* Print symbol information. */
4475
4476static void
4477som_print_symbol (ignore_abfd, afile, symbol, how)
4478 bfd *ignore_abfd;
4479 PTR afile;
4480 asymbol *symbol;
4481 bfd_print_symbol_type how;
4482{
4483 FILE *file = (FILE *) afile;
4484 switch (how)
4485 {
4486 case bfd_print_symbol_name:
4487 fprintf (file, "%s", symbol->name);
4488 break;
4489 case bfd_print_symbol_more:
4490 fprintf (file, "som ");
4491 fprintf_vma (file, symbol->value);
4492 fprintf (file, " %lx", (long) symbol->flags);
4493 break;
4494 case bfd_print_symbol_all:
4495 {
4496 CONST char *section_name;
4497 section_name = symbol->section ? symbol->section->name : "(*none*)";
4498 bfd_print_symbol_vandf ((PTR) file, symbol);
4499 fprintf (file, " %s\t%s", section_name, symbol->name);
4500 break;
4501 }
4502 }
4503}
4504
4505static boolean
4506som_bfd_is_local_label_name (abfd, name)
4507 bfd *abfd;
4508 const char *name;
4509{
4510 return (name[0] == 'L' && name[1] == '$');
4511}
4512
4513/* Count or process variable-length SOM fixup records.
4514
4515 To avoid code duplication we use this code both to compute the number
4516 of relocations requested by a stream, and to internalize the stream.
4517
4518 When computing the number of relocations requested by a stream the
4519 variables rptr, section, and symbols have no meaning.
4520
4521 Return the number of relocations requested by the fixup stream. When
4522 not just counting
4523
4524 This needs at least two or three more passes to get it cleaned up. */
4525
4526static unsigned int
4527som_set_reloc_info (fixup, end, internal_relocs, section, symbols, just_count)
4528 unsigned char *fixup;
4529 unsigned int end;
4530 arelent *internal_relocs;
4531 asection *section;
4532 asymbol **symbols;
4533 boolean just_count;
4534{
4535 unsigned int op, varname, deallocate_contents = 0;
4536 unsigned char *end_fixups = &fixup[end];
4537 const struct fixup_format *fp;
4538 char *cp;
4539 unsigned char *save_fixup;
4540 int variables[26], stack[20], c, v, count, prev_fixup, *sp, saved_unwind_bits;
4541 const int *subop;
4542 arelent *rptr= internal_relocs;
4543 unsigned int offset = 0;
4544
4545#define var(c) variables[(c) - 'A']
4546#define push(v) (*sp++ = (v))
4547#define pop() (*--sp)
4548#define emptystack() (sp == stack)
4549
4550 som_initialize_reloc_queue (reloc_queue);
4551 memset (variables, 0, sizeof (variables));
4552 memset (stack, 0, sizeof (stack));
4553 count = 0;
4554 prev_fixup = 0;
4555 saved_unwind_bits = 0;
4556 sp = stack;
4557
4558 while (fixup < end_fixups)
4559 {
4560
4561 /* Save pointer to the start of this fixup. We'll use
4562 it later to determine if it is necessary to put this fixup
4563 on the queue. */
4564 save_fixup = fixup;
4565
4566 /* Get the fixup code and its associated format. */
4567 op = *fixup++;
4568 fp = &som_fixup_formats[op];
4569
4570 /* Handle a request for a previous fixup. */
4571 if (*fp->format == 'P')
4572 {
4573 /* Get pointer to the beginning of the prev fixup, move
4574 the repeated fixup to the head of the queue. */
4575 fixup = reloc_queue[fp->D].reloc;
4576 som_reloc_queue_fix (reloc_queue, fp->D);
4577 prev_fixup = 1;
4578
4579 /* Get the fixup code and its associated format. */
4580 op = *fixup++;
4581 fp = &som_fixup_formats[op];
4582 }
4583
4584 /* If this fixup will be passed to BFD, set some reasonable defaults. */
4585 if (! just_count
4586 && som_hppa_howto_table[op].type != R_NO_RELOCATION
4587 && som_hppa_howto_table[op].type != R_DATA_OVERRIDE)
4588 {
4589 rptr->address = offset;
4590 rptr->howto = &som_hppa_howto_table[op];
4591 rptr->addend = 0;
4592 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4593 }
4594
4595 /* Set default input length to 0. Get the opcode class index
4596 into D. */
4597 var ('L') = 0;
4598 var ('D') = fp->D;
4599 var ('U') = saved_unwind_bits;
4600
4601 /* Get the opcode format. */
4602 cp = fp->format;
4603
4604 /* Process the format string. Parsing happens in two phases,
4605 parse RHS, then assign to LHS. Repeat until no more
4606 characters in the format string. */
4607 while (*cp)
4608 {
4609 /* The variable this pass is going to compute a value for. */
4610 varname = *cp++;
4611
4612 /* Start processing RHS. Continue until a NULL or '=' is found. */
4613 do
4614 {
4615 c = *cp++;
4616
4617 /* If this is a variable, push it on the stack. */
4618 if (isupper (c))
4619 push (var (c));
4620
4621 /* If this is a lower case letter, then it represents
4622 additional data from the fixup stream to be pushed onto
4623 the stack. */
4624 else if (islower (c))
4625 {
4626 int bits = (c - 'a') * 8;
4627 for (v = 0; c > 'a'; --c)
4628 v = (v << 8) | *fixup++;
4629 if (varname == 'V')
4630 v = sign_extend (v, bits);
4631 push (v);
4632 }
4633
4634 /* A decimal constant. Push it on the stack. */
4635 else if (isdigit (c))
4636 {
4637 v = c - '0';
4638 while (isdigit (*cp))
4639 v = (v * 10) + (*cp++ - '0');
4640 push (v);
4641 }
4642 else
4643
4644 /* An operator. Pop two two values from the stack and
4645 use them as operands to the given operation. Push
4646 the result of the operation back on the stack. */
4647 switch (c)
4648 {
4649 case '+':
4650 v = pop ();
4651 v += pop ();
4652 push (v);
4653 break;
4654 case '*':
4655 v = pop ();
4656 v *= pop ();
4657 push (v);
4658 break;
4659 case '<':
4660 v = pop ();
4661 v = pop () << v;
4662 push (v);
4663 break;
4664 default:
4665 abort ();
4666 }
4667 }
4668 while (*cp && *cp != '=');
4669
4670 /* Move over the equal operator. */
4671 cp++;
4672
4673 /* Pop the RHS off the stack. */
4674 c = pop ();
4675
4676 /* Perform the assignment. */
4677 var (varname) = c;
4678
4679 /* Handle side effects. and special 'O' stack cases. */
4680 switch (varname)
4681 {
4682 /* Consume some bytes from the input space. */
4683 case 'L':
4684 offset += c;
4685 break;
4686 /* A symbol to use in the relocation. Make a note
4687 of this if we are not just counting. */
4688 case 'S':
4689 if (! just_count)
4690 rptr->sym_ptr_ptr = &symbols[c];
4691 break;
4692 /* Argument relocation bits for a function call. */
4693 case 'R':
4694 if (! just_count)
4695 {
4696 unsigned int tmp = var ('R');
4697 rptr->addend = 0;
4698
4699 if ((som_hppa_howto_table[op].type == R_PCREL_CALL
4700 && R_PCREL_CALL + 10 > op)
4701 || (som_hppa_howto_table[op].type == R_ABS_CALL
4702 && R_ABS_CALL + 10 > op))
4703 {
4704 /* Simple encoding. */
4705 if (tmp > 4)
4706 {
4707 tmp -= 5;
4708 rptr->addend |= 1;
4709 }
4710 if (tmp == 4)
4711 rptr->addend |= 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2;
4712 else if (tmp == 3)
4713 rptr->addend |= 1 << 8 | 1 << 6 | 1 << 4;
4714 else if (tmp == 2)
4715 rptr->addend |= 1 << 8 | 1 << 6;
4716 else if (tmp == 1)
4717 rptr->addend |= 1 << 8;
4718 }
4719 else
4720 {
4721 unsigned int tmp1, tmp2;
4722
4723 /* First part is easy -- low order two bits are
4724 directly copied, then shifted away. */
4725 rptr->addend = tmp & 0x3;
4726 tmp >>= 2;
4727
4728 /* Diving the result by 10 gives us the second
4729 part. If it is 9, then the first two words
4730 are a double precision paramater, else it is
4731 3 * the first arg bits + the 2nd arg bits. */
4732 tmp1 = tmp / 10;
4733 tmp -= tmp1 * 10;
4734 if (tmp1 == 9)
4735 rptr->addend += (0xe << 6);
4736 else
4737 {
4738 /* Get the two pieces. */
4739 tmp2 = tmp1 / 3;
4740 tmp1 -= tmp2 * 3;
4741 /* Put them in the addend. */
4742 rptr->addend += (tmp2 << 8) + (tmp1 << 6);
4743 }
4744
4745 /* What's left is the third part. It's unpacked
4746 just like the second. */
4747 if (tmp == 9)
4748 rptr->addend += (0xe << 2);
4749 else
4750 {
4751 tmp2 = tmp / 3;
4752 tmp -= tmp2 * 3;
4753 rptr->addend += (tmp2 << 4) + (tmp << 2);
4754 }
4755 }
4756 rptr->addend = HPPA_R_ADDEND (rptr->addend, 0);
4757 }
4758 break;
4759 /* Handle the linker expression stack. */
4760 case 'O':
4761 switch (op)
4762 {
4763 case R_COMP1:
4764 subop = comp1_opcodes;
4765 break;
4766 case R_COMP2:
4767 subop = comp2_opcodes;
4768 break;
4769 case R_COMP3:
4770 subop = comp3_opcodes;
4771 break;
4772 default:
4773 abort ();
4774 }
4775 while (*subop <= (unsigned char) c)
4776 ++subop;
4777 --subop;
4778 break;
4779 /* The lower 32unwind bits must be persistent. */
4780 case 'U':
4781 saved_unwind_bits = var ('U');
4782 break;
4783
4784 default:
4785 break;
4786 }
4787 }
4788
4789 /* If we used a previous fixup, clean up after it. */
4790 if (prev_fixup)
4791 {
4792 fixup = save_fixup + 1;
4793 prev_fixup = 0;
4794 }
4795 /* Queue it. */
4796 else if (fixup > save_fixup + 1)
4797 som_reloc_queue_insert (save_fixup, fixup - save_fixup, reloc_queue);
4798
4799 /* We do not pass R_DATA_OVERRIDE or R_NO_RELOCATION
4800 fixups to BFD. */
4801 if (som_hppa_howto_table[op].type != R_DATA_OVERRIDE
4802 && som_hppa_howto_table[op].type != R_NO_RELOCATION)
4803 {
4804 /* Done with a single reloction. Loop back to the top. */
4805 if (! just_count)
4806 {
4807 if (som_hppa_howto_table[op].type == R_ENTRY)
4808 rptr->addend = var ('T');
4809 else if (som_hppa_howto_table[op].type == R_EXIT)
4810 rptr->addend = var ('U');
4811 else if (som_hppa_howto_table[op].type == R_PCREL_CALL
4812 || som_hppa_howto_table[op].type == R_ABS_CALL)
4813 ;
4814 else if (som_hppa_howto_table[op].type == R_DATA_ONE_SYMBOL)
4815 {
4816 unsigned addend = var ('V');
4817
4818 /* Try what was specified in R_DATA_OVERRIDE first
4819 (if anything). Then the hard way using the
4820 section contents. */
4821 rptr->addend = var ('V');
4822
4823 if (rptr->addend == 0 && !section->contents)
4824 {
4825 /* Got to read the damn contents first. We don't
4826 bother saving the contents (yet). Add it one
4827 day if the need arises. */
4828 section->contents = bfd_malloc (section->_raw_size);
4829 if (section->contents == NULL)
4830 return -1;
4831
4832 deallocate_contents = 1;
4833 bfd_get_section_contents (section->owner,
4834 section,
4835 section->contents,
4836 0,
4837 section->_raw_size);
4838 }
4839 else if (rptr->addend == 0)
4840 rptr->addend = bfd_get_32 (section->owner,
4841 (section->contents
4842 + offset - var ('L')));
4843
4844 }
4845 else
4846 rptr->addend = var ('V');
4847 rptr++;
4848 }
4849 count++;
4850 /* Now that we've handled a "full" relocation, reset
4851 some state. */
4852 memset (variables, 0, sizeof (variables));
4853 memset (stack, 0, sizeof (stack));
4854 }
4855 }
4856 if (deallocate_contents)
4857 free (section->contents);
4858
4859 return count;
4860
4861#undef var
4862#undef push
4863#undef pop
4864#undef emptystack
4865}
4866
4867/* Read in the relocs (aka fixups in SOM terms) for a section.
4868
4869 som_get_reloc_upper_bound calls this routine with JUST_COUNT
4870 set to true to indicate it only needs a count of the number
4871 of actual relocations. */
4872
4873static boolean
4874som_slurp_reloc_table (abfd, section, symbols, just_count)
4875 bfd *abfd;
4876 asection *section;
4877 asymbol **symbols;
4878 boolean just_count;
4879{
4880 char *external_relocs;
4881 unsigned int fixup_stream_size;
4882 arelent *internal_relocs;
4883 unsigned int num_relocs;
4884
4885 fixup_stream_size = som_section_data (section)->reloc_size;
4886 /* If there were no relocations, then there is nothing to do. */
4887 if (section->reloc_count == 0)
4888 return true;
4889
4890 /* If reloc_count is -1, then the relocation stream has not been
4891 parsed. We must do so now to know how many relocations exist. */
4892 if (section->reloc_count == -1)
4893 {
4894 external_relocs = (char *) bfd_malloc (fixup_stream_size);
4895 if (external_relocs == (char *) NULL)
4896 return false;
4897 /* Read in the external forms. */
4898 if (bfd_seek (abfd,
4899 obj_som_reloc_filepos (abfd) + section->rel_filepos,
4900 SEEK_SET)
4901 != 0)
4902 return false;
4903 if (bfd_read (external_relocs, 1, fixup_stream_size, abfd)
4904 != fixup_stream_size)
4905 return false;
4906
4907 /* Let callers know how many relocations found.
4908 also save the relocation stream as we will
4909 need it again. */
4910 section->reloc_count = som_set_reloc_info (external_relocs,
4911 fixup_stream_size,
4912 NULL, NULL, NULL, true);
4913
4914 som_section_data (section)->reloc_stream = external_relocs;
4915 }
4916
4917 /* If the caller only wanted a count, then return now. */
4918 if (just_count)
4919 return true;
4920
4921 num_relocs = section->reloc_count;
4922 external_relocs = som_section_data (section)->reloc_stream;
4923 /* Return saved information about the relocations if it is available. */
4924 if (section->relocation != (arelent *) NULL)
4925 return true;
4926
4927 internal_relocs = (arelent *)
4928 bfd_zalloc (abfd, (num_relocs * sizeof (arelent)));
4929 if (internal_relocs == (arelent *) NULL)
4930 return false;
4931
4932 /* Process and internalize the relocations. */
4933 som_set_reloc_info (external_relocs, fixup_stream_size,
4934 internal_relocs, section, symbols, false);
4935
4936 /* We're done with the external relocations. Free them. */
4937 free (external_relocs);
4938 som_section_data (section)->reloc_stream = NULL;
4939
4940 /* Save our results and return success. */
4941 section->relocation = internal_relocs;
4942 return (true);
4943}
4944
4945/* Return the number of bytes required to store the relocation
4946 information associated with the given section. */
4947
4948static long
4949som_get_reloc_upper_bound (abfd, asect)
4950 bfd *abfd;
4951 sec_ptr asect;
4952{
4953 /* If section has relocations, then read in the relocation stream
4954 and parse it to determine how many relocations exist. */
4955 if (asect->flags & SEC_RELOC)
4956 {
4957 if (! som_slurp_reloc_table (abfd, asect, NULL, true))
4958 return -1;
4959 return (asect->reloc_count + 1) * sizeof (arelent *);
4960 }
4961 /* There are no relocations. */
4962 return 0;
4963}
4964
4965/* Convert relocations from SOM (external) form into BFD internal
4966 form. Return the number of relocations. */
4967
4968static long
4969som_canonicalize_reloc (abfd, section, relptr, symbols)
4970 bfd *abfd;
4971 sec_ptr section;
4972 arelent **relptr;
4973 asymbol **symbols;
4974{
4975 arelent *tblptr;
4976 int count;
4977
4978 if (som_slurp_reloc_table (abfd, section, symbols, false) == false)
4979 return -1;
4980
4981 count = section->reloc_count;
4982 tblptr = section->relocation;
4983
4984 while (count--)
4985 *relptr++ = tblptr++;
4986
4987 *relptr = (arelent *) NULL;
4988 return section->reloc_count;
4989}
4990
4991extern const bfd_target som_vec;
4992
4993/* A hook to set up object file dependent section information. */
4994
4995static boolean
4996som_new_section_hook (abfd, newsect)
4997 bfd *abfd;
4998 asection *newsect;
4999{
5000 newsect->used_by_bfd =
5001 (PTR) bfd_zalloc (abfd, sizeof (struct som_section_data_struct));
5002 if (!newsect->used_by_bfd)
5003 return false;
5004 newsect->alignment_power = 3;
5005
5006 /* We allow more than three sections internally */
5007 return true;
5008}
5009
5010/* Copy any private info we understand from the input symbol
5011 to the output symbol. */
5012
5013static boolean
5014som_bfd_copy_private_symbol_data (ibfd, isymbol, obfd, osymbol)
5015 bfd *ibfd;
5016 asymbol *isymbol;
5017 bfd *obfd;
5018 asymbol *osymbol;
5019{
5020 struct som_symbol *input_symbol = (struct som_symbol *) isymbol;
5021 struct som_symbol *output_symbol = (struct som_symbol *) osymbol;
5022
5023 /* One day we may try to grok other private data. */
5024 if (ibfd->xvec->flavour != bfd_target_som_flavour
5025 || obfd->xvec->flavour != bfd_target_som_flavour)
5026 return false;
5027
5028 /* The only private information we need to copy is the argument relocation
5029 bits. */
5030 output_symbol->tc_data.ap.hppa_arg_reloc =
5031 input_symbol->tc_data.ap.hppa_arg_reloc;
5032
5033 return true;
5034}
5035
5036/* Copy any private info we understand from the input section
5037 to the output section. */
5038static boolean
5039som_bfd_copy_private_section_data (ibfd, isection, obfd, osection)
5040 bfd *ibfd;
5041 asection *isection;
5042 bfd *obfd;
5043 asection *osection;
5044{
5045 /* One day we may try to grok other private data. */
5046 if (ibfd->xvec->flavour != bfd_target_som_flavour
5047 || obfd->xvec->flavour != bfd_target_som_flavour
5048 || (!som_is_space (isection) && !som_is_subspace (isection)))
5049 return true;
5050
5051 som_section_data (osection)->copy_data
5052 = (struct som_copyable_section_data_struct *)
5053 bfd_zalloc (obfd, sizeof (struct som_copyable_section_data_struct));
5054 if (som_section_data (osection)->copy_data == NULL)
5055 return false;
5056
5057 memcpy (som_section_data (osection)->copy_data,
5058 som_section_data (isection)->copy_data,
5059 sizeof (struct som_copyable_section_data_struct));
5060
5061 /* Reparent if necessary. */
5062 if (som_section_data (osection)->copy_data->container)
5063 som_section_data (osection)->copy_data->container =
5064 som_section_data (osection)->copy_data->container->output_section;
5065
5066 return true;
5067}
5068
5069/* Copy any private info we understand from the input bfd
5070 to the output bfd. */
5071
5072static boolean
5073som_bfd_copy_private_bfd_data (ibfd, obfd)
5074 bfd *ibfd, *obfd;
5075{
5076 /* One day we may try to grok other private data. */
5077 if (ibfd->xvec->flavour != bfd_target_som_flavour
5078 || obfd->xvec->flavour != bfd_target_som_flavour)
5079 return true;
5080
5081 /* Allocate some memory to hold the data we need. */
5082 obj_som_exec_data (obfd) = (struct som_exec_data *)
5083 bfd_zalloc (obfd, sizeof (struct som_exec_data));
5084 if (obj_som_exec_data (obfd) == NULL)
5085 return false;
5086
5087 /* Now copy the data. */
5088 memcpy (obj_som_exec_data (obfd), obj_som_exec_data (ibfd),
5089 sizeof (struct som_exec_data));
5090
5091 return true;
5092}
5093
5094/* Set backend info for sections which can not be described
5095 in the BFD data structures. */
5096
5097boolean
5098bfd_som_set_section_attributes (section, defined, private, sort_key, spnum)
5099 asection *section;
5100 int defined;
5101 int private;
5102 unsigned int sort_key;
5103 int spnum;
5104{
5105 /* Allocate memory to hold the magic information. */
5106 if (som_section_data (section)->copy_data == NULL)
5107 {
5108 som_section_data (section)->copy_data
5109 = (struct som_copyable_section_data_struct *)
5110 bfd_zalloc (section->owner,
5111 sizeof (struct som_copyable_section_data_struct));
5112 if (som_section_data (section)->copy_data == NULL)
5113 return false;
5114 }
5115 som_section_data (section)->copy_data->sort_key = sort_key;
5116 som_section_data (section)->copy_data->is_defined = defined;
5117 som_section_data (section)->copy_data->is_private = private;
5118 som_section_data (section)->copy_data->container = section;
5119 som_section_data (section)->copy_data->space_number = spnum;
5120 return true;
5121}
5122
5123/* Set backend info for subsections which can not be described
5124 in the BFD data structures. */
5125
5126boolean
5127bfd_som_set_subsection_attributes (section, container, access,
5128 sort_key, quadrant)
5129 asection *section;
5130 asection *container;
5131 int access;
5132 unsigned int sort_key;
5133 int quadrant;
5134{
5135 /* Allocate memory to hold the magic information. */
5136 if (som_section_data (section)->copy_data == NULL)
5137 {
5138 som_section_data (section)->copy_data
5139 = (struct som_copyable_section_data_struct *)
5140 bfd_zalloc (section->owner,
5141 sizeof (struct som_copyable_section_data_struct));
5142 if (som_section_data (section)->copy_data == NULL)
5143 return false;
5144 }
5145 som_section_data (section)->copy_data->sort_key = sort_key;
5146 som_section_data (section)->copy_data->access_control_bits = access;
5147 som_section_data (section)->copy_data->quadrant = quadrant;
5148 som_section_data (section)->copy_data->container = container;
5149 return true;
5150}
5151
5152/* Set the full SOM symbol type. SOM needs far more symbol information
5153 than any other object file format I'm aware of. It is mandatory
5154 to be able to know if a symbol is an entry point, millicode, data,
5155 code, absolute, storage request, or procedure label. If you get
5156 the symbol type wrong your program will not link. */
5157
5158void
5159bfd_som_set_symbol_type (symbol, type)
5160 asymbol *symbol;
5161 unsigned int type;
5162{
5163 som_symbol_data (symbol)->som_type = type;
5164}
5165
5166/* Attach an auxiliary header to the BFD backend so that it may be
5167 written into the object file. */
5168boolean
5169bfd_som_attach_aux_hdr (abfd, type, string)
5170 bfd *abfd;
5171 int type;
5172 char *string;
5173{
5174 if (type == VERSION_AUX_ID)
5175 {
5176 int len = strlen (string);
5177 int pad = 0;
5178
5179 if (len % 4)
5180 pad = (4 - (len % 4));
5181 obj_som_version_hdr (abfd) = (struct user_string_aux_hdr *)
5182 bfd_zalloc (abfd, sizeof (struct aux_id)
5183 + sizeof (unsigned int) + len + pad);
5184 if (!obj_som_version_hdr (abfd))
5185 return false;
5186 obj_som_version_hdr (abfd)->header_id.type = VERSION_AUX_ID;
5187 obj_som_version_hdr (abfd)->header_id.length = len + pad;
5188 obj_som_version_hdr (abfd)->header_id.length += sizeof (int);
5189 obj_som_version_hdr (abfd)->string_length = len;
5190 strncpy (obj_som_version_hdr (abfd)->user_string, string, len);
5191 }
5192 else if (type == COPYRIGHT_AUX_ID)
5193 {
5194 int len = strlen (string);
5195 int pad = 0;
5196
5197 if (len % 4)
5198 pad = (4 - (len % 4));
5199 obj_som_copyright_hdr (abfd) = (struct copyright_aux_hdr *)
5200 bfd_zalloc (abfd, sizeof (struct aux_id)
5201 + sizeof (unsigned int) + len + pad);
5202 if (!obj_som_copyright_hdr (abfd))
5203 return false;
5204 obj_som_copyright_hdr (abfd)->header_id.type = COPYRIGHT_AUX_ID;
5205 obj_som_copyright_hdr (abfd)->header_id.length = len + pad;
5206 obj_som_copyright_hdr (abfd)->header_id.length += sizeof (int);
5207 obj_som_copyright_hdr (abfd)->string_length = len;
5208 strcpy (obj_som_copyright_hdr (abfd)->copyright, string);
5209 }
5210 return true;
5211}
5212
5213/* Attach an compilation unit header to the BFD backend so that it may be
5214 written into the object file. */
5215
5216boolean
5217bfd_som_attach_compilation_unit (abfd, name, language_name, product_id,
5218 version_id)
5219 bfd *abfd;
5220 const char *name;
5221 const char *language_name;
5222 const char *product_id;
5223 const char *version_id;
5224{
5225 COMPUNIT *n = (COMPUNIT *) bfd_zalloc (abfd, COMPUNITSZ);
5226 if (n == NULL)
5227 return false;
5228
5229#define STRDUP(f) \
5230 if (f != NULL) \
5231 { \
5232 n->f.n_name = bfd_alloc (abfd, strlen (f) + 1); \
5233 if (n->f.n_name == NULL) \
5234 return false; \
5235 strcpy (n->f.n_name, f); \
5236 }
5237
5238 STRDUP (name);
5239 STRDUP (language_name);
5240 STRDUP (product_id);
5241 STRDUP (version_id);
5242
5243#undef STRDUP
5244
5245 obj_som_compilation_unit (abfd) = n;
5246
5247 return true;
5248}
5249
5250static boolean
5251som_get_section_contents (abfd, section, location, offset, count)
5252 bfd *abfd;
5253 sec_ptr section;
5254 PTR location;
5255 file_ptr offset;
5256 bfd_size_type count;
5257{
5258 if (count == 0 || ((section->flags & SEC_HAS_CONTENTS) == 0))
5259 return true;
5260 if ((bfd_size_type)(offset+count) > section->_raw_size
5261 || bfd_seek (abfd, (file_ptr)(section->filepos + offset), SEEK_SET) == -1
5262 || bfd_read (location, (bfd_size_type)1, count, abfd) != count)
5263 return (false); /* on error */
5264 return (true);
5265}
5266
5267static boolean
5268som_set_section_contents (abfd, section, location, offset, count)
5269 bfd *abfd;
5270 sec_ptr section;
5271 PTR location;
5272 file_ptr offset;
5273 bfd_size_type count;
5274{
5275 if (abfd->output_has_begun == false)
5276 {
5277 /* Set up fixed parts of the file, space, and subspace headers.
5278 Notify the world that output has begun. */
5279 som_prep_headers (abfd);
5280 abfd->output_has_begun = true;
5281 /* Start writing the object file. This include all the string
5282 tables, fixup streams, and other portions of the object file. */
5283 som_begin_writing (abfd);
5284 }
5285
5286 /* Only write subspaces which have "real" contents (eg. the contents
5287 are not generated at run time by the OS). */
5288 if (!som_is_subspace (section)
5289 || ((section->flags & SEC_HAS_CONTENTS) == 0))
5290 return true;
5291
5292 /* Seek to the proper offset within the object file and write the
5293 data. */
5294 offset += som_section_data (section)->subspace_dict->file_loc_init_value;
5295 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
5296 return false;
5297
5298 if (bfd_write ((PTR) location, 1, count, abfd) != count)
5299 return false;
5300 return true;
5301}
5302
5303static boolean
5304som_set_arch_mach (abfd, arch, machine)
5305 bfd *abfd;
5306 enum bfd_architecture arch;
5307 unsigned long machine;
5308{
5309 /* Allow any architecture to be supported by the SOM backend */
5310 return bfd_default_set_arch_mach (abfd, arch, machine);
5311}
5312
5313static boolean
5314som_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
5315 functionname_ptr, line_ptr)
5316 bfd *abfd;
5317 asection *section;
5318 asymbol **symbols;
5319 bfd_vma offset;
5320 CONST char **filename_ptr;
5321 CONST char **functionname_ptr;
5322 unsigned int *line_ptr;
5323{
5324 return (false);
5325}
5326
5327static int
5328som_sizeof_headers (abfd, reloc)
5329 bfd *abfd;
5330 boolean reloc;
5331{
5332 (*_bfd_error_handler) (_("som_sizeof_headers unimplemented"));
5333 fflush (stderr);
5334 abort ();
5335 return (0);
5336}
5337
5338/* Return the single-character symbol type corresponding to
5339 SOM section S, or '?' for an unknown SOM section. */
5340
5341static char
5342som_section_type (s)
5343 const char *s;
5344{
5345 const struct section_to_type *t;
5346
5347 for (t = &stt[0]; t->section; t++)
5348 if (!strcmp (s, t->section))
5349 return t->type;
5350 return '?';
5351}
5352
5353static int
5354som_decode_symclass (symbol)
5355 asymbol *symbol;
5356{
5357 char c;
5358
5359 if (bfd_is_com_section (symbol->section))
5360 return 'C';
5361 if (bfd_is_und_section (symbol->section))
5362 return 'U';
5363 if (bfd_is_ind_section (symbol->section))
5364 return 'I';
5365 if (!(symbol->flags & (BSF_GLOBAL|BSF_LOCAL)))
5366 return '?';
5367
5368 if (bfd_is_abs_section (symbol->section)
5369 || (som_symbol_data (symbol) != NULL
5370 && som_symbol_data (symbol)->som_type == SYMBOL_TYPE_ABSOLUTE))
5371 c = 'a';
5372 else if (symbol->section)
5373 c = som_section_type (symbol->section->name);
5374 else
5375 return '?';
5376 if (symbol->flags & BSF_GLOBAL)
5377 c = toupper (c);
5378 return c;
5379}
5380
5381/* Return information about SOM symbol SYMBOL in RET. */
5382
5383static void
5384som_get_symbol_info (ignore_abfd, symbol, ret)
5385 bfd *ignore_abfd;
5386 asymbol *symbol;
5387 symbol_info *ret;
5388{
5389 ret->type = som_decode_symclass (symbol);
5390 if (ret->type != 'U')
5391 ret->value = symbol->value+symbol->section->vma;
5392 else
5393 ret->value = 0;
5394 ret->name = symbol->name;
5395}
5396
5397/* Count the number of symbols in the archive symbol table. Necessary
5398 so that we can allocate space for all the carsyms at once. */
5399
5400static boolean
5401som_bfd_count_ar_symbols (abfd, lst_header, count)
5402 bfd *abfd;
5403 struct lst_header *lst_header;
5404 symindex *count;
5405{
5406 unsigned int i;
5407 unsigned int *hash_table = NULL;
5408 file_ptr lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
5409
5410 hash_table =
5411 (unsigned int *) bfd_malloc (lst_header->hash_size
5412 * sizeof (unsigned int));
5413 if (hash_table == NULL && lst_header->hash_size != 0)
5414 goto error_return;
5415
5416 /* Don't forget to initialize the counter! */
5417 *count = 0;
5418
5419 /* Read in the hash table. The has table is an array of 32bit file offsets
5420 which point to the hash chains. */
5421 if (bfd_read ((PTR) hash_table, lst_header->hash_size, 4, abfd)
5422 != lst_header->hash_size * 4)
5423 goto error_return;
5424
5425 /* Walk each chain counting the number of symbols found on that particular
5426 chain. */
5427 for (i = 0; i < lst_header->hash_size; i++)
5428 {
5429 struct lst_symbol_record lst_symbol;
5430
5431 /* An empty chain has zero as it's file offset. */
5432 if (hash_table[i] == 0)
5433 continue;
5434
5435 /* Seek to the first symbol in this hash chain. */
5436 if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
5437 goto error_return;
5438
5439 /* Read in this symbol and update the counter. */
5440 if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
5441 != sizeof (lst_symbol))
5442 goto error_return;
5443
5444 (*count)++;
5445
5446 /* Now iterate through the rest of the symbols on this chain. */
5447 while (lst_symbol.next_entry)
5448 {
5449
5450 /* Seek to the next symbol. */
5451 if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET)
5452 < 0)
5453 goto error_return;
5454
5455 /* Read the symbol in and update the counter. */
5456 if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
5457 != sizeof (lst_symbol))
5458 goto error_return;
5459
5460 (*count)++;
5461 }
5462 }
5463 if (hash_table != NULL)
5464 free (hash_table);
5465 return true;
5466
5467 error_return:
5468 if (hash_table != NULL)
5469 free (hash_table);
5470 return false;
5471}
5472
5473/* Fill in the canonical archive symbols (SYMS) from the archive described
5474 by ABFD and LST_HEADER. */
5475
5476static boolean
5477som_bfd_fill_in_ar_symbols (abfd, lst_header, syms)
5478 bfd *abfd;
5479 struct lst_header *lst_header;
5480 carsym **syms;
5481{
5482 unsigned int i, len;
5483 carsym *set = syms[0];
5484 unsigned int *hash_table = NULL;
5485 struct som_entry *som_dict = NULL;
5486 file_ptr lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
5487
5488 hash_table =
5489 (unsigned int *) bfd_malloc (lst_header->hash_size
5490 * sizeof (unsigned int));
5491 if (hash_table == NULL && lst_header->hash_size != 0)
5492 goto error_return;
5493
5494 som_dict =
5495 (struct som_entry *) bfd_malloc (lst_header->module_count
5496 * sizeof (struct som_entry));
5497 if (som_dict == NULL && lst_header->module_count != 0)
5498 goto error_return;
5499
5500 /* Read in the hash table. The has table is an array of 32bit file offsets
5501 which point to the hash chains. */
5502 if (bfd_read ((PTR) hash_table, lst_header->hash_size, 4, abfd)
5503 != lst_header->hash_size * 4)
5504 goto error_return;
5505
5506 /* Seek to and read in the SOM dictionary. We will need this to fill
5507 in the carsym's filepos field. */
5508 if (bfd_seek (abfd, lst_filepos + lst_header->dir_loc, SEEK_SET) < 0)
5509 goto error_return;
5510
5511 if (bfd_read ((PTR) som_dict, lst_header->module_count,
5512 sizeof (struct som_entry), abfd)
5513 != lst_header->module_count * sizeof (struct som_entry))
5514 goto error_return;
5515
5516 /* Walk each chain filling in the carsyms as we go along. */
5517 for (i = 0; i < lst_header->hash_size; i++)
5518 {
5519 struct lst_symbol_record lst_symbol;
5520
5521 /* An empty chain has zero as it's file offset. */
5522 if (hash_table[i] == 0)
5523 continue;
5524
5525 /* Seek to and read the first symbol on the chain. */
5526 if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
5527 goto error_return;
5528
5529 if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
5530 != sizeof (lst_symbol))
5531 goto error_return;
5532
5533 /* Get the name of the symbol, first get the length which is stored
5534 as a 32bit integer just before the symbol.
5535
5536 One might ask why we don't just read in the entire string table
5537 and index into it. Well, according to the SOM ABI the string
5538 index can point *anywhere* in the archive to save space, so just
5539 using the string table would not be safe. */
5540 if (bfd_seek (abfd, lst_filepos + lst_header->string_loc
5541 + lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
5542 goto error_return;
5543
5544 if (bfd_read (&len, 1, 4, abfd) != 4)
5545 goto error_return;
5546
5547 /* Allocate space for the name and null terminate it too. */
5548 set->name = bfd_zalloc (abfd, len + 1);
5549 if (!set->name)
5550 goto error_return;
5551 if (bfd_read (set->name, 1, len, abfd) != len)
5552 goto error_return;
5553
5554 set->name[len] = 0;
5555
5556 /* Fill in the file offset. Note that the "location" field points
5557 to the SOM itself, not the ar_hdr in front of it. */
5558 set->file_offset = som_dict[lst_symbol.som_index].location
5559 - sizeof (struct ar_hdr);
5560
5561 /* Go to the next symbol. */
5562 set++;
5563
5564 /* Iterate through the rest of the chain. */
5565 while (lst_symbol.next_entry)
5566 {
5567 /* Seek to the next symbol and read it in. */
5568 if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET) <0)
5569 goto error_return;
5570
5571 if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
5572 != sizeof (lst_symbol))
5573 goto error_return;
5574
5575 /* Seek to the name length & string and read them in. */
5576 if (bfd_seek (abfd, lst_filepos + lst_header->string_loc
5577 + lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
5578 goto error_return;
5579
5580 if (bfd_read (&len, 1, 4, abfd) != 4)
5581 goto error_return;
5582
5583 /* Allocate space for the name and null terminate it too. */
5584 set->name = bfd_zalloc (abfd, len + 1);
5585 if (!set->name)
5586 goto error_return;
5587
5588 if (bfd_read (set->name, 1, len, abfd) != len)
5589 goto error_return;
5590 set->name[len] = 0;
5591
5592 /* Fill in the file offset. Note that the "location" field points
5593 to the SOM itself, not the ar_hdr in front of it. */
5594 set->file_offset = som_dict[lst_symbol.som_index].location
5595 - sizeof (struct ar_hdr);
5596
5597 /* Go on to the next symbol. */
5598 set++;
5599 }
5600 }
5601 /* If we haven't died by now, then we successfully read the entire
5602 archive symbol table. */
5603 if (hash_table != NULL)
5604 free (hash_table);
5605 if (som_dict != NULL)
5606 free (som_dict);
5607 return true;
5608
5609 error_return:
5610 if (hash_table != NULL)
5611 free (hash_table);
5612 if (som_dict != NULL)
5613 free (som_dict);
5614 return false;
5615}
5616
5617/* Read in the LST from the archive. */
5618static boolean
5619som_slurp_armap (abfd)
5620 bfd *abfd;
5621{
5622 struct lst_header lst_header;
5623 struct ar_hdr ar_header;
5624 unsigned int parsed_size;
5625 struct artdata *ardata = bfd_ardata (abfd);
5626 char nextname[17];
5627 int i = bfd_read ((PTR) nextname, 1, 16, abfd);
5628
5629 /* Special cases. */
5630 if (i == 0)
5631 return true;
5632 if (i != 16)
5633 return false;
5634
5635 if (bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR) < 0)
5636 return false;
5637
5638 /* For archives without .o files there is no symbol table. */
5639 if (strncmp (nextname, "/ ", 16))
5640 {
5641 bfd_has_map (abfd) = false;
5642 return true;
5643 }
5644
5645 /* Read in and sanity check the archive header. */
5646 if (bfd_read ((PTR) &ar_header, 1, sizeof (struct ar_hdr), abfd)
5647 != sizeof (struct ar_hdr))
5648 return false;
5649
5650 if (strncmp (ar_header.ar_fmag, ARFMAG, 2))
5651 {
5652 bfd_set_error (bfd_error_malformed_archive);
5653 return false;
5654 }
5655
5656 /* How big is the archive symbol table entry? */
5657 errno = 0;
5658 parsed_size = strtol (ar_header.ar_size, NULL, 10);
5659 if (errno != 0)
5660 {
5661 bfd_set_error (bfd_error_malformed_archive);
5662 return false;
5663 }
5664
5665 /* Save off the file offset of the first real user data. */
5666 ardata->first_file_filepos = bfd_tell (abfd) + parsed_size;
5667
5668 /* Read in the library symbol table. We'll make heavy use of this
5669 in just a minute. */
5670 if (bfd_read ((PTR) & lst_header, 1, sizeof (struct lst_header), abfd)
5671 != sizeof (struct lst_header))
5672 return false;
5673
5674 /* Sanity check. */
5675 if (lst_header.a_magic != LIBMAGIC)
5676 {
5677 bfd_set_error (bfd_error_malformed_archive);
5678 return false;
5679 }
5680
5681 /* Count the number of symbols in the library symbol table. */
5682 if (som_bfd_count_ar_symbols (abfd, &lst_header, &ardata->symdef_count)
5683 == false)
5684 return false;
5685
5686 /* Get back to the start of the library symbol table. */
5687 if (bfd_seek (abfd, ardata->first_file_filepos - parsed_size
5688 + sizeof (struct lst_header), SEEK_SET) < 0)
5689 return false;
5690
5691 /* Initializae the cache and allocate space for the library symbols. */
5692 ardata->cache = 0;
5693 ardata->symdefs = (carsym *) bfd_alloc (abfd,
5694 (ardata->symdef_count
5695 * sizeof (carsym)));
5696 if (!ardata->symdefs)
5697 return false;
5698
5699 /* Now fill in the canonical archive symbols. */
5700 if (som_bfd_fill_in_ar_symbols (abfd, &lst_header, &ardata->symdefs)
5701 == false)
5702 return false;
5703
5704 /* Seek back to the "first" file in the archive. Note the "first"
5705 file may be the extended name table. */
5706 if (bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET) < 0)
5707 return false;
5708
5709 /* Notify the generic archive code that we have a symbol map. */
5710 bfd_has_map (abfd) = true;
5711 return true;
5712}
5713
5714/* Begin preparing to write a SOM library symbol table.
5715
5716 As part of the prep work we need to determine the number of symbols
5717 and the size of the associated string section. */
5718
5719static boolean
5720som_bfd_prep_for_ar_write (abfd, num_syms, stringsize)
5721 bfd *abfd;
5722 unsigned int *num_syms, *stringsize;
5723{
5724 bfd *curr_bfd = abfd->archive_head;
5725
5726 /* Some initialization. */
5727 *num_syms = 0;
5728 *stringsize = 0;
5729
5730 /* Iterate over each BFD within this archive. */
5731 while (curr_bfd != NULL)
5732 {
5733 unsigned int curr_count, i;
5734 som_symbol_type *sym;
5735
5736 /* Don't bother for non-SOM objects. */
5737 if (curr_bfd->format != bfd_object
5738 || curr_bfd->xvec->flavour != bfd_target_som_flavour)
5739 {
5740 curr_bfd = curr_bfd->next;
5741 continue;
5742 }
5743
5744 /* Make sure the symbol table has been read, then snag a pointer
5745 to it. It's a little slimey to grab the symbols via obj_som_symtab,
5746 but doing so avoids allocating lots of extra memory. */
5747 if (som_slurp_symbol_table (curr_bfd) == false)
5748 return false;
5749
5750 sym = obj_som_symtab (curr_bfd);
5751 curr_count = bfd_get_symcount (curr_bfd);
5752
5753 /* Examine each symbol to determine if it belongs in the
5754 library symbol table. */
5755 for (i = 0; i < curr_count; i++, sym++)
5756 {
5757 struct som_misc_symbol_info info;
5758
5759 /* Derive SOM information from the BFD symbol. */
5760 som_bfd_derive_misc_symbol_info (curr_bfd, &sym->symbol, &info);
5761
5762 /* Should we include this symbol? */
5763 if (info.symbol_type == ST_NULL
5764 || info.symbol_type == ST_SYM_EXT
5765 || info.symbol_type == ST_ARG_EXT)
5766 continue;
5767
5768 /* Only global symbols and unsatisfied commons. */
5769 if (info.symbol_scope != SS_UNIVERSAL
5770 && info.symbol_type != ST_STORAGE)
5771 continue;
5772
5773 /* Do no include undefined symbols. */
5774 if (bfd_is_und_section (sym->symbol.section))
5775 continue;
5776
5777 /* Bump the various counters, being careful to honor
5778 alignment considerations in the string table. */
5779 (*num_syms)++;
5780 *stringsize = *stringsize + strlen (sym->symbol.name) + 5;
5781 while (*stringsize % 4)
5782 (*stringsize)++;
5783 }
5784
5785 curr_bfd = curr_bfd->next;
5786 }
5787 return true;
5788}
5789
5790/* Hash a symbol name based on the hashing algorithm presented in the
5791 SOM ABI. */
5792static unsigned int
5793som_bfd_ar_symbol_hash (symbol)
5794 asymbol *symbol;
5795{
5796 unsigned int len = strlen (symbol->name);
5797
5798 /* Names with length 1 are special. */
5799 if (len == 1)
5800 return 0x1000100 | (symbol->name[0] << 16) | symbol->name[0];
5801
5802 return ((len & 0x7f) << 24) | (symbol->name[1] << 16)
5803 | (symbol->name[len-2] << 8) | symbol->name[len-1];
5804}
5805
5806/* Do the bulk of the work required to write the SOM library
5807 symbol table. */
5808
5809static boolean
5810som_bfd_ar_write_symbol_stuff (abfd, nsyms, string_size, lst, elength)
5811 bfd *abfd;
5812 unsigned int nsyms, string_size;
5813 struct lst_header lst;
5814 unsigned elength;
5815{
5816 file_ptr lst_filepos;
5817 char *strings = NULL, *p;
5818 struct lst_symbol_record *lst_syms = NULL, *curr_lst_sym;
5819 bfd *curr_bfd;
5820 unsigned int *hash_table = NULL;
5821 struct som_entry *som_dict = NULL;
5822 struct lst_symbol_record **last_hash_entry = NULL;
5823 unsigned int curr_som_offset, som_index = 0;
5824
5825 hash_table =
5826 (unsigned int *) bfd_malloc (lst.hash_size * sizeof (unsigned int));
5827 if (hash_table == NULL && lst.hash_size != 0)
5828 goto error_return;
5829 som_dict =
5830 (struct som_entry *) bfd_malloc (lst.module_count
5831 * sizeof (struct som_entry));
5832 if (som_dict == NULL && lst.module_count != 0)
5833 goto error_return;
5834
5835 last_hash_entry =
5836 ((struct lst_symbol_record **)
5837 bfd_malloc (lst.hash_size * sizeof (struct lst_symbol_record *)));
5838 if (last_hash_entry == NULL && lst.hash_size != 0)
5839 goto error_return;
5840
5841 /* Lots of fields are file positions relative to the start
5842 of the lst record. So save its location. */
5843 lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
5844
5845 /* Some initialization. */
5846 memset (hash_table, 0, 4 * lst.hash_size);
5847 memset (som_dict, 0, lst.module_count * sizeof (struct som_entry));
5848 memset (last_hash_entry, 0,
5849 lst.hash_size * sizeof (struct lst_symbol_record *));
5850
5851 /* Symbols have som_index fields, so we have to keep track of the
5852 index of each SOM in the archive.
5853
5854 The SOM dictionary has (among other things) the absolute file
5855 position for the SOM which a particular dictionary entry
5856 describes. We have to compute that information as we iterate
5857 through the SOMs/symbols. */
5858 som_index = 0;
5859
5860 /* We add in the size of the archive header twice as the location
5861 in the SOM dictionary is the actual offset of the SOM, not the
5862 archive header before the SOM. */
5863 curr_som_offset = 8 + 2 * sizeof (struct ar_hdr) + lst.file_end;
5864
5865 /* Make room for the archive header and the contents of the
5866 extended string table. Note that elength includes the size
5867 of the archive header for the extended name table! */
5868 if (elength)
5869 curr_som_offset += elength;
5870
5871 /* Make sure we're properly aligned. */
5872 curr_som_offset = (curr_som_offset + 0x1) & ~0x1;
5873
5874 /* FIXME should be done with buffers just like everything else... */
5875 lst_syms = bfd_malloc (nsyms * sizeof (struct lst_symbol_record));
5876 if (lst_syms == NULL && nsyms != 0)
5877 goto error_return;
5878 strings = bfd_malloc (string_size);
5879 if (strings == NULL && string_size != 0)
5880 goto error_return;
5881
5882 p = strings;
5883 curr_lst_sym = lst_syms;
5884
5885 curr_bfd = abfd->archive_head;
5886 while (curr_bfd != NULL)
5887 {
5888 unsigned int curr_count, i;
5889 som_symbol_type *sym;
5890
5891 /* Don't bother for non-SOM objects. */
5892 if (curr_bfd->format != bfd_object
5893 || curr_bfd->xvec->flavour != bfd_target_som_flavour)
5894 {
5895 curr_bfd = curr_bfd->next;
5896 continue;
5897 }
5898
5899 /* Make sure the symbol table has been read, then snag a pointer
5900 to it. It's a little slimey to grab the symbols via obj_som_symtab,
5901 but doing so avoids allocating lots of extra memory. */
5902 if (som_slurp_symbol_table (curr_bfd) == false)
5903 goto error_return;
5904
5905 sym = obj_som_symtab (curr_bfd);
5906 curr_count = bfd_get_symcount (curr_bfd);
5907
5908 for (i = 0; i < curr_count; i++, sym++)
5909 {
5910 struct som_misc_symbol_info info;
5911
5912 /* Derive SOM information from the BFD symbol. */
5913 som_bfd_derive_misc_symbol_info (curr_bfd, &sym->symbol, &info);
5914
5915 /* Should we include this symbol? */
5916 if (info.symbol_type == ST_NULL
5917 || info.symbol_type == ST_SYM_EXT
5918 || info.symbol_type == ST_ARG_EXT)
5919 continue;
5920
5921 /* Only global symbols and unsatisfied commons. */
5922 if (info.symbol_scope != SS_UNIVERSAL
5923 && info.symbol_type != ST_STORAGE)
5924 continue;
5925
5926 /* Do no include undefined symbols. */
5927 if (bfd_is_und_section (sym->symbol.section))
5928 continue;
5929
5930 /* If this is the first symbol from this SOM, then update
5931 the SOM dictionary too. */
5932 if (som_dict[som_index].location == 0)
5933 {
5934 som_dict[som_index].location = curr_som_offset;
5935 som_dict[som_index].length = arelt_size (curr_bfd);
5936 }
5937
5938 /* Fill in the lst symbol record. */
5939 curr_lst_sym->hidden = 0;
ba20314e 5940 curr_lst_sym->secondary_def = info.secondary_def;
252b5132
RH		 5941 curr_lst_sym->symbol_type = info.symbol_type;
5942 curr_lst_sym->symbol_scope = info.symbol_scope;
5943 curr_lst_sym->check_level = 0;
5944 curr_lst_sym->must_qualify = 0;
5945 curr_lst_sym->initially_frozen = 0;
5946 curr_lst_sym->memory_resident = 0;
5947 curr_lst_sym->is_common = bfd_is_com_section (sym->symbol.section);
5948 curr_lst_sym->dup_common = 0;
5949 curr_lst_sym->xleast = 3;
5950 curr_lst_sym->arg_reloc = info.arg_reloc;
5951 curr_lst_sym->name.n_strx = p - strings + 4;
5952 curr_lst_sym->qualifier_name.n_strx = 0;
5953 curr_lst_sym->symbol_info = info.symbol_info;
5954 curr_lst_sym->symbol_value = info.symbol_value | info.priv_level;
5955 curr_lst_sym->symbol_descriptor = 0;
5956 curr_lst_sym->reserved = 0;
5957 curr_lst_sym->som_index = som_index;
5958 curr_lst_sym->symbol_key = som_bfd_ar_symbol_hash (&sym->symbol);
5959 curr_lst_sym->next_entry = 0;
5960
5961 /* Insert into the hash table. */
5962 if (hash_table[curr_lst_sym->symbol_key % lst.hash_size])
5963 {
5964 struct lst_symbol_record *tmp;
5965
5966 /* There is already something at the head of this hash chain,
5967 so tack this symbol onto the end of the chain. */
5968 tmp = last_hash_entry[curr_lst_sym->symbol_key % lst.hash_size];
5969 tmp->next_entry
5970 = (curr_lst_sym - lst_syms) * sizeof (struct lst_symbol_record)
5971 + lst.hash_size * 4
5972 + lst.module_count * sizeof (struct som_entry)
5973 + sizeof (struct lst_header);
5974 }
5975 else
5976 {
5977 /* First entry in this hash chain. */
5978 hash_table[curr_lst_sym->symbol_key % lst.hash_size]
5979 = (curr_lst_sym - lst_syms) * sizeof (struct lst_symbol_record)
5980 + lst.hash_size * 4
5981 + lst.module_count * sizeof (struct som_entry)
5982 + sizeof (struct lst_header);
5983 }
5984
5985 /* Keep track of the last symbol we added to this chain so we can
5986 easily update its next_entry pointer. */
5987 last_hash_entry[curr_lst_sym->symbol_key % lst.hash_size]
5988 = curr_lst_sym;
5989
5990
5991 /* Update the string table. */
5992 bfd_put_32 (abfd, strlen (sym->symbol.name), p);
5993 p += 4;
5994 strcpy (p, sym->symbol.name);
5995 p += strlen (sym->symbol.name) + 1;
5996 while ((int)p % 4)
5997 {
5998 bfd_put_8 (abfd, 0, p);
5999 p++;
6000 }
6001
6002 /* Head to the next symbol. */
6003 curr_lst_sym++;
6004 }
6005
6006 /* Keep track of where each SOM will finally reside; then look
6007 at the next BFD. */
6008 curr_som_offset += arelt_size (curr_bfd) + sizeof (struct ar_hdr);
6009
6010 /* A particular object in the archive may have an odd length; the
6011 linker requires objects begin on an even boundary. So round
6012 up the current offset as necessary. */
6013 curr_som_offset = (curr_som_offset + 0x1) & ~0x1;
6014 curr_bfd = curr_bfd->next;
6015 som_index++;
6016 }
6017
6018 /* Now scribble out the hash table. */
6019 if (bfd_write ((PTR) hash_table, lst.hash_size, 4, abfd)
6020 != lst.hash_size * 4)
6021 goto error_return;
6022
6023 /* Then the SOM dictionary. */
6024 if (bfd_write ((PTR) som_dict, lst.module_count,
6025 sizeof (struct som_entry), abfd)
6026 != lst.module_count * sizeof (struct som_entry))
6027 goto error_return;
6028
6029 /* The library symbols. */
6030 if (bfd_write ((PTR) lst_syms, nsyms, sizeof (struct lst_symbol_record), abfd)
6031 != nsyms * sizeof (struct lst_symbol_record))
6032 goto error_return;
6033
6034 /* And finally the strings. */
6035 if (bfd_write ((PTR) strings, string_size, 1, abfd) != string_size)
6036 goto error_return;
6037
6038 if (hash_table != NULL)
6039 free (hash_table);
6040 if (som_dict != NULL)
6041 free (som_dict);
6042 if (last_hash_entry != NULL)
6043 free (last_hash_entry);
6044 if (lst_syms != NULL)
6045 free (lst_syms);
6046 if (strings != NULL)
6047 free (strings);
6048 return true;
6049
6050 error_return:
6051 if (hash_table != NULL)
6052 free (hash_table);
6053 if (som_dict != NULL)
6054 free (som_dict);
6055 if (last_hash_entry != NULL)
6056 free (last_hash_entry);
6057 if (lst_syms != NULL)
6058 free (lst_syms);
6059 if (strings != NULL)
6060 free (strings);
6061
6062 return false;
6063}
6064
6065/* Write out the LST for the archive.
6066
6067 You'll never believe this is really how armaps are handled in SOM... */
6068
6069/*ARGSUSED*/
6070static boolean
6071som_write_armap (abfd, elength, map, orl_count, stridx)
6072 bfd *abfd;
6073 unsigned int elength;
6074 struct orl *map;
6075 unsigned int orl_count;
6076 int stridx;
6077{
6078 bfd *curr_bfd;
6079 struct stat statbuf;
6080 unsigned int i, lst_size, nsyms, stringsize;
6081 struct ar_hdr hdr;
6082 struct lst_header lst;
6083 int *p;
6084
6085 /* We'll use this for the archive's date and mode later. */
6086 if (stat (abfd->filename, &statbuf) != 0)
6087 {
6088 bfd_set_error (bfd_error_system_call);
6089 return false;
6090 }
6091 /* Fudge factor. */
6092 bfd_ardata (abfd)->armap_timestamp = statbuf.st_mtime + 60;
6093
6094 /* Account for the lst header first. */
6095 lst_size = sizeof (struct lst_header);
6096
6097 /* Start building the LST header. */
6098 /* FIXME: Do we need to examine each element to determine the
6099 largest id number? */
6100 lst.system_id = CPU_PA_RISC1_0;
6101 lst.a_magic = LIBMAGIC;
6102 lst.version_id = VERSION_ID;
6103 lst.file_time.secs = 0;
6104 lst.file_time.nanosecs = 0;
6105
6106 lst.hash_loc = lst_size;
6107 lst.hash_size = SOM_LST_HASH_SIZE;
6108
6109 /* Hash table is a SOM_LST_HASH_SIZE 32bit offsets. */
6110 lst_size += 4 * SOM_LST_HASH_SIZE;
6111
6112 /* We need to count the number of SOMs in this archive. */
6113 curr_bfd = abfd->archive_head;
6114 lst.module_count = 0;
6115 while (curr_bfd != NULL)
6116 {
6117 /* Only true SOM objects count. */
6118 if (curr_bfd->format == bfd_object
6119 && curr_bfd->xvec->flavour == bfd_target_som_flavour)
6120 lst.module_count++;
6121 curr_bfd = curr_bfd->next;
6122 }
6123 lst.module_limit = lst.module_count;
6124 lst.dir_loc = lst_size;
6125 lst_size += sizeof (struct som_entry) * lst.module_count;
6126
6127 /* We don't support import/export tables, auxiliary headers,
6128 or free lists yet. Make the linker work a little harder
6129 to make our life easier. */
6130
6131 lst.export_loc = 0;
6132 lst.export_count = 0;
6133 lst.import_loc = 0;
6134 lst.aux_loc = 0;
6135 lst.aux_size = 0;
6136
6137 /* Count how many symbols we will have on the hash chains and the
6138 size of the associated string table. */
6139 if (som_bfd_prep_for_ar_write (abfd, &nsyms, &stringsize) == false)
6140 return false;
6141
6142 lst_size += sizeof (struct lst_symbol_record) * nsyms;
6143
6144 /* For the string table. One day we might actually use this info
6145 to avoid small seeks/reads when reading archives. */
6146 lst.string_loc = lst_size;
6147 lst.string_size = stringsize;
6148 lst_size += stringsize;
6149
6150 /* SOM ABI says this must be zero. */
6151 lst.free_list = 0;
6152 lst.file_end = lst_size;
6153
6154 /* Compute the checksum. Must happen after the entire lst header
6155 has filled in. */
6156 p = (int *)&lst;
6157 lst.checksum = 0;
6158 for (i = 0; i < sizeof (struct lst_header)/sizeof (int) - 1; i++)
6159 lst.checksum ^= *p++;
6160
6161 sprintf (hdr.ar_name, "/ ");
6162 sprintf (hdr.ar_date, "%ld", bfd_ardata (abfd)->armap_timestamp);
6163 sprintf (hdr.ar_uid, "%ld", (long) getuid ());
6164 sprintf (hdr.ar_gid, "%ld", (long) getgid ());
6165 sprintf (hdr.ar_mode, "%-8o", (unsigned int) statbuf.st_mode);
6166 sprintf (hdr.ar_size, "%-10d", (int) lst_size);
6167 hdr.ar_fmag[0] = '`';
6168 hdr.ar_fmag[1] = '\012';
6169
6170 /* Turn any nulls into spaces. */
6171 for (i = 0; i < sizeof (struct ar_hdr); i++)
6172 if (((char *) (&hdr))[i] == '\0')
6173 (((char *) (&hdr))[i]) = ' ';
6174
6175 /* Scribble out the ar header. */
6176 if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
6177 != sizeof (struct ar_hdr))
6178 return false;
6179
6180 /* Now scribble out the lst header. */
6181 if (bfd_write ((PTR) &lst, 1, sizeof (struct lst_header), abfd)
6182 != sizeof (struct lst_header))
6183 return false;
6184
6185 /* Build and write the armap. */
6186 if (som_bfd_ar_write_symbol_stuff (abfd, nsyms, stringsize, lst, elength)
6187 == false)
6188 return false;
6189
6190 /* Done. */
6191 return true;
6192}
6193
6194/* Free all information we have cached for this BFD. We can always
6195 read it again later if we need it. */
6196
6197static boolean
6198som_bfd_free_cached_info (abfd)
6199 bfd *abfd;
6200{
6201 asection *o;
6202
6203 if (bfd_get_format (abfd) != bfd_object)
6204 return true;
6205
6206#define FREE(x) if (x != NULL) { free (x); x = NULL; }
6207 /* Free the native string and symbol tables. */
6208 FREE (obj_som_symtab (abfd));
6209 FREE (obj_som_stringtab (abfd));
6210 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
6211 {
6212 /* Free the native relocations. */
6213 o->reloc_count = -1;
6214 FREE (som_section_data (o)->reloc_stream);
6215 /* Free the generic relocations. */
6216 FREE (o->relocation);
6217 }
6218#undef FREE
6219
6220 return true;
6221}
6222
6223/* End of miscellaneous support functions. */
6224
6225/* Linker support functions. */
6226static boolean
6227som_bfd_link_split_section (abfd, sec)
6228 bfd *abfd;
6229 asection *sec;
6230{
6231 return (som_is_subspace (sec) && sec->_raw_size > 240000);
6232}
6233
6234#define som_close_and_cleanup som_bfd_free_cached_info
6235
6236#define som_read_ar_hdr _bfd_generic_read_ar_hdr
6237#define som_openr_next_archived_file bfd_generic_openr_next_archived_file
6238#define som_get_elt_at_index _bfd_generic_get_elt_at_index
6239#define som_generic_stat_arch_elt bfd_generic_stat_arch_elt
6240#define som_truncate_arname bfd_bsd_truncate_arname
6241#define som_slurp_extended_name_table _bfd_slurp_extended_name_table
6242#define som_construct_extended_name_table \
6243 _bfd_archive_coff_construct_extended_name_table
6244#define som_update_armap_timestamp bfd_true
6245#define som_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
6246
6247#define som_get_lineno _bfd_nosymbols_get_lineno
6248#define som_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
6249#define som_read_minisymbols _bfd_generic_read_minisymbols
6250#define som_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
6251#define som_get_section_contents_in_window \
6252 _bfd_generic_get_section_contents_in_window
6253
6254#define som_bfd_get_relocated_section_contents \
6255 bfd_generic_get_relocated_section_contents
6256#define som_bfd_relax_section bfd_generic_relax_section
6257#define som_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
6258#define som_bfd_link_add_symbols _bfd_generic_link_add_symbols
6259#define som_bfd_final_link _bfd_generic_final_link
6260
6261#define som_bfd_gc_sections bfd_generic_gc_sections
6262
6263
6264const bfd_target som_vec =
6265{
6266 "som", /* name */
6267 bfd_target_som_flavour,
6268 BFD_ENDIAN_BIG, /* target byte order */
6269 BFD_ENDIAN_BIG, /* target headers byte order */
6270 (HAS_RELOC | EXEC_P | /* object flags */
6271 HAS_LINENO | HAS_DEBUG |
6272 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | DYNAMIC),
6273 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
6274 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
6275
6276/* leading_symbol_char: is the first char of a user symbol
6277 predictable, and if so what is it */
6278 0,
6279 '/', /* ar_pad_char */
6280 14, /* ar_max_namelen */
6281 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
6282 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
6283 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
6284 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
6285 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
6286 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
6287 {_bfd_dummy_target,
6288 som_object_p, /* bfd_check_format */
6289 bfd_generic_archive_p,
6290 _bfd_dummy_target
6291 },
6292 {
6293 bfd_false,
6294 som_mkobject,
6295 _bfd_generic_mkarchive,
6296 bfd_false
6297 },
6298 {
6299 bfd_false,
6300 som_write_object_contents,
6301 _bfd_write_archive_contents,
6302 bfd_false,
6303 },
6304#undef som
6305
6306 BFD_JUMP_TABLE_GENERIC (som),
6307 BFD_JUMP_TABLE_COPY (som),
6308 BFD_JUMP_TABLE_CORE (_bfd_nocore),
6309 BFD_JUMP_TABLE_ARCHIVE (som),
6310 BFD_JUMP_TABLE_SYMBOLS (som),
6311 BFD_JUMP_TABLE_RELOCS (som),
6312 BFD_JUMP_TABLE_WRITE (som),
6313 BFD_JUMP_TABLE_LINK (som),
6314 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
6315
c3c89269
NC		 6316 NULL,
6317
252b5132
RH		 6318 (PTR) 0
6319};
6320
6321#endif /* HOST_HPPAHPUX || HOST_HPPABSD || HOST_HPPAOSF */
GDB Binutils - Deliverables
This page took 0.274986 seconds and 4 git commands to generate.