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