projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Make all callers of malloc or realloc (including via obstacks)
[binutils-gdb.git] / bfd / som.c
1 /* bfd back-end for HP PA-RISC SOM objects.
2 Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3
4 Contributed by the Center for Software Science at the
5 University of Utah (pa-gdb-bugs@cs.utah.edu).
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22
23 #include "bfd.h"
24 #include "sysdep.h"
25
26 #if defined (HOST_HPPAHPUX) || defined (HOST_HPPABSD) || defined (HOST_HPPAOSF)
27
28 #include "libbfd.h"
29 #include "som.h"
30 #include "libhppa.h"
31
32 #include <stdio.h>
33 #include <sys/types.h>
34 #include <sys/param.h>
35 #include <sys/dir.h>
36 #include <signal.h>
37 #include <machine/reg.h>
38 #include <sys/user.h> /* After a.out.h */
39 #include <sys/file.h>
40 #include <errno.h>
41
42 /* Magic not defined in standard HP-UX header files until 8.0 */
43
44 #ifndef CPU_PA_RISC1_0
45 #define CPU_PA_RISC1_0 0x20B
46 #endif /* CPU_PA_RISC1_0 */
47
48 #ifndef CPU_PA_RISC1_1
49 #define CPU_PA_RISC1_1 0x210
50 #endif /* CPU_PA_RISC1_1 */
51
52 #ifndef _PA_RISC1_0_ID
53 #define _PA_RISC1_0_ID CPU_PA_RISC1_0
54 #endif /* _PA_RISC1_0_ID */
55
56 #ifndef _PA_RISC1_1_ID
57 #define _PA_RISC1_1_ID CPU_PA_RISC1_1
58 #endif /* _PA_RISC1_1_ID */
59
60 #ifndef _PA_RISC_MAXID
61 #define _PA_RISC_MAXID 0x2FF
62 #endif /* _PA_RISC_MAXID */
63
64 #ifndef _PA_RISC_ID
65 #define _PA_RISC_ID(__m_num) \
66 (((__m_num) == _PA_RISC1_0_ID) || \
67 ((__m_num) >= _PA_RISC1_1_ID && (__m_num) <= _PA_RISC_MAXID))
68 #endif /* _PA_RISC_ID */
69
70 /* Size (in chars) of the temporary buffers used during fixup and string
71 table writes. */
72
73 #define SOM_TMP_BUFSIZE 8192
74
75
76 /* SOM allows any one of the four previous relocations to be reused
77 with a "R_PREV_FIXUP" relocation entry. Since R_PREV_FIXUP
78 relocations are always a single byte, using a R_PREV_FIXUP instead
79 of some multi-byte relocation makes object files smaller.
80
81 Note one side effect of using a R_PREV_FIXUP is the relocation that
82 is being repeated moves to the front of the queue. */
83 struct reloc_queue
84 {
85 unsigned char *reloc;
86 unsigned int size;
87 } reloc_queue[4];
88
89 /* This fully describes the symbol types which may be attached to
90 an EXPORT or IMPORT directive. Only SOM uses this formation
91 (ELF has no need for it). */
92 typedef enum
93 {
94 SYMBOL_TYPE_UNKNOWN,
95 SYMBOL_TYPE_ABSOLUTE,
96 SYMBOL_TYPE_CODE,
97 SYMBOL_TYPE_DATA,
98 SYMBOL_TYPE_ENTRY,
99 SYMBOL_TYPE_MILLICODE,
100 SYMBOL_TYPE_PLABEL,
101 SYMBOL_TYPE_PRI_PROG,
102 SYMBOL_TYPE_SEC_PROG,
103 } pa_symbol_type;
104
105 struct section_to_type
106 {
107 char *section;
108 char type;
109 };
110
111 /* Forward declarations */
112
113 static boolean som_mkobject PARAMS ((bfd *));
114 static bfd_target * som_object_setup PARAMS ((bfd *,
115 struct header *,
116 struct som_exec_auxhdr *));
117 static asection * make_unique_section PARAMS ((bfd *, CONST char *, int));
118 static boolean setup_sections PARAMS ((bfd *, struct header *));
119 static bfd_target * som_object_p PARAMS ((bfd *));
120 static boolean som_write_object_contents PARAMS ((bfd *));
121 static boolean som_slurp_string_table PARAMS ((bfd *));
122 static unsigned int som_slurp_symbol_table PARAMS ((bfd *));
123 static unsigned int som_get_symtab_upper_bound PARAMS ((bfd *));
124 static unsigned int som_canonicalize_reloc PARAMS ((bfd *, sec_ptr,
125 arelent **, asymbol **));
126 static unsigned int som_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr));
127 static unsigned int som_set_reloc_info PARAMS ((unsigned char *, unsigned int,
128 arelent *, asection *,
129 asymbol **, boolean));
130 static boolean som_slurp_reloc_table PARAMS ((bfd *, asection *,
131 asymbol **, boolean));
132 static unsigned int som_get_symtab PARAMS ((bfd *, asymbol **));
133 static asymbol * som_make_empty_symbol PARAMS ((bfd *));
134 static void som_print_symbol PARAMS ((bfd *, PTR,
135 asymbol *, bfd_print_symbol_type));
136 static boolean som_new_section_hook PARAMS ((bfd *, asection *));
137 static boolean som_set_section_contents PARAMS ((bfd *, sec_ptr, PTR,
138 file_ptr, bfd_size_type));
139 static boolean som_set_arch_mach PARAMS ((bfd *, enum bfd_architecture,
140 unsigned long));
141 static boolean som_find_nearest_line PARAMS ((bfd *, asection *,
142 asymbol **, bfd_vma,
143 CONST char **,
144 CONST char **,
145 unsigned int *));
146 static void som_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
147 static asection * som_section_from_subspace_index PARAMS ((bfd *,
148 unsigned int));
149 static int log2 PARAMS ((unsigned int));
150 static bfd_reloc_status_type hppa_som_reloc PARAMS ((bfd *, arelent *,
151 asymbol *, PTR,
152 asection *, bfd *,
153 char **));
154 static void som_initialize_reloc_queue PARAMS ((struct reloc_queue *));
155 static void som_reloc_queue_insert PARAMS ((unsigned char *, unsigned int,
156 struct reloc_queue *));
157 static void som_reloc_queue_fix PARAMS ((struct reloc_queue *, unsigned int));
158 static int som_reloc_queue_find PARAMS ((unsigned char *, unsigned int,
159 struct reloc_queue *));
160 static unsigned char * try_prev_fixup PARAMS ((bfd *, int *, unsigned char *,
161 unsigned int,
162 struct reloc_queue *));
163
164 static unsigned char * som_reloc_skip PARAMS ((bfd *, unsigned int,
165 unsigned char *, unsigned int *,
166 struct reloc_queue *));
167 static unsigned char * som_reloc_addend PARAMS ((bfd *, int, unsigned char *,
168 unsigned int *,
169 struct reloc_queue *));
170 static unsigned char * som_reloc_call PARAMS ((bfd *, unsigned char *,
171 unsigned int *,
172 arelent *, int,
173 struct reloc_queue *));
174 static unsigned long som_count_spaces PARAMS ((bfd *));
175 static unsigned long som_count_subspaces PARAMS ((bfd *));
176 static int compare_syms PARAMS ((asymbol **, asymbol **));
177 static unsigned long som_compute_checksum PARAMS ((bfd *));
178 static boolean som_prep_headers PARAMS ((bfd *));
179 static int som_sizeof_headers PARAMS ((bfd *, boolean));
180 static boolean som_write_headers PARAMS ((bfd *));
181 static boolean som_build_and_write_symbol_table PARAMS ((bfd *));
182 static void som_prep_for_fixups PARAMS ((bfd *, asymbol **, unsigned long));
183 static boolean som_write_fixups PARAMS ((bfd *, unsigned long, unsigned int *));
184 static boolean som_write_space_strings PARAMS ((bfd *, unsigned long,
185 unsigned int *));
186 static boolean som_write_symbol_strings PARAMS ((bfd *, unsigned long,
187 asymbol **, unsigned int,
188 unsigned *));
189 static boolean som_begin_writing PARAMS ((bfd *));
190 static const reloc_howto_type * som_bfd_reloc_type_lookup
191 PARAMS ((bfd_arch_info_type *, bfd_reloc_code_real_type));
192 static char som_section_type PARAMS ((const char *));
193 static int som_decode_symclass PARAMS ((asymbol *));
194
195
196 /* Map SOM section names to POSIX/BSD single-character symbol types.
197
198 This table includes all the standard subspaces as defined in the
199 current "PRO ABI for PA-RISC Systems", $UNWIND$ which for
200 some reason was left out, and sections specific to embedded stabs. */
201
202 static const struct section_to_type stt[] = {
203 {"$TEXT$", 't'},
204 {"$SHLIB_INFO$", 't'},
205 {"$MILLICODE$", 't'},
206 {"$LIT$", 't'},
207 {"$CODE$", 't'},
208 {"$UNWIND_START$", 't'},
209 {"$UNWIND$", 't'},
210 {"$PRIVATE$", 'd'},
211 {"$PLT$", 'd'},
212 {"$SHLIB_DATA$", 'd'},
213 {"$DATA$", 'd'},
214 {"$SHORTDATA$", 'g'},
215 {"$DLT$", 'd'},
216 {"$GLOBAL$", 'g'},
217 {"$SHORTBSS$", 's'},
218 {"$BSS$", 'b'},
219 {"$GDB_STRINGS$", 'N'},
220 {"$GDB_SYMBOLS$", 'N'},
221 {0, 0}
222 };
223
224 /* About the relocation formatting table...
225
226 There are 256 entries in the table, one for each possible
227 relocation opcode available in SOM. We index the table by
228 the relocation opcode. The names and operations are those
229 defined by a.out_800 (4).
230
231 Right now this table is only used to count and perform minimal
232 processing on relocation streams so that they can be internalized
233 into BFD and symbolically printed by utilities. To make actual use
234 of them would be much more difficult, BFD's concept of relocations
235 is far too simple to handle SOM relocations. The basic assumption
236 that a relocation can be completely processed independent of other
237 relocations before an object file is written is invalid for SOM.
238
239 The SOM relocations are meant to be processed as a stream, they
240 specify copying of data from the input section to the output section
241 while possibly modifying the data in some manner. They also can
242 specify that a variable number of zeros or uninitialized data be
243 inserted on in the output segment at the current offset. Some
244 relocations specify that some previous relocation be re-applied at
245 the current location in the input/output sections. And finally a number
246 of relocations have effects on other sections (R_ENTRY, R_EXIT,
247 R_UNWIND_AUX and a variety of others). There isn't even enough room
248 in the BFD relocation data structure to store enough information to
249 perform all the relocations.
250
251 Each entry in the table has three fields.
252
253 The first entry is an index into this "class" of relocations. This
254 index can then be used as a variable within the relocation itself.
255
256 The second field is a format string which actually controls processing
257 of the relocation. It uses a simple postfix machine to do calculations
258 based on variables/constants found in the string and the relocation
259 stream.
260
261 The third field specifys whether or not this relocation may use
262 a constant (V) from the previous R_DATA_OVERRIDE rather than a constant
263 stored in the instruction.
264
265 Variables:
266
267 L = input space byte count
268 D = index into class of relocations
269 M = output space byte count
270 N = statement number (unused?)
271 O = stack operation
272 R = parameter relocation bits
273 S = symbol index
274 U = 64 bits of stack unwind and frame size info (we only keep 32 bits)
275 V = a literal constant (usually used in the next relocation)
276 P = a previous relocation
277
278 Lower case letters (starting with 'b') refer to following
279 bytes in the relocation stream. 'b' is the next 1 byte,
280 c is the next 2 bytes, d is the next 3 bytes, etc...
281 This is the variable part of the relocation entries that
282 makes our life a living hell.
283
284 numerical constants are also used in the format string. Note
285 the constants are represented in decimal.
286
287 '+', "*" and "=" represents the obvious postfix operators.
288 '<' represents a left shift.
289
290 Stack Operations:
291
292 Parameter Relocation Bits:
293
294 Unwind Entries:
295
296 Previous Relocations: The index field represents which in the queue
297 of 4 previous fixups should be re-applied.
298
299 Literal Constants: These are generally used to represent addend
300 parts of relocations when these constants are not stored in the
301 fields of the instructions themselves. For example the instruction
302 addil foo-$global$-0x1234 would use an override for "0x1234" rather
303 than storing it into the addil itself. */
304
305 struct fixup_format
306 {
307 int D;
308 char *format;
309 };
310
311 static const struct fixup_format som_fixup_formats[256] =
312 {
313 /* R_NO_RELOCATION */
314 0, "LD1+4*=", /* 0x00 */
315 1, "LD1+4*=", /* 0x01 */
316 2, "LD1+4*=", /* 0x02 */
317 3, "LD1+4*=", /* 0x03 */
318 4, "LD1+4*=", /* 0x04 */
319 5, "LD1+4*=", /* 0x05 */
320 6, "LD1+4*=", /* 0x06 */
321 7, "LD1+4*=", /* 0x07 */
322 8, "LD1+4*=", /* 0x08 */
323 9, "LD1+4*=", /* 0x09 */
324 10, "LD1+4*=", /* 0x0a */
325 11, "LD1+4*=", /* 0x0b */
326 12, "LD1+4*=", /* 0x0c */
327 13, "LD1+4*=", /* 0x0d */
328 14, "LD1+4*=", /* 0x0e */
329 15, "LD1+4*=", /* 0x0f */
330 16, "LD1+4*=", /* 0x10 */
331 17, "LD1+4*=", /* 0x11 */
332 18, "LD1+4*=", /* 0x12 */
333 19, "LD1+4*=", /* 0x13 */
334 20, "LD1+4*=", /* 0x14 */
335 21, "LD1+4*=", /* 0x15 */
336 22, "LD1+4*=", /* 0x16 */
337 23, "LD1+4*=", /* 0x17 */
338 0, "LD8<b+1+4*=", /* 0x18 */
339 1, "LD8<b+1+4*=", /* 0x19 */
340 2, "LD8<b+1+4*=", /* 0x1a */
341 3, "LD8<b+1+4*=", /* 0x1b */
342 0, "LD16<c+1+4*=", /* 0x1c */
343 1, "LD16<c+1+4*=", /* 0x1d */
344 2, "LD16<c+1+4*=", /* 0x1e */
345 0, "Ld1+=", /* 0x1f */
346 /* R_ZEROES */
347 0, "Lb1+4*=", /* 0x20 */
348 1, "Ld1+=", /* 0x21 */
349 /* R_UNINIT */
350 0, "Lb1+4*=", /* 0x22 */
351 1, "Ld1+=", /* 0x23 */
352 /* R_RELOCATION */
353 0, "L4=", /* 0x24 */
354 /* R_DATA_ONE_SYMBOL */
355 0, "L4=Sb=", /* 0x25 */
356 1, "L4=Sd=", /* 0x26 */
357 /* R_DATA_PLEBEL */
358 0, "L4=Sb=", /* 0x27 */
359 1, "L4=Sd=", /* 0x28 */
360 /* R_SPACE_REF */
361 0, "L4=", /* 0x29 */
362 /* R_REPEATED_INIT */
363 0, "L4=Mb1+4*=", /* 0x2a */
364 1, "Lb4*=Mb1+L*=", /* 0x2b */
365 2, "Lb4*=Md1+4*=", /* 0x2c */
366 3, "Ld1+=Me1+=", /* 0x2d */
367 /* R_RESERVED */
368 0, "", /* 0x2e */
369 0, "", /* 0x2f */
370 /* R_PCREL_CALL */
371 0, "L4=RD=Sb=", /* 0x30 */
372 1, "L4=RD=Sb=", /* 0x31 */
373 2, "L4=RD=Sb=", /* 0x32 */
374 3, "L4=RD=Sb=", /* 0x33 */
375 4, "L4=RD=Sb=", /* 0x34 */
376 5, "L4=RD=Sb=", /* 0x35 */
377 6, "L4=RD=Sb=", /* 0x36 */
378 7, "L4=RD=Sb=", /* 0x37 */
379 8, "L4=RD=Sb=", /* 0x38 */
380 9, "L4=RD=Sb=", /* 0x39 */
381 0, "L4=RD8<b+=Sb=",/* 0x3a */
382 1, "L4=RD8<b+=Sb=",/* 0x3b */
383 0, "L4=RD8<b+=Sd=",/* 0x3c */
384 1, "L4=RD8<b+=Sd=",/* 0x3d */
385 /* R_RESERVED */
386 0, "", /* 0x3e */
387 0, "", /* 0x3f */
388 /* R_ABS_CALL */
389 0, "L4=RD=Sb=", /* 0x40 */
390 1, "L4=RD=Sb=", /* 0x41 */
391 2, "L4=RD=Sb=", /* 0x42 */
392 3, "L4=RD=Sb=", /* 0x43 */
393 4, "L4=RD=Sb=", /* 0x44 */
394 5, "L4=RD=Sb=", /* 0x45 */
395 6, "L4=RD=Sb=", /* 0x46 */
396 7, "L4=RD=Sb=", /* 0x47 */
397 8, "L4=RD=Sb=", /* 0x48 */
398 9, "L4=RD=Sb=", /* 0x49 */
399 0, "L4=RD8<b+=Sb=",/* 0x4a */
400 1, "L4=RD8<b+=Sb=",/* 0x4b */
401 0, "L4=RD8<b+=Sd=",/* 0x4c */
402 1, "L4=RD8<b+=Sd=",/* 0x4d */
403 /* R_RESERVED */
404 0, "", /* 0x4e */
405 0, "", /* 0x4f */
406 /* R_DP_RELATIVE */
407 0, "L4=SD=", /* 0x50 */
408 1, "L4=SD=", /* 0x51 */
409 2, "L4=SD=", /* 0x52 */
410 3, "L4=SD=", /* 0x53 */
411 4, "L4=SD=", /* 0x54 */
412 5, "L4=SD=", /* 0x55 */
413 6, "L4=SD=", /* 0x56 */
414 7, "L4=SD=", /* 0x57 */
415 8, "L4=SD=", /* 0x58 */
416 9, "L4=SD=", /* 0x59 */
417 10, "L4=SD=", /* 0x5a */
418 11, "L4=SD=", /* 0x5b */
419 12, "L4=SD=", /* 0x5c */
420 13, "L4=SD=", /* 0x5d */
421 14, "L4=SD=", /* 0x5e */
422 15, "L4=SD=", /* 0x5f */
423 16, "L4=SD=", /* 0x60 */
424 17, "L4=SD=", /* 0x61 */
425 18, "L4=SD=", /* 0x62 */
426 19, "L4=SD=", /* 0x63 */
427 20, "L4=SD=", /* 0x64 */
428 21, "L4=SD=", /* 0x65 */
429 22, "L4=SD=", /* 0x66 */
430 23, "L4=SD=", /* 0x67 */
431 24, "L4=SD=", /* 0x68 */
432 25, "L4=SD=", /* 0x69 */
433 26, "L4=SD=", /* 0x6a */
434 27, "L4=SD=", /* 0x6b */
435 28, "L4=SD=", /* 0x6c */
436 29, "L4=SD=", /* 0x6d */
437 30, "L4=SD=", /* 0x6e */
438 31, "L4=SD=", /* 0x6f */
439 32, "L4=Sb=", /* 0x70 */
440 33, "L4=Sd=", /* 0x71 */
441 /* R_RESERVED */
442 0, "", /* 0x72 */
443 0, "", /* 0x73 */
444 0, "", /* 0x74 */
445 0, "", /* 0x75 */
446 0, "", /* 0x76 */
447 0, "", /* 0x77 */
448 /* R_DLT_REL */
449 0, "L4=Sb=", /* 0x78 */
450 1, "L4=Sd=", /* 0x79 */
451 /* R_RESERVED */
452 0, "", /* 0x7a */
453 0, "", /* 0x7b */
454 0, "", /* 0x7c */
455 0, "", /* 0x7d */
456 0, "", /* 0x7e */
457 0, "", /* 0x7f */
458 /* R_CODE_ONE_SYMBOL */
459 0, "L4=SD=", /* 0x80 */
460 1, "L4=SD=", /* 0x81 */
461 2, "L4=SD=", /* 0x82 */
462 3, "L4=SD=", /* 0x83 */
463 4, "L4=SD=", /* 0x84 */
464 5, "L4=SD=", /* 0x85 */
465 6, "L4=SD=", /* 0x86 */
466 7, "L4=SD=", /* 0x87 */
467 8, "L4=SD=", /* 0x88 */
468 9, "L4=SD=", /* 0x89 */
469 10, "L4=SD=", /* 0x8q */
470 11, "L4=SD=", /* 0x8b */
471 12, "L4=SD=", /* 0x8c */
472 13, "L4=SD=", /* 0x8d */
473 14, "L4=SD=", /* 0x8e */
474 15, "L4=SD=", /* 0x8f */
475 16, "L4=SD=", /* 0x90 */
476 17, "L4=SD=", /* 0x91 */
477 18, "L4=SD=", /* 0x92 */
478 19, "L4=SD=", /* 0x93 */
479 20, "L4=SD=", /* 0x94 */
480 21, "L4=SD=", /* 0x95 */
481 22, "L4=SD=", /* 0x96 */
482 23, "L4=SD=", /* 0x97 */
483 24, "L4=SD=", /* 0x98 */
484 25, "L4=SD=", /* 0x99 */
485 26, "L4=SD=", /* 0x9a */
486 27, "L4=SD=", /* 0x9b */
487 28, "L4=SD=", /* 0x9c */
488 29, "L4=SD=", /* 0x9d */
489 30, "L4=SD=", /* 0x9e */
490 31, "L4=SD=", /* 0x9f */
491 32, "L4=Sb=", /* 0xa0 */
492 33, "L4=Sd=", /* 0xa1 */
493 /* R_RESERVED */
494 0, "", /* 0xa2 */
495 0, "", /* 0xa3 */
496 0, "", /* 0xa4 */
497 0, "", /* 0xa5 */
498 0, "", /* 0xa6 */
499 0, "", /* 0xa7 */
500 0, "", /* 0xa8 */
501 0, "", /* 0xa9 */
502 0, "", /* 0xaa */
503 0, "", /* 0xab */
504 0, "", /* 0xac */
505 0, "", /* 0xad */
506 /* R_MILLI_REL */
507 0, "L4=Sb=", /* 0xae */
508 1, "L4=Sd=", /* 0xaf */
509 /* R_CODE_PLABEL */
510 0, "L4=Sb=", /* 0xb0 */
511 1, "L4=Sd=", /* 0xb1 */
512 /* R_BREAKPOINT */
513 0, "L4=", /* 0xb2 */
514 /* R_ENTRY */
515 0, "Ui=", /* 0xb3 */
516 1, "Uf=", /* 0xb4 */
517 /* R_ALT_ENTRY */
518 0, "", /* 0xb5 */
519 /* R_EXIT */
520 0, "", /* 0xb6 */
521 /* R_BEGIN_TRY */
522 0, "", /* 0xb7 */
523 /* R_END_TRY */
524 0, "R0=", /* 0xb8 */
525 1, "Rb4*=", /* 0xb9 */
526 2, "Rd4*=", /* 0xba */
527 /* R_BEGIN_BRTAB */
528 0, "", /* 0xbb */
529 /* R_END_BRTAB */
530 0, "", /* 0xbc */
531 /* R_STATEMENT */
532 0, "Nb=", /* 0xbd */
533 1, "Nc=", /* 0xbe */
534 2, "Nd=", /* 0xbf */
535 /* R_DATA_EXPR */
536 0, "L4=", /* 0xc0 */
537 /* R_CODE_EXPR */
538 0, "L4=", /* 0xc1 */
539 /* R_FSEL */
540 0, "", /* 0xc2 */
541 /* R_LSEL */
542 0, "", /* 0xc3 */
543 /* R_RSEL */
544 0, "", /* 0xc4 */
545 /* R_N_MODE */
546 0, "", /* 0xc5 */
547 /* R_S_MODE */
548 0, "", /* 0xc6 */
549 /* R_D_MODE */
550 0, "", /* 0xc7 */
551 /* R_R_MODE */
552 0, "", /* 0xc8 */
553 /* R_DATA_OVERRIDE */
554 0, "V0=", /* 0xc9 */
555 1, "Vb=", /* 0xca */
556 2, "Vc=", /* 0xcb */
557 3, "Vd=", /* 0xcc */
558 4, "Ve=", /* 0xcd */
559 /* R_TRANSLATED */
560 0, "", /* 0xce */
561 /* R_RESERVED */
562 0, "", /* 0xcf */
563 /* R_COMP1 */
564 0, "Ob=", /* 0xd0 */
565 /* R_COMP2 */
566 0, "Ob=Sd=", /* 0xd1 */
567 /* R_COMP3 */
568 0, "Ob=Ve=", /* 0xd2 */
569 /* R_PREV_FIXUP */
570 0, "P", /* 0xd3 */
571 1, "P", /* 0xd4 */
572 2, "P", /* 0xd5 */
573 3, "P", /* 0xd6 */
574 /* R_RESERVED */
575 0, "", /* 0xd7 */
576 0, "", /* 0xd8 */
577 0, "", /* 0xd9 */
578 0, "", /* 0xda */
579 0, "", /* 0xdb */
580 0, "", /* 0xdc */
581 0, "", /* 0xdd */
582 0, "", /* 0xde */
583 0, "", /* 0xdf */
584 0, "", /* 0xe0 */
585 0, "", /* 0xe1 */
586 0, "", /* 0xe2 */
587 0, "", /* 0xe3 */
588 0, "", /* 0xe4 */
589 0, "", /* 0xe5 */
590 0, "", /* 0xe6 */
591 0, "", /* 0xe7 */
592 0, "", /* 0xe8 */
593 0, "", /* 0xe9 */
594 0, "", /* 0xea */
595 0, "", /* 0xeb */
596 0, "", /* 0xec */
597 0, "", /* 0xed */
598 0, "", /* 0xee */
599 0, "", /* 0xef */
600 0, "", /* 0xf0 */
601 0, "", /* 0xf1 */
602 0, "", /* 0xf2 */
603 0, "", /* 0xf3 */
604 0, "", /* 0xf4 */
605 0, "", /* 0xf5 */
606 0, "", /* 0xf6 */
607 0, "", /* 0xf7 */
608 0, "", /* 0xf8 */
609 0, "", /* 0xf9 */
610 0, "", /* 0xfa */
611 0, "", /* 0xfb */
612 0, "", /* 0xfc */
613 0, "", /* 0xfd */
614 0, "", /* 0xfe */
615 0, "", /* 0xff */
616 };
617
618 static const int comp1_opcodes[] =
619 {
620 0x00,
621 0x40,
622 0x41,
623 0x42,
624 0x43,
625 0x44,
626 0x45,
627 0x46,
628 0x47,
629 0x48,
630 0x49,
631 0x4a,
632 0x4b,
633 0x60,
634 0x80,
635 0xa0,
636 0xc0,
637 -1
638 };
639
640 static const int comp2_opcodes[] =
641 {
642 0x00,
643 0x80,
644 0x82,
645 0xc0,
646 -1
647 };
648
649 static const int comp3_opcodes[] =
650 {
651 0x00,
652 0x02,
653 -1
654 };
655
656 /* These apparently are not in older versions of hpux reloc.h. */
657 #ifndef R_DLT_REL
658 #define R_DLT_REL 0x78
659 #endif
660
661 #ifndef R_AUX_UNWIND
662 #define R_AUX_UNWIND 0xcf
663 #endif
664
665 #ifndef R_SEC_STMT
666 #define R_SEC_STMT 0xd7
667 #endif
668
669 static reloc_howto_type som_hppa_howto_table[] =
670 {
671 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
672 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
673 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
674 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
675 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
676 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
677 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
678 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
679 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
680 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
681 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
682 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
683 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
684 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
685 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
686 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
687 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
688 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
689 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
690 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
691 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
692 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
693 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
694 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
695 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
696 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
697 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
698 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
699 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
700 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
701 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
702 {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
703 {R_ZEROES, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ZEROES"},
704 {R_ZEROES, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ZEROES"},
705 {R_UNINIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_UNINIT"},
706 {R_UNINIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_UNINIT"},
707 {R_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RELOCATION"},
708 {R_DATA_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_ONE_SYMBOL"},
709 {R_DATA_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_ONE_SYMBOL"},
710 {R_DATA_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_PLABEL"},
711 {R_DATA_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_PLABEL"},
712 {R_SPACE_REF, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_SPACE_REF"},
713 {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
714 {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
715 {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
716 {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
717 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
718 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
719 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
720 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
721 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
722 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
723 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
724 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
725 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
726 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
727 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
728 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
729 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
730 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
731 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
732 {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
733 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
734 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
735 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
736 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
737 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
738 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
739 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
740 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
741 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
742 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
743 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
744 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
745 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
746 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
747 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
748 {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
749 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
750 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
751 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
752 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
753 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
754 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
755 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
756 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
757 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
758 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
759 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
760 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
761 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
762 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
763 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
764 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
765 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
766 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
767 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
768 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
769 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
770 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
771 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
772 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
773 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
774 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
775 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
776 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
777 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
778 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
779 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
780 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
781 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
782 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
783 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
784 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
785 {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
786 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
787 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
788 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
789 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
790 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
791 {R_DLT_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DLT_REL"},
792 {R_DLT_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DLT_REL"},
793 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
794 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
795 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
796 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
797 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
798 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
799 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
800 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
801 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
802 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
803 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
804 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
805 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
806 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
807 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
808 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
809 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
810 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
811 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
812 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
813 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
814 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
815 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
816 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
817 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
818 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
819 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
820 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
821 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
822 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
823 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
824 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
825 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
826 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
827 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
828 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
829 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
830 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
831 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
832 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
833 {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
834 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
835 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
836 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
837 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
838 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
839 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
840 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
841 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
842 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
843 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
844 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
845 {R_MILLI_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_MILLI_REL"},
846 {R_MILLI_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_MILLI_REL"},
847 {R_CODE_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_PLABEL"},
848 {R_CODE_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_PLABEL"},
849 {R_BREAKPOINT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_BREAKPOINT"},
850 {R_ENTRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ENTRY"},
851 {R_ENTRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ENTRY"},
852 {R_ALT_ENTRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ALT_ENTRY"},
853 {R_EXIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_EXIT"},
854 {R_BEGIN_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_BEGIN_TRY"},
855 {R_END_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_TRY"},
856 {R_END_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_TRY"},
857 {R_END_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_TRY"},
858 {R_BEGIN_BRTAB, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_BEGIN_BRTAB"},
859 {R_END_BRTAB, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_BRTAB"},
860 {R_STATEMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_STATEMENT"},
861 {R_STATEMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_STATEMENT"},
862 {R_STATEMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_STATEMENT"},
863 {R_DATA_EXPR, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_EXPR"},
864 {R_CODE_EXPR, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_EXPR"},
865 {R_FSEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_FSEL"},
866 {R_LSEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LSEL"},
867 {R_RSEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RSEL"},
868 {R_N_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_N_MODE"},
869 {R_S_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_S_MODE"},
870 {R_D_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_D_MODE"},
871 {R_R_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_R_MODE"},
872 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
873 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
874 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
875 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
876 {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
877 {R_TRANSLATED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_TRANSLATED"},
878 {R_AUX_UNWIND, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_AUX_UNWIND"},
879 {R_COMP1, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMP1"},
880 {R_COMP2, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMP2"},
881 {R_COMP3, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMP3"},
882 {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
883 {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
884 {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
885 {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
886 {R_SEC_STMT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_SEC_STMT"},
887 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
888 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
889 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
890 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
891 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
892 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
893 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
894 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
895 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
896 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
897 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
898 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
899 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
900 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
901 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
902 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
903 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
904 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
905 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
906 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
907 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
908 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
909 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
910 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
911 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
912 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
913 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
914 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
915 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
916 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
917 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
918 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
919 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
920 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
921 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
922 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
923 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
924 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
925 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
926 {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"}};
927
928
929 /* Initialize the SOM relocation queue. By definition the queue holds
930 the last four multibyte fixups. */
931
932 static void
933 som_initialize_reloc_queue (queue)
934 struct reloc_queue *queue;
935 {
936 queue[0].reloc = NULL;
937 queue[0].size = 0;
938 queue[1].reloc = NULL;
939 queue[1].size = 0;
940 queue[2].reloc = NULL;
941 queue[2].size = 0;
942 queue[3].reloc = NULL;
943 queue[3].size = 0;
944 }
945
946 /* Insert a new relocation into the relocation queue. */
947
948 static void
949 som_reloc_queue_insert (p, size, queue)
950 unsigned char *p;
951 unsigned int size;
952 struct reloc_queue *queue;
953 {
954 queue[3].reloc = queue[2].reloc;
955 queue[3].size = queue[2].size;
956 queue[2].reloc = queue[1].reloc;
957 queue[2].size = queue[1].size;
958 queue[1].reloc = queue[0].reloc;
959 queue[1].size = queue[0].size;
960 queue[0].reloc = p;
961 queue[0].size = size;
962 }
963
964 /* When an entry in the relocation queue is reused, the entry moves
965 to the front of the queue. */
966
967 static void
968 som_reloc_queue_fix (queue, index)
969 struct reloc_queue *queue;
970 unsigned int index;
971 {
972 if (index == 0)
973 return;
974
975 if (index == 1)
976 {
977 unsigned char *tmp1 = queue[0].reloc;
978 unsigned int tmp2 = queue[0].size;
979 queue[0].reloc = queue[1].reloc;
980 queue[0].size = queue[1].size;
981 queue[1].reloc = tmp1;
982 queue[1].size = tmp2;
983 return;
984 }
985
986 if (index == 2)
987 {
988 unsigned char *tmp1 = queue[0].reloc;
989 unsigned int tmp2 = queue[0].size;
990 queue[0].reloc = queue[2].reloc;
991 queue[0].size = queue[2].size;
992 queue[2].reloc = queue[1].reloc;
993 queue[2].size = queue[1].size;
994 queue[1].reloc = tmp1;
995 queue[1].size = tmp2;
996 return;
997 }
998
999 if (index == 3)
1000 {
1001 unsigned char *tmp1 = queue[0].reloc;
1002 unsigned int tmp2 = queue[0].size;
1003 queue[0].reloc = queue[3].reloc;
1004 queue[0].size = queue[3].size;
1005 queue[3].reloc = queue[2].reloc;
1006 queue[3].size = queue[2].size;
1007 queue[2].reloc = queue[1].reloc;
1008 queue[2].size = queue[1].size;
1009 queue[1].reloc = tmp1;
1010 queue[1].size = tmp2;
1011 return;
1012 }
1013 abort();
1014 }
1015
1016 /* Search for a particular relocation in the relocation queue. */
1017
1018 static int
1019 som_reloc_queue_find (p, size, queue)
1020 unsigned char *p;
1021 unsigned int size;
1022 struct reloc_queue *queue;
1023 {
1024 if (queue[0].reloc && !bcmp (p, queue[0].reloc, size)
1025 && size == queue[0].size)
1026 return 0;
1027 if (queue[1].reloc && !bcmp (p, queue[1].reloc, size)
1028 && size == queue[1].size)
1029 return 1;
1030 if (queue[2].reloc && !bcmp (p, queue[2].reloc, size)
1031 && size == queue[2].size)
1032 return 2;
1033 if (queue[3].reloc && !bcmp (p, queue[3].reloc, size)
1034 && size == queue[3].size)
1035 return 3;
1036 return -1;
1037 }
1038
1039 static unsigned char *
1040 try_prev_fixup (abfd, subspace_reloc_sizep, p, size, queue)
1041 bfd *abfd;
1042 int *subspace_reloc_sizep;
1043 unsigned char *p;
1044 unsigned int size;
1045 struct reloc_queue *queue;
1046 {
1047 int queue_index = som_reloc_queue_find (p, size, queue);
1048
1049 if (queue_index != -1)
1050 {
1051 /* Found this in a previous fixup. Undo the fixup we
1052 just built and use R_PREV_FIXUP instead. We saved
1053 a total of size - 1 bytes in the fixup stream. */
1054 bfd_put_8 (abfd, R_PREV_FIXUP + queue_index, p);
1055 p += 1;
1056 *subspace_reloc_sizep += 1;
1057 som_reloc_queue_fix (queue, queue_index);
1058 }
1059 else
1060 {
1061 som_reloc_queue_insert (p, size, queue);
1062 *subspace_reloc_sizep += size;
1063 p += size;
1064 }
1065 return p;
1066 }
1067
1068 /* Emit the proper R_NO_RELOCATION fixups to map the next SKIP
1069 bytes without any relocation. Update the size of the subspace
1070 relocation stream via SUBSPACE_RELOC_SIZE_P; also return the
1071 current pointer into the relocation stream. */
1072
1073 static unsigned char *
1074 som_reloc_skip (abfd, skip, p, subspace_reloc_sizep, queue)
1075 bfd *abfd;
1076 unsigned int skip;
1077 unsigned char *p;
1078 unsigned int *subspace_reloc_sizep;
1079 struct reloc_queue *queue;
1080 {
1081 /* Use a 4 byte R_NO_RELOCATION entry with a maximal value
1082 then R_PREV_FIXUPs to get the difference down to a
1083 reasonable size. */
1084 if (skip >= 0x1000000)
1085 {
1086 skip -= 0x1000000;
1087 bfd_put_8 (abfd, R_NO_RELOCATION + 31, p);
1088 bfd_put_8 (abfd, 0xff, p + 1);
1089 bfd_put_16 (abfd, 0xffff, p + 2);
1090 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue);
1091 while (skip >= 0x1000000)
1092 {
1093 skip -= 0x1000000;
1094 bfd_put_8 (abfd, R_PREV_FIXUP, p);
1095 p++;
1096 *subspace_reloc_sizep += 1;
1097 /* No need to adjust queue here since we are repeating the
1098 most recent fixup. */
1099 }
1100 }
1101
1102 /* The difference must be less than 0x1000000. Use one
1103 more R_NO_RELOCATION entry to get to the right difference. */
1104 if ((skip & 3) == 0 && skip <= 0xc0000 && skip > 0)
1105 {
1106 /* Difference can be handled in a simple single-byte
1107 R_NO_RELOCATION entry. */
1108 if (skip <= 0x60)
1109 {
1110 bfd_put_8 (abfd, R_NO_RELOCATION + (skip >> 2) - 1, p);
1111 *subspace_reloc_sizep += 1;
1112 p++;
1113 }
1114 /* Handle it with a two byte R_NO_RELOCATION entry. */
1115 else if (skip <= 0x1000)
1116 {
1117 bfd_put_8 (abfd, R_NO_RELOCATION + 24 + (((skip >> 2) - 1) >> 8), p);
1118 bfd_put_8 (abfd, (skip >> 2) - 1, p + 1);
1119 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue);
1120 }
1121 /* Handle it with a three byte R_NO_RELOCATION entry. */
1122 else
1123 {
1124 bfd_put_8 (abfd, R_NO_RELOCATION + 28 + (((skip >> 2) - 1) >> 16), p);
1125 bfd_put_16 (abfd, (skip >> 2) - 1, p + 1);
1126 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue);
1127 }
1128 }
1129 /* Ugh. Punt and use a 4 byte entry. */
1130 else if (skip > 0)
1131 {
1132 bfd_put_8 (abfd, R_NO_RELOCATION + 31, p);
1133 bfd_put_8 (abfd, skip >> 16, p + 1);
1134 bfd_put_16 (abfd, skip, p + 2);
1135 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue);
1136 }
1137 return p;
1138 }
1139
1140 /* Emit the proper R_DATA_OVERRIDE fixups to handle a nonzero addend
1141 from a BFD relocation. Update the size of the subspace relocation
1142 stream via SUBSPACE_RELOC_SIZE_P; also return the current pointer
1143 into the relocation stream. */
1144
1145 static unsigned char *
1146 som_reloc_addend (abfd, addend, p, subspace_reloc_sizep, queue)
1147 bfd *abfd;
1148 int addend;
1149 unsigned char *p;
1150 unsigned int *subspace_reloc_sizep;
1151 struct reloc_queue *queue;
1152 {
1153 if ((unsigned)(addend) + 0x80 < 0x100)
1154 {
1155 bfd_put_8 (abfd, R_DATA_OVERRIDE + 1, p);
1156 bfd_put_8 (abfd, addend, p + 1);
1157 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue);
1158 }
1159 else if ((unsigned) (addend) + 0x8000 < 0x10000)
1160 {
1161 bfd_put_8 (abfd, R_DATA_OVERRIDE + 2, p);
1162 bfd_put_16 (abfd, addend, p + 1);
1163 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue);
1164 }
1165 else if ((unsigned) (addend) + 0x800000 < 0x1000000)
1166 {
1167 bfd_put_8 (abfd, R_DATA_OVERRIDE + 3, p);
1168 bfd_put_8 (abfd, addend >> 16, p + 1);
1169 bfd_put_16 (abfd, addend, p + 2);
1170 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue);
1171 }
1172 else
1173 {
1174 bfd_put_8 (abfd, R_DATA_OVERRIDE + 4, p);
1175 bfd_put_32 (abfd, addend, p + 1);
1176 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 5, queue);
1177 }
1178 return p;
1179 }
1180
1181 /* Handle a single function call relocation. */
1182
1183 static unsigned char *
1184 som_reloc_call (abfd, p, subspace_reloc_sizep, bfd_reloc, sym_num, queue)
1185 bfd *abfd;
1186 unsigned char *p;
1187 unsigned int *subspace_reloc_sizep;
1188 arelent *bfd_reloc;
1189 int sym_num;
1190 struct reloc_queue *queue;
1191 {
1192 int arg_bits = HPPA_R_ARG_RELOC (bfd_reloc->addend);
1193 int rtn_bits = arg_bits & 0x3;
1194 int type, done = 0;
1195
1196 /* You'll never believe all this is necessary to handle relocations
1197 for function calls. Having to compute and pack the argument
1198 relocation bits is the real nightmare.
1199
1200 If you're interested in how this works, just forget it. You really
1201 do not want to know about this braindamage. */
1202
1203 /* First see if this can be done with a "simple" relocation. Simple
1204 relocations have a symbol number < 0x100 and have simple encodings
1205 of argument relocations. */
1206
1207 if (sym_num < 0x100)
1208 {
1209 switch (arg_bits)
1210 {
1211 case 0:
1212 case 1:
1213 type = 0;
1214 break;
1215 case 1 << 8:
1216 case 1 << 8 | 1:
1217 type = 1;
1218 break;
1219 case 1 << 8 | 1 << 6:
1220 case 1 << 8 | 1 << 6 | 1:
1221 type = 2;
1222 break;
1223 case 1 << 8 | 1 << 6 | 1 << 4:
1224 case 1 << 8 | 1 << 6 | 1 << 4 | 1:
1225 type = 3;
1226 break;
1227 case 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2:
1228 case 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2 | 1:
1229 type = 4;
1230 break;
1231 default:
1232 /* Not one of the easy encodings. This will have to be
1233 handled by the more complex code below. */
1234 type = -1;
1235 break;
1236 }
1237 if (type != -1)
1238 {
1239 /* Account for the return value too. */
1240 if (rtn_bits)
1241 type += 5;
1242
1243 /* Emit a 2 byte relocation. Then see if it can be handled
1244 with a relocation which is already in the relocation queue. */
1245 bfd_put_8 (abfd, bfd_reloc->howto->type + type, p);
1246 bfd_put_8 (abfd, sym_num, p + 1);
1247 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue);
1248 done = 1;
1249 }
1250 }
1251
1252 /* If this could not be handled with a simple relocation, then do a hard
1253 one. Hard relocations occur if the symbol number was too high or if
1254 the encoding of argument relocation bits is too complex. */
1255 if (! done)
1256 {
1257 /* Don't ask about these magic sequences. I took them straight
1258 from gas-1.36 which took them from the a.out man page. */
1259 type = rtn_bits;
1260 if ((arg_bits >> 6 & 0xf) == 0xe)
1261 type += 9 * 40;
1262 else
1263 type += (3 * (arg_bits >> 8 & 3) + (arg_bits >> 6 & 3)) * 40;
1264 if ((arg_bits >> 2 & 0xf) == 0xe)
1265 type += 9 * 4;
1266 else
1267 type += (3 * (arg_bits >> 4 & 3) + (arg_bits >> 2 & 3)) * 4;
1268
1269 /* Output the first two bytes of the relocation. These describe
1270 the length of the relocation and encoding style. */
1271 bfd_put_8 (abfd, bfd_reloc->howto->type + 10
1272 + 2 * (sym_num >= 0x100) + (type >= 0x100),
1273 p);
1274 bfd_put_8 (abfd, type, p + 1);
1275
1276 /* Now output the symbol index and see if this bizarre relocation
1277 just happened to be in the relocation queue. */
1278 if (sym_num < 0x100)
1279 {
1280 bfd_put_8 (abfd, sym_num, p + 2);
1281 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue);
1282 }
1283 else
1284 {
1285 bfd_put_8 (abfd, sym_num >> 16, p + 2);
1286 bfd_put_16 (abfd, sym_num, p + 3);
1287 p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 5, queue);
1288 }
1289 }
1290 return p;
1291 }
1292
1293
1294 /* Return the logarithm of X, base 2, considering X unsigned.
1295 Abort if X is not a power of two -- this should never happen (FIXME:
1296 It will happen on corrupt executables. GDB should give an error, not
1297 a coredump, in that case). */
1298
1299 static int
1300 log2 (x)
1301 unsigned int x;
1302 {
1303 int log = 0;
1304
1305 /* Test for 0 or a power of 2. */
1306 if (x == 0 || x != (x & -x))
1307 abort();
1308
1309 while ((x >>= 1) != 0)
1310 log++;
1311 return log;
1312 }
1313
1314 static bfd_reloc_status_type
1315 hppa_som_reloc (abfd, reloc_entry, symbol_in, data,
1316 input_section, output_bfd, error_message)
1317 bfd *abfd;
1318 arelent *reloc_entry;
1319 asymbol *symbol_in;
1320 PTR data;
1321 asection *input_section;
1322 bfd *output_bfd;
1323 char **error_message;
1324 {
1325 if (output_bfd)
1326 {
1327 reloc_entry->address += input_section->output_offset;
1328 return bfd_reloc_ok;
1329 }
1330 return bfd_reloc_ok;
1331 }
1332
1333 /* Given a generic HPPA relocation type, the instruction format,
1334 and a field selector, return an appropriate SOM reloation.
1335
1336 FIXME. Need to handle %RR, %LR and the like as field selectors.
1337 These will need to generate multiple SOM relocations. */
1338
1339 int **
1340 hppa_som_gen_reloc_type (abfd, base_type, format, field)
1341 bfd *abfd;
1342 int base_type;
1343 int format;
1344 enum hppa_reloc_field_selector_type field;
1345 {
1346 int *final_type, **final_types;
1347
1348 final_types = (int **) bfd_alloc_by_size_t (abfd, sizeof (int *) * 3);
1349 final_type = (int *) bfd_alloc_by_size_t (abfd, sizeof (int));
1350 if (!final_types || !final_type)
1351 {
1352 bfd_error = no_memory;
1353 return NULL;
1354 }
1355
1356 /* The field selector may require additional relocations to be
1357 generated. It's impossible to know at this moment if additional
1358 relocations will be needed, so we make them. The code to actually
1359 write the relocation/fixup stream is responsible for removing
1360 any redundant relocations. */
1361 switch (field)
1362 {
1363 case e_fsel:
1364 case e_psel:
1365 case e_lpsel:
1366 case e_rpsel:
1367 final_types[0] = final_type;
1368 final_types[1] = NULL;
1369 final_types[2] = NULL;
1370 *final_type = base_type;
1371 break;
1372
1373 case e_tsel:
1374 case e_ltsel:
1375 case e_rtsel:
1376 final_types[0] = (int *) bfd_alloc_by_size_t (abfd, sizeof (int));
1377 if (!final_types[0])
1378 {
1379 bfd_error = no_memory;
1380 return NULL;
1381 }
1382 if (field == e_tsel)
1383 *final_types[0] = R_FSEL;
1384 else if (field == e_ltsel)
1385 *final_types[0] = R_LSEL;
1386 else
1387 *final_types[0] = R_RSEL;
1388 final_types[1] = final_type;
1389 final_types[2] = NULL;
1390 *final_type = base_type;
1391 break;
1392
1393 case e_lssel:
1394 case e_rssel:
1395 final_types[0] = (int *) bfd_alloc_by_size_t (abfd, sizeof (int));
1396 if (!final_types[0])
1397 {
1398 bfd_error = no_memory;
1399 return NULL;
1400 }
1401 *final_types[0] = R_S_MODE;
1402 final_types[1] = final_type;
1403 final_types[2] = NULL;
1404 *final_type = base_type;
1405 break;
1406
1407 case e_lsel:
1408 case e_rsel:
1409 final_types[0] = (int *) bfd_alloc_by_size_t (abfd, sizeof (int));
1410 if (!final_types[0])
1411 {
1412 bfd_error = no_memory;
1413 return NULL;
1414 }
1415 *final_types[0] = R_N_MODE;
1416 final_types[1] = final_type;
1417 final_types[2] = NULL;
1418 *final_type = base_type;
1419 break;
1420
1421 case e_ldsel:
1422 case e_rdsel:
1423 final_types[0] = (int *) bfd_alloc_by_size_t (abfd, sizeof (int));
1424 if (!final_types[0])
1425 {
1426 bfd_error = no_memory;
1427 return NULL;
1428 }
1429 *final_types[0] = R_D_MODE;
1430 final_types[1] = final_type;
1431 final_types[2] = NULL;
1432 *final_type = base_type;
1433 break;
1434
1435 case e_lrsel:
1436 case e_rrsel:
1437 final_types[0] = (int *) bfd_alloc_by_size_t (abfd, sizeof (int));
1438 if (!final_types[0])
1439 {
1440 bfd_error = no_memory;
1441 return NULL;
1442 }
1443 *final_types[0] = R_R_MODE;
1444 final_types[1] = final_type;
1445 final_types[2] = NULL;
1446 *final_type = base_type;
1447 break;
1448 }
1449
1450 switch (base_type)
1451 {
1452 case R_HPPA:
1453 /* PLABELs get their own relocation type. */
1454 if (field == e_psel
1455 || field == e_lpsel
1456 || field == e_rpsel)
1457 {
1458 /* A PLABEL relocation that has a size of 32 bits must
1459 be a R_DATA_PLABEL. All others are R_CODE_PLABELs. */
1460 if (format == 32)
1461 *final_type = R_DATA_PLABEL;
1462 else
1463 *final_type = R_CODE_PLABEL;
1464 }
1465 /* PIC stuff. */
1466 else if (field == e_tsel
1467 || field == e_ltsel
1468 || field == e_rtsel)
1469 *final_type = R_DLT_REL;
1470 /* A relocation in the data space is always a full 32bits. */
1471 else if (format == 32)
1472 *final_type = R_DATA_ONE_SYMBOL;
1473
1474 break;
1475
1476 case R_HPPA_GOTOFF:
1477 /* More PLABEL special cases. */
1478 if (field == e_psel
1479 || field == e_lpsel
1480 || field == e_rpsel)
1481 *final_type = R_DATA_PLABEL;
1482 break;
1483
1484 case R_HPPA_NONE:
1485 case R_HPPA_ABS_CALL:
1486 case R_HPPA_PCREL_CALL:
1487 case R_HPPA_COMPLEX:
1488 case R_HPPA_COMPLEX_PCREL_CALL:
1489 case R_HPPA_COMPLEX_ABS_CALL:
1490 /* Right now we can default all these. */
1491 break;
1492 }
1493 return final_types;
1494 }
1495
1496 /* Return the address of the correct entry in the PA SOM relocation
1497 howto table. */
1498
1499 static const reloc_howto_type *
1500 som_bfd_reloc_type_lookup (arch, code)
1501 bfd_arch_info_type *arch;
1502 bfd_reloc_code_real_type code;
1503 {
1504 if ((int) code < (int) R_NO_RELOCATION + 255)
1505 {
1506 BFD_ASSERT ((int) som_hppa_howto_table[(int) code].type == (int) code);
1507 return &som_hppa_howto_table[(int) code];
1508 }
1509
1510 return (reloc_howto_type *) 0;
1511 }
1512
1513 /* Perform some initialization for an object. Save results of this
1514 initialization in the BFD. */
1515
1516 static bfd_target *
1517 som_object_setup (abfd, file_hdrp, aux_hdrp)
1518 bfd *abfd;
1519 struct header *file_hdrp;
1520 struct som_exec_auxhdr *aux_hdrp;
1521 {
1522 /* som_mkobject will set bfd_error if som_mkobject fails. */
1523 if (som_mkobject (abfd) != true)
1524 return 0;
1525
1526 /* Set BFD flags based on what information is available in the SOM. */
1527 abfd->flags = NO_FLAGS;
1528 if (! file_hdrp->entry_offset)
1529 abfd->flags |= HAS_RELOC;
1530 else
1531 abfd->flags |= EXEC_P;
1532 if (file_hdrp->symbol_total)
1533 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
1534
1535 bfd_get_start_address (abfd) = aux_hdrp->exec_entry;
1536 bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 0);
1537 bfd_get_symcount (abfd) = file_hdrp->symbol_total;
1538
1539 /* Initialize the saved symbol table and string table to NULL.
1540 Save important offsets and sizes from the SOM header into
1541 the BFD. */
1542 obj_som_stringtab (abfd) = (char *) NULL;
1543 obj_som_symtab (abfd) = (som_symbol_type *) NULL;
1544 obj_som_stringtab_size (abfd) = file_hdrp->symbol_strings_size;
1545 obj_som_sym_filepos (abfd) = file_hdrp->symbol_location;
1546 obj_som_str_filepos (abfd) = file_hdrp->symbol_strings_location;
1547 obj_som_reloc_filepos (abfd) = file_hdrp->fixup_request_location;
1548
1549 return abfd->xvec;
1550 }
1551
1552 /* Create a new BFD section for NAME. If NAME already exists, then create a
1553 new unique name, with NAME as the prefix. This exists because SOM .o files
1554 may have more than one $CODE$ subspace. */
1555
1556 static asection *
1557 make_unique_section (abfd, name, num)
1558 bfd *abfd;
1559 CONST char *name;
1560 int num;
1561 {
1562 asection *sect;
1563 char *newname;
1564 char altname[100];
1565
1566 sect = bfd_make_section (abfd, name);
1567 while (!sect)
1568 {
1569 sprintf (altname, "%s-%d", name, num++);
1570 sect = bfd_make_section (abfd, altname);
1571 }
1572
1573 newname = bfd_alloc (abfd, strlen (sect->name) + 1);
1574 if (!newname)
1575 {
1576 bfd_error = no_memory;
1577 return NULL;
1578 }
1579 strcpy (newname, sect->name);
1580
1581 sect->name = newname;
1582 return sect;
1583 }
1584
1585 /* Convert all of the space and subspace info into BFD sections. Each space
1586 contains a number of subspaces, which in turn describe the mapping between
1587 regions of the exec file, and the address space that the program runs in.
1588 BFD sections which correspond to spaces will overlap the sections for the
1589 associated subspaces. */
1590
1591 static boolean
1592 setup_sections (abfd, file_hdr)
1593 bfd *abfd;
1594 struct header *file_hdr;
1595 {
1596 char *space_strings;
1597 int space_index;
1598 unsigned int total_subspaces = 0;
1599
1600 /* First, read in space names */
1601
1602 space_strings = alloca (file_hdr->space_strings_size);
1603 if (!space_strings)
1604 return false;
1605
1606 if (bfd_seek (abfd, file_hdr->space_strings_location, SEEK_SET) < 0)
1607 return false;
1608 if (bfd_read (space_strings, 1, file_hdr->space_strings_size, abfd)
1609 != file_hdr->space_strings_size)
1610 return false;
1611
1612 /* Loop over all of the space dictionaries, building up sections */
1613 for (space_index = 0; space_index < file_hdr->space_total; space_index++)
1614 {
1615 struct space_dictionary_record space;
1616 struct subspace_dictionary_record subspace, save_subspace;
1617 int subspace_index;
1618 asection *space_asect;
1619
1620 /* Read the space dictionary element */
1621 if (bfd_seek (abfd, file_hdr->space_location
1622 + space_index * sizeof space, SEEK_SET) < 0)
1623 return false;
1624 if (bfd_read (&space, 1, sizeof space, abfd) != sizeof space)
1625 return false;
1626
1627 /* Setup the space name string */
1628 space.name.n_name = space.name.n_strx + space_strings;
1629
1630 /* Make a section out of it */
1631 space_asect = make_unique_section (abfd, space.name.n_name, space_index);
1632 if (!space_asect)
1633 return false;
1634
1635 /* Now, read in the first subspace for this space */
1636 if (bfd_seek (abfd, file_hdr->subspace_location
1637 + space.subspace_index * sizeof subspace,
1638 SEEK_SET) < 0)
1639 return false;
1640 if (bfd_read (&subspace, 1, sizeof subspace, abfd) != sizeof subspace)
1641 return false;
1642 /* Seek back to the start of the subspaces for loop below */
1643 if (bfd_seek (abfd, file_hdr->subspace_location
1644 + space.subspace_index * sizeof subspace,
1645 SEEK_SET) < 0)
1646 return false;
1647
1648 /* Setup the start address and file loc from the first subspace record */
1649 space_asect->vma = subspace.subspace_start;
1650 space_asect->filepos = subspace.file_loc_init_value;
1651 space_asect->alignment_power = log2 (subspace.alignment);
1652
1653 /* Initialize save_subspace so we can reliably determine if this
1654 loop placed any useful values into it. */
1655 bzero (&save_subspace, sizeof (struct subspace_dictionary_record));
1656
1657 /* Loop over the rest of the subspaces, building up more sections */
1658 for (subspace_index = 0; subspace_index < space.subspace_quantity;
1659 subspace_index++)
1660 {
1661 asection *subspace_asect;
1662
1663 /* Read in the next subspace */
1664 if (bfd_read (&subspace, 1, sizeof subspace, abfd)
1665 != sizeof subspace)
1666 return false;
1667
1668 /* Setup the subspace name string */
1669 subspace.name.n_name = subspace.name.n_strx + space_strings;
1670
1671 /* Make a section out of this subspace */
1672 subspace_asect = make_unique_section (abfd, subspace.name.n_name,
1673 space.subspace_index + subspace_index);
1674
1675 if (!subspace_asect)
1676 return false;
1677
1678 /* Keep an easy mapping between subspaces and sections. */
1679 som_section_data (subspace_asect)->subspace_index
1680 = total_subspaces++;
1681
1682 /* Set SEC_READONLY and SEC_CODE/SEC_DATA as specified
1683 by the access_control_bits in the subspace header. */
1684 switch (subspace.access_control_bits >> 4)
1685 {
1686 /* Readonly data. */
1687 case 0x0:
1688 subspace_asect->flags |= SEC_DATA | SEC_READONLY;
1689 break;
1690
1691 /* Normal data. */
1692 case 0x1:
1693 subspace_asect->flags |= SEC_DATA;
1694 break;
1695
1696 /* Readonly code and the gateways.
1697 Gateways have other attributes which do not map
1698 into anything BFD knows about. */
1699 case 0x2:
1700 case 0x4:
1701 case 0x5:
1702 case 0x6:
1703 case 0x7:
1704 subspace_asect->flags |= SEC_CODE | SEC_READONLY;
1705 break;
1706
1707 /* dynamic (writable) code. */
1708 case 0x3:
1709 subspace_asect->flags |= SEC_CODE;
1710 break;
1711 }
1712
1713 if (subspace.dup_common || subspace.is_common)
1714 subspace_asect->flags |= SEC_IS_COMMON;
1715 else if (subspace.subspace_length > 0)
1716 subspace_asect->flags |= SEC_HAS_CONTENTS;
1717 if (subspace.is_loadable)
1718 subspace_asect->flags |= SEC_ALLOC | SEC_LOAD;
1719 if (subspace.code_only)
1720 subspace_asect->flags |= SEC_CODE;
1721
1722 /* Both file_loc_init_value and initialization_length will
1723 be zero for a BSS like subspace. */
1724 if (subspace.file_loc_init_value == 0
1725 && subspace.initialization_length == 0)
1726 subspace_asect->flags &= ~(SEC_DATA | SEC_LOAD);
1727
1728 /* This subspace has relocations.
1729 The fixup_request_quantity is a byte count for the number of
1730 entries in the relocation stream; it is not the actual number
1731 of relocations in the subspace. */
1732 if (subspace.fixup_request_quantity != 0)
1733 {
1734 subspace_asect->flags |= SEC_RELOC;
1735 subspace_asect->rel_filepos = subspace.fixup_request_index;
1736 som_section_data (subspace_asect)->reloc_size
1737 = subspace.fixup_request_quantity;
1738 /* We can not determine this yet. When we read in the
1739 relocation table the correct value will be filled in. */
1740 subspace_asect->reloc_count = -1;
1741 }
1742
1743 /* Update save_subspace if appropriate. */
1744 if (subspace.file_loc_init_value > save_subspace.file_loc_init_value)
1745 save_subspace = subspace;
1746
1747 subspace_asect->vma = subspace.subspace_start;
1748 subspace_asect->_cooked_size = subspace.subspace_length;
1749 subspace_asect->_raw_size = subspace.subspace_length;
1750 subspace_asect->alignment_power = log2 (subspace.alignment);
1751 subspace_asect->filepos = subspace.file_loc_init_value;
1752 }
1753
1754 /* Yow! there is no subspace within the space which actually
1755 has initialized information in it; this should never happen
1756 as far as I know. */
1757 if (!save_subspace.file_loc_init_value)
1758 abort ();
1759
1760 /* Setup the sizes for the space section based upon the info in the
1761 last subspace of the space. */
1762 space_asect->_cooked_size = save_subspace.subspace_start
1763 - space_asect->vma + save_subspace.subspace_length;
1764 space_asect->_raw_size = save_subspace.file_loc_init_value
1765 - space_asect->filepos + save_subspace.initialization_length;
1766 }
1767 return true;
1768 }
1769
1770 /* Read in a SOM object and make it into a BFD. */
1771
1772 static bfd_target *
1773 som_object_p (abfd)
1774 bfd *abfd;
1775 {
1776 struct header file_hdr;
1777 struct som_exec_auxhdr aux_hdr;
1778
1779 if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
1780 {
1781 bfd_error = system_call_error;
1782 return 0;
1783 }
1784
1785 if (!_PA_RISC_ID (file_hdr.system_id))
1786 {
1787 bfd_error = wrong_format;
1788 return 0;
1789 }
1790
1791 switch (file_hdr.a_magic)
1792 {
1793 case RELOC_MAGIC:
1794 case EXEC_MAGIC:
1795 case SHARE_MAGIC:
1796 case DEMAND_MAGIC:
1797 #ifdef DL_MAGIC
1798 case DL_MAGIC:
1799 #endif
1800 #ifdef SHL_MAGIC
1801 case SHL_MAGIC:
1802 #endif
1803 #ifdef EXECLIBMAGIC
1804 case EXECLIBMAGIC:
1805 #endif
1806 #ifdef SHARED_MAGIC_CNX
1807 case SHARED_MAGIC_CNX:
1808 #endif
1809 break;
1810 default:
1811 bfd_error = wrong_format;
1812 return 0;
1813 }
1814
1815 if (file_hdr.version_id != VERSION_ID
1816 && file_hdr.version_id != NEW_VERSION_ID)
1817 {
1818 bfd_error = wrong_format;
1819 return 0;
1820 }
1821
1822 /* If the aux_header_size field in the file header is zero, then this
1823 object is an incomplete executable (a .o file). Do not try to read
1824 a non-existant auxiliary header. */
1825 bzero (&aux_hdr, sizeof (struct som_exec_auxhdr));
1826 if (file_hdr.aux_header_size != 0)
1827 {
1828 if (bfd_read ((PTR) & aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
1829 {
1830 bfd_error = wrong_format;
1831 return 0;
1832 }
1833 }
1834
1835 if (!setup_sections (abfd, &file_hdr))
1836 {
1837 /* setup_sections does not bubble up a bfd error code. */
1838 bfd_error = bad_value;
1839 return 0;
1840 }
1841
1842 /* This appears to be a valid SOM object. Do some initialization. */
1843 return som_object_setup (abfd, &file_hdr, &aux_hdr);
1844 }
1845
1846 /* Create a SOM object. */
1847
1848 static boolean
1849 som_mkobject (abfd)
1850 bfd *abfd;
1851 {
1852 /* Allocate memory to hold backend information. */
1853 abfd->tdata.som_data = (struct som_data_struct *)
1854 bfd_zalloc (abfd, sizeof (struct som_data_struct));
1855 if (abfd->tdata.som_data == NULL)
1856 {
1857 bfd_error = no_memory;
1858 return false;
1859 }
1860 obj_som_file_hdr (abfd)
1861 = (struct header *) bfd_zalloc (abfd, sizeof (struct header));
1862 if (obj_som_file_hdr (abfd) == NULL)
1863
1864 {
1865 bfd_error = no_memory;
1866 return false;
1867 }
1868 return true;
1869 }
1870
1871 /* Initialize some information in the file header. This routine makes
1872 not attempt at doing the right thing for a full executable; it
1873 is only meant to handle relocatable objects. */
1874
1875 static boolean
1876 som_prep_headers (abfd)
1877 bfd *abfd;
1878 {
1879 struct header *file_hdr = obj_som_file_hdr (abfd);
1880 asection *section;
1881
1882 /* FIXME. This should really be conditional based on whether or not
1883 PA1.1 instructions/registers have been used. */
1884 file_hdr->system_id = HP9000S800_ID;
1885
1886 /* FIXME. Only correct for building relocatable objects. */
1887 if (abfd->flags & EXEC_P)
1888 abort ();
1889 else
1890 file_hdr->a_magic = RELOC_MAGIC;
1891
1892 /* Only new format SOM is supported. */
1893 file_hdr->version_id = NEW_VERSION_ID;
1894
1895 /* These fields are optional, and embedding timestamps is not always
1896 a wise thing to do, it makes comparing objects during a multi-stage
1897 bootstrap difficult. */
1898 file_hdr->file_time.secs = 0;
1899 file_hdr->file_time.nanosecs = 0;
1900
1901 if (abfd->flags & EXEC_P)
1902 abort ();
1903 else
1904 {
1905 file_hdr->entry_space = 0;
1906 file_hdr->entry_subspace = 0;
1907 file_hdr->entry_offset = 0;
1908 }
1909
1910 /* FIXME. I do not know if we ever need to put anything other
1911 than zero in this field. */
1912 file_hdr->presumed_dp = 0;
1913
1914 /* Now iterate over the sections translating information from
1915 BFD sections to SOM spaces/subspaces. */
1916
1917 for (section = abfd->sections; section != NULL; section = section->next)
1918 {
1919 /* Ignore anything which has not been marked as a space or
1920 subspace. */
1921 if (som_section_data (section)->is_space == 0
1922
1923 && som_section_data (section)->is_subspace == 0)
1924 continue;
1925
1926 if (som_section_data (section)->is_space)
1927 {
1928 /* Set space attributes. Note most attributes of SOM spaces
1929 are set based on the subspaces it contains. */
1930 som_section_data (section)->space_dict.loader_fix_index = -1;
1931 som_section_data (section)->space_dict.init_pointer_index = -1;
1932 }
1933 else
1934 {
1935 /* Set subspace attributes. Basic stuff is done here, additional
1936 attributes are filled in later as more information becomes
1937 available. */
1938 if (section->flags & SEC_IS_COMMON)
1939 {
1940 som_section_data (section)->subspace_dict.dup_common = 1;
1941 som_section_data (section)->subspace_dict.is_common = 1;
1942 }
1943
1944 if (section->flags & SEC_ALLOC)
1945 som_section_data (section)->subspace_dict.is_loadable = 1;
1946
1947 if (section->flags & SEC_CODE)
1948 som_section_data (section)->subspace_dict.code_only = 1;
1949
1950 som_section_data (section)->subspace_dict.subspace_start =
1951 section->vma;
1952 som_section_data (section)->subspace_dict.subspace_length =
1953 bfd_section_size (abfd, section);
1954 som_section_data (section)->subspace_dict.initialization_length =
1955 bfd_section_size (abfd, section);
1956 som_section_data (section)->subspace_dict.alignment =
1957 1 << section->alignment_power;
1958 }
1959 }
1960 return true;
1961 }
1962
1963 /* Count and return the number of spaces attached to the given BFD. */
1964
1965 static unsigned long
1966 som_count_spaces (abfd)
1967 bfd *abfd;
1968 {
1969 int count = 0;
1970 asection *section;
1971
1972 for (section = abfd->sections; section != NULL; section = section->next)
1973 count += som_section_data (section)->is_space;
1974
1975 return count;
1976 }
1977
1978 /* Count the number of subspaces attached to the given BFD. */
1979
1980 static unsigned long
1981 som_count_subspaces (abfd)
1982 bfd *abfd;
1983 {
1984 int count = 0;
1985 asection *section;
1986
1987 for (section = abfd->sections; section != NULL; section = section->next)
1988 count += som_section_data (section)->is_subspace;
1989
1990 return count;
1991 }
1992
1993 /* Return -1, 0, 1 indicating the relative ordering of sym1 and sym2.
1994
1995 We desire symbols to be ordered starting with the symbol with the
1996 highest relocation count down to the symbol with the lowest relocation
1997 count. Doing so compacts the relocation stream. */
1998
1999 static int
2000 compare_syms (sym1, sym2)
2001 asymbol **sym1;
2002 asymbol **sym2;
2003
2004 {
2005 unsigned int count1, count2;
2006
2007 /* Get relocation count for each symbol. Note that the count
2008 is stored in the udata pointer for section symbols! */
2009 if ((*sym1)->flags & BSF_SECTION_SYM)
2010 count1 = (int)(*sym1)->udata;
2011 else
2012 count1 = (*som_symbol_data ((*sym1)))->reloc_count;
2013
2014 if ((*sym2)->flags & BSF_SECTION_SYM)
2015 count2 = (int)(*sym2)->udata;
2016 else
2017 count2 = (*som_symbol_data ((*sym2)))->reloc_count;
2018
2019 /* Return the appropriate value. */
2020 if (count1 < count2)
2021 return 1;
2022 else if (count1 > count2)
2023 return -1;
2024 return 0;
2025 }
2026
2027 /* Perform various work in preparation for emitting the fixup stream. */
2028
2029 static void
2030 som_prep_for_fixups (abfd, syms, num_syms)
2031 bfd *abfd;
2032 asymbol **syms;
2033 unsigned long num_syms;
2034 {
2035 int i;
2036 asection *section;
2037
2038 /* Most SOM relocations involving a symbol have a length which is
2039 dependent on the index of the symbol. So symbols which are
2040 used often in relocations should have a small index. */
2041
2042 /* First initialize the counters for each symbol. */
2043 for (i = 0; i < num_syms; i++)
2044 {
2045 /* Handle a section symbol; these have no pointers back to the
2046 SOM symbol info. So we just use the pointer field (udata)
2047 to hold the relocation count.
2048
2049 FIXME. While we're here set the name of any section symbol
2050 to something which will not screw GDB. How do other formats
2051 deal with this?!? */
2052 if (som_symbol_data (syms[i]) == NULL)
2053 {
2054 syms[i]->flags |= BSF_SECTION_SYM;
2055 syms[i]->name = "L$0\002";
2056 syms[i]->udata = (PTR) 0;
2057 }
2058 else
2059 (*som_symbol_data (syms[i]))->reloc_count = 0;
2060 }
2061
2062 /* Now that the counters are initialized, make a weighted count
2063 of how often a given symbol is used in a relocation. */
2064 for (section = abfd->sections; section != NULL; section = section->next)
2065 {
2066 int i;
2067
2068 /* Does this section have any relocations? */
2069 if (section->reloc_count <= 0)
2070 continue;
2071
2072 /* Walk through each relocation for this section. */
2073 for (i = 1; i < section->reloc_count; i++)
2074 {
2075 arelent *reloc = section->orelocation[i];
2076 int scale;
2077
2078 /* If no symbol, then there is no counter to increase. */
2079 if (reloc->sym_ptr_ptr == NULL)
2080 continue;
2081
2082 /* Scaling to encourage symbols involved in R_DP_RELATIVE
2083 and R_CODE_ONE_SYMBOL relocations to come first. These
2084 two relocations have single byte versions if the symbol
2085 index is very small. */
2086 if (reloc->howto->type == R_DP_RELATIVE
2087 || reloc->howto->type == R_CODE_ONE_SYMBOL)
2088 scale = 2;
2089 else
2090 scale = 1;
2091
2092 /* Handle section symbols by ramming the count in the udata
2093 field. It will not be used and the count is very important
2094 for these symbols. */
2095 if ((*reloc->sym_ptr_ptr)->flags & BSF_SECTION_SYM)
2096 {
2097 (*reloc->sym_ptr_ptr)->udata =
2098 (PTR) ((int) (*reloc->sym_ptr_ptr)->udata + scale);
2099 continue;
2100 }
2101
2102 /* A normal symbol. Increment the count. */
2103 (*som_symbol_data ((*reloc->sym_ptr_ptr)))->reloc_count += scale;
2104 }
2105 }
2106
2107 /* Now sort the symbols. */
2108 qsort (syms, num_syms, sizeof (asymbol *), compare_syms);
2109
2110 /* Compute the symbol indexes, they will be needed by the relocation
2111 code. */
2112 for (i = 0; i < num_syms; i++)
2113 {
2114 /* A section symbol. Again, there is no pointer to backend symbol
2115 information, so we reuse (abuse) the udata field again. */
2116 if (syms[i]->flags & BSF_SECTION_SYM)
2117 syms[i]->udata = (PTR) i;
2118 else
2119 (*som_symbol_data (syms[i]))->index = i;
2120 }
2121 }
2122
2123 static boolean
2124 som_write_fixups (abfd, current_offset, total_reloc_sizep)
2125 bfd *abfd;
2126 unsigned long current_offset;
2127 unsigned int *total_reloc_sizep;
2128 {
2129 unsigned int i, j;
2130 unsigned char *tmp_space, *p;
2131 unsigned int total_reloc_size = 0;
2132 unsigned int subspace_reloc_size = 0;
2133 unsigned int num_spaces = obj_som_file_hdr (abfd)->space_total;
2134 asection *section = abfd->sections;
2135
2136 /* Get a chunk of memory that we can use as buffer space, then throw
2137 away. */
2138 tmp_space = alloca (SOM_TMP_BUFSIZE);
2139 bzero (tmp_space, SOM_TMP_BUFSIZE);
2140 p = tmp_space;
2141
2142 /* All the fixups for a particular subspace are emitted in a single
2143 stream. All the subspaces for a particular space are emitted
2144 as a single stream.
2145
2146 So, to get all the locations correct one must iterate through all the
2147 spaces, for each space iterate through its subspaces and output a
2148 fixups stream. */
2149 for (i = 0; i < num_spaces; i++)
2150 {
2151 asection *subsection;
2152
2153 /* Find a space. */
2154 while (som_section_data (section)->is_space == 0)
2155 section = section->next;
2156
2157 /* Now iterate through each of its subspaces. */
2158 for (subsection = abfd->sections;
2159 subsection != NULL;
2160 subsection = subsection->next)
2161 {
2162 int reloc_offset, current_rounding_mode;
2163
2164 /* Find a subspace of this space. */
2165 if (som_section_data (subsection)->is_subspace == 0
2166 || som_section_data (subsection)->containing_space != section)
2167 continue;
2168
2169 /* If this subspace had no relocations, then we're finished
2170 with it. */
2171 if (subsection->reloc_count <= 0)
2172 {
2173 som_section_data (subsection)->subspace_dict.fixup_request_index
2174 = -1;
2175 continue;
2176 }
2177
2178 /* This subspace has some relocations. Put the relocation stream
2179 index into the subspace record. */
2180 som_section_data (subsection)->subspace_dict.fixup_request_index
2181 = total_reloc_size;
2182
2183 /* To make life easier start over with a clean slate for
2184 each subspace. Seek to the start of the relocation stream
2185 for this subspace in preparation for writing out its fixup
2186 stream. */
2187 if (bfd_seek (abfd, current_offset + total_reloc_size, SEEK_SET) != 0)
2188 {
2189 bfd_error = system_call_error;
2190 return false;
2191 }
2192
2193 /* Buffer space has already been allocated. Just perform some
2194 initialization here. */
2195 p = tmp_space;
2196 subspace_reloc_size = 0;
2197 reloc_offset = 0;
2198 som_initialize_reloc_queue (reloc_queue);
2199 current_rounding_mode = R_N_MODE;
2200
2201 /* Translate each BFD relocation into one or more SOM
2202 relocations. */
2203 for (j = 0; j < subsection->reloc_count; j++)
2204 {
2205 arelent *bfd_reloc = subsection->orelocation[j];
2206 unsigned int skip;
2207 int sym_num;
2208
2209 /* Get the symbol number. Remember it's stored in a
2210 special place for section symbols. */
2211 if ((*bfd_reloc->sym_ptr_ptr)->flags & BSF_SECTION_SYM)
2212 sym_num = (int) (*bfd_reloc->sym_ptr_ptr)->udata;
2213 else
2214 sym_num = (*som_symbol_data ((*bfd_reloc->sym_ptr_ptr)))->index;
2215
2216 /* If there is not enough room for the next couple relocations,
2217 then dump the current buffer contents now. Also reinitialize
2218 the relocation queue.
2219
2220 FIXME. We assume here that no BFD relocation will expand
2221 to more than 100 bytes of SOM relocations. This should (?!?)
2222 be quite safe. */
2223 if (p - tmp_space + 100 > SOM_TMP_BUFSIZE)
2224 {
2225 if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
2226 != p - tmp_space)
2227 {
2228 bfd_error = system_call_error;
2229 return false;
2230 }
2231 p = tmp_space;
2232 som_initialize_reloc_queue (reloc_queue);
2233 }
2234
2235 /* Emit R_NO_RELOCATION fixups to map any bytes which were
2236 skipped. */
2237 skip = bfd_reloc->address - reloc_offset;
2238 p = som_reloc_skip (abfd, skip, p,
2239 &subspace_reloc_size, reloc_queue);
2240
2241 /* Update reloc_offset for the next iteration.
2242
2243 Many relocations do not consume input bytes. They
2244 are markers, or set state necessary to perform some
2245 later relocation. */
2246 switch (bfd_reloc->howto->type)
2247 {
2248 /* This only needs to handle relocations that may be
2249 made by hppa_som_gen_reloc. */
2250 case R_ENTRY:
2251 case R_EXIT:
2252 case R_N_MODE:
2253 case R_S_MODE:
2254 case R_D_MODE:
2255 case R_R_MODE:
2256 case R_FSEL:
2257 case R_LSEL:
2258 case R_RSEL:
2259 reloc_offset = bfd_reloc->address;
2260 break;
2261
2262 default:
2263 reloc_offset = bfd_reloc->address + 4;
2264 break;
2265 }
2266
2267 /* Now the actual relocation we care about. */
2268 switch (bfd_reloc->howto->type)
2269 {
2270 case R_PCREL_CALL:
2271 case R_ABS_CALL:
2272 p = som_reloc_call (abfd, p, &subspace_reloc_size,
2273 bfd_reloc, sym_num, reloc_queue);
2274 break;
2275
2276 case R_CODE_ONE_SYMBOL:
2277 case R_DP_RELATIVE:
2278 /* Account for any addend. */
2279 if (bfd_reloc->addend)
2280 p = som_reloc_addend (abfd, bfd_reloc->addend, p,
2281 &subspace_reloc_size, reloc_queue);
2282
2283 if (sym_num < 0x20)
2284 {
2285 bfd_put_8 (abfd, bfd_reloc->howto->type + sym_num, p);
2286 subspace_reloc_size += 1;
2287 p += 1;
2288 }
2289 else if (sym_num < 0x100)
2290 {
2291 bfd_put_8 (abfd, bfd_reloc->howto->type + 32, p);
2292 bfd_put_8 (abfd, sym_num, p + 1);
2293 p = try_prev_fixup (abfd, &subspace_reloc_size, p,
2294 2, reloc_queue);
2295 }
2296 else if (sym_num < 0x10000000)
2297 {
2298 bfd_put_8 (abfd, bfd_reloc->howto->type + 33, p);
2299 bfd_put_8 (abfd, sym_num >> 16, p + 1);
2300 bfd_put_16 (abfd, sym_num, p + 2);
2301 p = try_prev_fixup (abfd, &subspace_reloc_size,
2302 p, 4, reloc_queue);
2303 }
2304 else
2305 abort ();
2306 break;
2307
2308 case R_DATA_ONE_SYMBOL:
2309 case R_DATA_PLABEL:
2310 case R_CODE_PLABEL:
2311 case R_DLT_REL:
2312 /* Account for any addend. */
2313 if (bfd_reloc->addend)
2314 p = som_reloc_addend (abfd, bfd_reloc->addend, p,
2315 &subspace_reloc_size, reloc_queue);
2316
2317 if (sym_num < 0x100)
2318 {
2319 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2320 bfd_put_8 (abfd, sym_num, p + 1);
2321 p = try_prev_fixup (abfd, &subspace_reloc_size, p,
2322 2, reloc_queue);
2323 }
2324 else if (sym_num < 0x10000000)
2325 {
2326 bfd_put_8 (abfd, bfd_reloc->howto->type + 1, p);
2327 bfd_put_8 (abfd, sym_num >> 16, p + 1);
2328 bfd_put_16 (abfd, sym_num, p + 2);
2329 p = try_prev_fixup (abfd, &subspace_reloc_size,
2330 p, 4, reloc_queue);
2331 }
2332 else
2333 abort ();
2334 break;
2335
2336 case R_ENTRY:
2337 {
2338 int *descp
2339 = (int *) (*som_symbol_data ((*bfd_reloc->sym_ptr_ptr)))->unwind;
2340 bfd_put_8 (abfd, R_ENTRY, p);
2341 bfd_put_32 (abfd, descp[0], p + 1);
2342 bfd_put_32 (abfd, descp[1], p + 5);
2343 p = try_prev_fixup (abfd, &subspace_reloc_size,
2344 p, 9, reloc_queue);
2345 break;
2346 }
2347
2348 case R_EXIT:
2349 bfd_put_8 (abfd, R_EXIT, p);
2350 subspace_reloc_size += 1;
2351 p += 1;
2352 break;
2353
2354 case R_N_MODE:
2355 case R_S_MODE:
2356 case R_D_MODE:
2357 case R_R_MODE:
2358 /* If this relocation requests the current rounding
2359 mode, then it is redundant. */
2360 if (bfd_reloc->howto->type != current_rounding_mode)
2361 {
2362 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2363 subspace_reloc_size += 1;
2364 p += 1;
2365 current_rounding_mode = bfd_reloc->howto->type;
2366 }
2367 break;
2368
2369 case R_FSEL:
2370 case R_LSEL:
2371 case R_RSEL:
2372 bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2373 subspace_reloc_size += 1;
2374 p += 1;
2375 break;
2376
2377 /* Put a "R_RESERVED" relocation in the stream if
2378 we hit something we do not understand. The linker
2379 will complain loudly if this ever happens. */
2380 default:
2381 bfd_put_8 (abfd, 0xff, p);
2382 subspace_reloc_size += 1;
2383 p += 1;
2384 break;
2385 }
2386 }
2387
2388 /* Last BFD relocation for a subspace has been processed.
2389 Map the rest of the subspace with R_NO_RELOCATION fixups. */
2390 p = som_reloc_skip (abfd, bfd_section_size (abfd, subsection)
2391 - reloc_offset,
2392 p, &subspace_reloc_size, reloc_queue);
2393
2394 /* Scribble out the relocations. */
2395 if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
2396 != p - tmp_space)
2397 {
2398 bfd_error = system_call_error;
2399 return false;
2400 }
2401 p = tmp_space;
2402
2403 total_reloc_size += subspace_reloc_size;
2404 som_section_data (subsection)->subspace_dict.fixup_request_quantity
2405 = subspace_reloc_size;
2406 }
2407 section = section->next;
2408 }
2409 *total_reloc_sizep = total_reloc_size;
2410 return true;
2411 }
2412
2413 /* Write out the space/subspace string table. */
2414
2415 static boolean
2416 som_write_space_strings (abfd, current_offset, string_sizep)
2417 bfd *abfd;
2418 unsigned long current_offset;
2419 unsigned int *string_sizep;
2420 {
2421 unsigned char *tmp_space, *p;
2422 unsigned int strings_size = 0;
2423 asection *section;
2424
2425 /* Get a chunk of memory that we can use as buffer space, then throw
2426 away. */
2427 tmp_space = alloca (SOM_TMP_BUFSIZE);
2428 bzero (tmp_space, SOM_TMP_BUFSIZE);
2429 p = tmp_space;
2430
2431 /* Seek to the start of the space strings in preparation for writing
2432 them out. */
2433 if (bfd_seek (abfd, current_offset, SEEK_SET) != 0)
2434 {
2435 bfd_error = system_call_error;
2436 return false;
2437 }
2438
2439 /* Walk through all the spaces and subspaces (order is not important)
2440 building up and writing string table entries for their names. */
2441 for (section = abfd->sections; section != NULL; section = section->next)
2442 {
2443 int length;
2444
2445 /* Only work with space/subspaces; avoid any other sections
2446 which might have been made (.text for example). */
2447 if (som_section_data (section)->is_space == 0
2448 && som_section_data (section)->is_subspace == 0)
2449 continue;
2450
2451 /* Get the length of the space/subspace name. */
2452 length = strlen (section->name);
2453
2454 /* If there is not enough room for the next entry, then dump the
2455 current buffer contents now. Each entry will take 4 bytes to
2456 hold the string length + the string itself + null terminator. */
2457 if (p - tmp_space + 5 + length > SOM_TMP_BUFSIZE)
2458 {
2459 if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
2460 != p - tmp_space)
2461 {
2462 bfd_error = system_call_error;
2463 return false;
2464 }
2465 /* Reset to beginning of the buffer space. */
2466 p = tmp_space;
2467 }
2468
2469 /* First element in a string table entry is the length of the
2470 string. Alignment issues are already handled. */
2471 bfd_put_32 (abfd, length, p);
2472 p += 4;
2473 strings_size += 4;
2474
2475 /* Record the index in the space/subspace records. */
2476 if (som_section_data (section)->is_space)
2477 som_section_data (section)->space_dict.name.n_strx = strings_size;
2478 else
2479 som_section_data (section)->subspace_dict.name.n_strx = strings_size;
2480
2481 /* Next comes the string itself + a null terminator. */
2482 strcpy (p, section->name);
2483 p += length + 1;
2484 strings_size += length + 1;
2485
2486 /* Always align up to the next word boundary. */
2487 while (strings_size % 4)
2488 {
2489 bfd_put_8 (abfd, 0, p);
2490 p++;
2491 strings_size++;
2492 }
2493 }
2494
2495 /* Done with the space/subspace strings. Write out any information
2496 contained in a partial block. */
2497 if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd) != p - tmp_space)
2498 {
2499 bfd_error = system_call_error;
2500 return false;
2501 }
2502 *string_sizep = strings_size;
2503 return true;
2504 }
2505
2506 /* Write out the symbol string table. */
2507
2508 static boolean
2509 som_write_symbol_strings (abfd, current_offset, syms, num_syms, string_sizep)
2510 bfd *abfd;
2511 unsigned long current_offset;
2512 asymbol **syms;
2513 unsigned int num_syms;
2514 unsigned int *string_sizep;
2515 {
2516 unsigned int i;
2517 unsigned char *tmp_space, *p;
2518 unsigned int strings_size = 0;
2519
2520 /* Get a chunk of memory that we can use as buffer space, then throw
2521 away. */
2522 tmp_space = alloca (SOM_TMP_BUFSIZE);
2523 bzero (tmp_space, SOM_TMP_BUFSIZE);
2524 p = tmp_space;
2525
2526 /* Seek to the start of the space strings in preparation for writing
2527 them out. */
2528 if (bfd_seek (abfd, current_offset, SEEK_SET) != 0)
2529 {
2530 bfd_error = system_call_error;
2531 return false;
2532 }
2533
2534 for (i = 0; i < num_syms; i++)
2535 {
2536 int length = strlen (syms[i]->name);
2537
2538 /* If there is not enough room for the next entry, then dump the
2539 current buffer contents now. */
2540 if (p - tmp_space + 5 + length > SOM_TMP_BUFSIZE)
2541 {
2542 if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
2543 != p - tmp_space)
2544 {
2545 bfd_error = system_call_error;
2546 return false;
2547 }
2548 /* Reset to beginning of the buffer space. */
2549 p = tmp_space;
2550 }
2551
2552 /* First element in a string table entry is the length of the
2553 string. This must always be 4 byte aligned. This is also
2554 an appropriate time to fill in the string index field in the
2555 symbol table entry. */
2556 bfd_put_32 (abfd, length, p);
2557 strings_size += 4;
2558 p += 4;
2559
2560 /* Next comes the string itself + a null terminator. */
2561 strcpy (p, syms[i]->name);
2562
2563 /* ACK. FIXME. */
2564 syms[i]->name = (char *)strings_size;
2565 p += length + 1;
2566 strings_size += length + 1;
2567
2568 /* Always align up to the next word boundary. */
2569 while (strings_size % 4)
2570 {
2571 bfd_put_8 (abfd, 0, p);
2572 strings_size++;
2573 p++;
2574 }
2575 }
2576
2577 /* Scribble out any partial block. */
2578 if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd) != p - tmp_space)
2579 {
2580 bfd_error = system_call_error;
2581 return false;
2582 }
2583
2584 *string_sizep = strings_size;
2585 return true;
2586 }
2587
2588 /* Compute variable information to be placed in the SOM headers,
2589 space/subspace dictionaries, relocation streams, etc. Begin
2590 writing parts of the object file. */
2591
2592 static boolean
2593 som_begin_writing (abfd)
2594 bfd *abfd;
2595 {
2596 unsigned long current_offset = 0;
2597 int strings_size = 0;
2598 unsigned int total_reloc_size = 0;
2599 unsigned long num_spaces, num_subspaces, num_syms, i;
2600 asection *section;
2601 asymbol **syms = bfd_get_outsymbols (abfd);
2602 unsigned int total_subspaces = 0;
2603
2604 /* The file header will always be first in an object file,
2605 everything else can be in random locations. To keep things
2606 "simple" BFD will lay out the object file in the manner suggested
2607 by the PRO ABI for PA-RISC Systems. */
2608
2609 /* Before any output can really begin offsets for all the major
2610 portions of the object file must be computed. So, starting
2611 with the initial file header compute (and sometimes write)
2612 each portion of the object file. */
2613
2614 /* Make room for the file header, it's contents are not complete
2615 yet, so it can not be written at this time. */
2616 current_offset += sizeof (struct header);
2617
2618 /* Any auxiliary headers will follow the file header. Right now
2619 we support only the copyright and version headers. */
2620 obj_som_file_hdr (abfd)->aux_header_location = current_offset;
2621 obj_som_file_hdr (abfd)->aux_header_size = 0;
2622 if (obj_som_version_hdr (abfd) != NULL)
2623 {
2624 unsigned int len;
2625
2626 bfd_seek (abfd, current_offset, SEEK_SET);
2627
2628 /* Write the aux_id structure and the string length. */
2629 len = sizeof (struct aux_id) + sizeof (unsigned int);
2630 obj_som_file_hdr (abfd)->aux_header_size += len;
2631 current_offset += len;
2632 if (bfd_write ((PTR) obj_som_version_hdr (abfd), len, 1, abfd) != len)
2633 {
2634 bfd_error = system_call_error;
2635 return false;
2636 }
2637
2638 /* Write the version string. */
2639 len = obj_som_version_hdr (abfd)->header_id.length - sizeof (int);
2640 obj_som_file_hdr (abfd)->aux_header_size += len;
2641 current_offset += len;
2642 if (bfd_write ((PTR) obj_som_version_hdr (abfd)->user_string,
2643 len, 1, abfd) != len)
2644 {
2645 bfd_error = system_call_error;
2646 return false;
2647 }
2648 }
2649
2650 if (obj_som_copyright_hdr (abfd) != NULL)
2651 {
2652 unsigned int len;
2653
2654 bfd_seek (abfd, current_offset, SEEK_SET);
2655
2656 /* Write the aux_id structure and the string length. */
2657 len = sizeof (struct aux_id) + sizeof (unsigned int);
2658 obj_som_file_hdr (abfd)->aux_header_size += len;
2659 current_offset += len;
2660 if (bfd_write ((PTR) obj_som_copyright_hdr (abfd), len, 1, abfd) != len)
2661 {
2662 bfd_error = system_call_error;
2663 return false;
2664 }
2665
2666 /* Write the copyright string. */
2667 len = obj_som_copyright_hdr (abfd)->header_id.length - sizeof (int);
2668 obj_som_file_hdr (abfd)->aux_header_size += len;
2669 current_offset += len;
2670 if (bfd_write ((PTR) obj_som_copyright_hdr (abfd)->copyright,
2671 len, 1, abfd) != len)
2672 {
2673 bfd_error = system_call_error;
2674 return false;
2675 }
2676 }
2677
2678 /* Next comes the initialization pointers; we have no initialization
2679 pointers, so current offset does not change. */
2680 obj_som_file_hdr (abfd)->init_array_location = current_offset;
2681 obj_som_file_hdr (abfd)->init_array_total = 0;
2682
2683 /* Next are the space records. These are fixed length records.
2684
2685 Count the number of spaces to determine how much room is needed
2686 in the object file for the space records.
2687
2688 The names of the spaces are stored in a separate string table,
2689 and the index for each space into the string table is computed
2690 below. Therefore, it is not possible to write the space headers
2691 at this time. */
2692 num_spaces = som_count_spaces (abfd);
2693 obj_som_file_hdr (abfd)->space_location = current_offset;
2694 obj_som_file_hdr (abfd)->space_total = num_spaces;
2695 current_offset += num_spaces * sizeof (struct space_dictionary_record);
2696
2697 /* Next are the subspace records. These are fixed length records.
2698
2699 Count the number of subspaes to determine how much room is needed
2700 in the object file for the subspace records.
2701
2702 A variety if fields in the subspace record are still unknown at
2703 this time (index into string table, fixup stream location/size, etc). */
2704 num_subspaces = som_count_subspaces (abfd);
2705 obj_som_file_hdr (abfd)->subspace_location = current_offset;
2706 obj_som_file_hdr (abfd)->subspace_total = num_subspaces;
2707 current_offset += num_subspaces * sizeof (struct subspace_dictionary_record);
2708
2709 /* Next is the string table for the space/subspace names. We will
2710 build and write the string table on the fly. At the same time
2711 we will fill in the space/subspace name index fields. */
2712
2713 /* The string table needs to be aligned on a word boundary. */
2714 if (current_offset % 4)
2715 current_offset += (4 - (current_offset % 4));
2716
2717 /* Mark the offset of the space/subspace string table in the
2718 file header. */
2719 obj_som_file_hdr (abfd)->space_strings_location = current_offset;
2720
2721 /* Scribble out the space strings. */
2722 if (som_write_space_strings (abfd, current_offset, &strings_size) == false)
2723 return false;
2724
2725 /* Record total string table size in the header and update the
2726 current offset. */
2727 obj_som_file_hdr (abfd)->space_strings_size = strings_size;
2728 current_offset += strings_size;
2729
2730 /* Next is the symbol table. These are fixed length records.
2731
2732 Count the number of symbols to determine how much room is needed
2733 in the object file for the symbol table.
2734
2735 The names of the symbols are stored in a separate string table,
2736 and the index for each symbol name into the string table is computed
2737 below. Therefore, it is not possible to write the symobl table
2738 at this time. */
2739 num_syms = bfd_get_symcount (abfd);
2740 obj_som_file_hdr (abfd)->symbol_location = current_offset;
2741 obj_som_file_hdr (abfd)->symbol_total = num_syms;
2742 current_offset += num_syms * sizeof (struct symbol_dictionary_record);
2743
2744 /* Do prep work before handling fixups. */
2745 som_prep_for_fixups (abfd, syms, num_syms);
2746
2747 /* Next comes the fixup stream which starts on a word boundary. */
2748 if (current_offset % 4)
2749 current_offset += (4 - (current_offset % 4));
2750 obj_som_file_hdr (abfd)->fixup_request_location = current_offset;
2751
2752 /* Write the fixups and update fields in subspace headers which
2753 relate to the fixup stream. */
2754 if (som_write_fixups (abfd, current_offset, &total_reloc_size) == false)
2755 return false;
2756
2757 /* Record the total size of the fixup stream in the file header. */
2758 obj_som_file_hdr (abfd)->fixup_request_total = total_reloc_size;
2759 current_offset += total_reloc_size;
2760
2761 /* Next are the symbol strings.
2762 Align them to a word boundary. */
2763 if (current_offset % 4)
2764 current_offset += (4 - (current_offset % 4));
2765 obj_som_file_hdr (abfd)->symbol_strings_location = current_offset;
2766
2767 /* Scribble out the symbol strings. */
2768 if (som_write_symbol_strings (abfd, current_offset, syms,
2769 num_syms, &strings_size)
2770 == false)
2771 return false;
2772
2773 /* Record total string table size in header and update the
2774 current offset. */
2775 obj_som_file_hdr (abfd)->symbol_strings_size = strings_size;
2776 current_offset += strings_size;
2777
2778 /* Next is the compiler records. We do not use these. */
2779 obj_som_file_hdr (abfd)->compiler_location = current_offset;
2780 obj_som_file_hdr (abfd)->compiler_total = 0;
2781
2782 /* Now compute the file positions for the loadable subspaces. */
2783
2784 section = abfd->sections;
2785 for (i = 0; i < num_spaces; i++)
2786 {
2787 asection *subsection;
2788
2789 /* Find a space. */
2790 while (som_section_data (section)->is_space == 0)
2791 section = section->next;
2792
2793 /* Now look for all its subspaces. */
2794 for (subsection = abfd->sections;
2795 subsection != NULL;
2796 subsection = subsection->next)
2797 {
2798
2799 if (som_section_data (subsection)->is_subspace == 0
2800 || som_section_data (subsection)->containing_space != section
2801 || (subsection->flags & SEC_ALLOC) == 0)
2802 continue;
2803
2804 som_section_data (subsection)->subspace_index = total_subspaces++;
2805 /* This is real data to be loaded from the file. */
2806 if (subsection->flags & SEC_LOAD)
2807 {
2808 som_section_data (subsection)->subspace_dict.file_loc_init_value
2809 = current_offset;
2810 section->filepos = current_offset;
2811 current_offset += bfd_section_size (abfd, subsection);
2812 }
2813 /* Looks like uninitialized data. */
2814 else
2815 {
2816 som_section_data (subsection)->subspace_dict.file_loc_init_value
2817 = 0;
2818 som_section_data (subsection)->subspace_dict.
2819 initialization_length = 0;
2820 }
2821 }
2822 /* Goto the next section. */
2823 section = section->next;
2824 }
2825
2826 /* Finally compute the file positions for unloadable subspaces. */
2827
2828 obj_som_file_hdr (abfd)->unloadable_sp_location = current_offset;
2829 section = abfd->sections;
2830 for (i = 0; i < num_spaces; i++)
2831 {
2832 asection *subsection;
2833
2834 /* Find a space. */
2835 while (som_section_data (section)->is_space == 0)
2836 section = section->next;
2837
2838 /* Now look for all its subspaces. */
2839 for (subsection = abfd->sections;
2840 subsection != NULL;
2841 subsection = subsection->next)
2842 {
2843
2844 if (som_section_data (subsection)->is_subspace == 0
2845 || som_section_data (subsection)->containing_space != section
2846 || (subsection->flags & SEC_ALLOC) != 0)
2847 continue;
2848
2849 som_section_data (subsection)->subspace_index = total_subspaces++;
2850 /* This is real data to be loaded from the file. */
2851 if ((subsection->flags & SEC_LOAD) == 0)
2852 {
2853 som_section_data (subsection)->subspace_dict.file_loc_init_value
2854 = current_offset;
2855 section->filepos = current_offset;
2856 current_offset += bfd_section_size (abfd, subsection);
2857 }
2858 /* Looks like uninitialized data. */
2859 else
2860 {
2861 som_section_data (subsection)->subspace_dict.file_loc_init_value
2862 = 0;
2863 som_section_data (subsection)->subspace_dict.
2864 initialization_length = bfd_section_size (abfd, subsection);
2865 }
2866 }
2867 /* Goto the next section. */
2868 section = section->next;
2869 }
2870
2871 obj_som_file_hdr (abfd)->unloadable_sp_size
2872 = current_offset - obj_som_file_hdr (abfd)->unloadable_sp_location;
2873
2874 /* Loader fixups are not supported in any way shape or form. */
2875 obj_som_file_hdr (abfd)->loader_fixup_location = 0;
2876 obj_som_file_hdr (abfd)->loader_fixup_total = 0;
2877
2878 /* Done. Store the total size of the SOM. */
2879 obj_som_file_hdr (abfd)->som_length = current_offset;
2880 return true;
2881 }
2882
2883 /* Finally, scribble out the various headers to the disk. */
2884
2885 static boolean
2886 som_write_headers (abfd)
2887 bfd *abfd;
2888 {
2889 int num_spaces = som_count_spaces (abfd);
2890 int i;
2891 int subspace_index = 0;
2892 file_ptr location;
2893 asection *section;
2894
2895 /* Subspaces are written first so that we can set up information
2896 about them in their containing spaces as the subspace is written. */
2897
2898 /* Seek to the start of the subspace dictionary records. */
2899 location = obj_som_file_hdr (abfd)->subspace_location;
2900 bfd_seek (abfd, location, SEEK_SET);
2901 section = abfd->sections;
2902 /* Now for each loadable space write out records for its subspaces. */
2903 for (i = 0; i < num_spaces; i++)
2904 {
2905 asection *subsection;
2906
2907 /* Find a space. */
2908 while (som_section_data (section)->is_space == 0)
2909 section = section->next;
2910
2911 /* Now look for all its subspaces. */
2912 for (subsection = abfd->sections;
2913 subsection != NULL;
2914 subsection = subsection->next)
2915 {
2916
2917 /* Skip any section which does not correspond to a space
2918 or subspace. Or does not have SEC_ALLOC set (and therefore
2919 has no real bits on the disk). */
2920 if (som_section_data (subsection)->is_subspace == 0
2921 || som_section_data (subsection)->containing_space != section
2922 || (subsection->flags & SEC_ALLOC) == 0)
2923 continue;
2924
2925 /* If this is the first subspace for this space, then save
2926 the index of the subspace in its containing space. Also
2927 set "is_loadable" in the containing space. */
2928
2929 if (som_section_data (section)->space_dict.subspace_quantity == 0)
2930 {
2931 som_section_data (section)->space_dict.is_loadable = 1;
2932 som_section_data (section)->space_dict.subspace_index
2933 = subspace_index;
2934 }
2935
2936 /* Increment the number of subspaces seen and the number of
2937 subspaces contained within the current space. */
2938 subspace_index++;
2939 som_section_data (section)->space_dict.subspace_quantity++;
2940
2941 /* Mark the index of the current space within the subspace's
2942 dictionary record. */
2943 som_section_data (subsection)->subspace_dict.space_index = i;
2944
2945 /* Dump the current subspace header. */
2946 if (bfd_write ((PTR) &som_section_data (subsection)->subspace_dict,
2947 sizeof (struct subspace_dictionary_record), 1, abfd)
2948 != sizeof (struct subspace_dictionary_record))
2949 {
2950 bfd_error = system_call_error;
2951 return false;
2952 }
2953 }
2954 /* Goto the next section. */
2955 section = section->next;
2956 }
2957
2958 /* Now repeat the process for unloadable subspaces. */
2959 section = abfd->sections;
2960 /* Now for each space write out records for its subspaces. */
2961 for (i = 0; i < num_spaces; i++)
2962 {
2963 asection *subsection;
2964
2965 /* Find a space. */
2966 while (som_section_data (section)->is_space == 0)
2967 section = section->next;
2968
2969 /* Now look for all its subspaces. */
2970 for (subsection = abfd->sections;
2971 subsection != NULL;
2972 subsection = subsection->next)
2973 {
2974
2975 /* Skip any section which does not correspond to a space or
2976 subspace, or which SEC_ALLOC set (and therefore handled
2977 in the loadable spaces/subspaces code above. */
2978
2979 if (som_section_data (subsection)->is_subspace == 0
2980 || som_section_data (subsection)->containing_space != section
2981 || (subsection->flags & SEC_ALLOC) != 0)
2982 continue;
2983
2984 /* If this is the first subspace for this space, then save
2985 the index of the subspace in its containing space. Clear
2986 "is_loadable". */
2987
2988 if (som_section_data (section)->space_dict.subspace_quantity == 0)
2989 {
2990 som_section_data (section)->space_dict.is_loadable = 0;
2991 som_section_data (section)->space_dict.subspace_index
2992 = subspace_index;
2993 }
2994
2995 /* Increment the number of subspaces seen and the number of
2996 subspaces contained within the current space. */
2997 som_section_data (section)->space_dict.subspace_quantity++;
2998 subspace_index++;
2999
3000 /* Mark the index of the current space within the subspace's
3001 dictionary record. */
3002 som_section_data (subsection)->subspace_dict.space_index = i;
3003
3004 /* Dump this subspace header. */
3005 if (bfd_write ((PTR) &som_section_data (subsection)->subspace_dict,
3006 sizeof (struct subspace_dictionary_record), 1, abfd)
3007 != sizeof (struct subspace_dictionary_record))
3008 {
3009 bfd_error = system_call_error;
3010 return false;
3011 }
3012 }
3013 /* Goto the next section. */
3014 section = section->next;
3015 }
3016
3017 /* All the subspace dictiondary records are written, and all the
3018 fields are set up in the space dictionary records.
3019
3020 Seek to the right location and start writing the space
3021 dictionary records. */
3022 location = obj_som_file_hdr (abfd)->space_location;
3023 bfd_seek (abfd, location, SEEK_SET);
3024
3025 section = abfd->sections;
3026 for (i = 0; i < num_spaces; i++)
3027 {
3028
3029 /* Find a space. */
3030 while (som_section_data (section)->is_space == 0)
3031 section = section->next;
3032
3033 /* Dump its header */
3034 if (bfd_write ((PTR) &som_section_data (section)->space_dict,
3035 sizeof (struct space_dictionary_record), 1, abfd)
3036 != sizeof (struct space_dictionary_record))
3037 {
3038 bfd_error = system_call_error;
3039 return false;
3040 }
3041
3042 /* Goto the next section. */
3043 section = section->next;
3044 }
3045
3046 /* Only thing left to do is write out the file header. It is always
3047 at location zero. Seek there and write it. */
3048 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
3049 if (bfd_write ((PTR) obj_som_file_hdr (abfd),
3050 sizeof (struct header), 1, abfd)
3051 != sizeof (struct header))
3052 {
3053 bfd_error = system_call_error;
3054 return false;
3055 }
3056 return true;
3057 }
3058
3059 /* Compute and return the checksum for a SOM file header. */
3060
3061 static unsigned long
3062 som_compute_checksum (abfd)
3063 bfd *abfd;
3064 {
3065 unsigned long checksum, count, i;
3066 unsigned long *buffer = (unsigned long *) obj_som_file_hdr (abfd);
3067
3068 checksum = 0;
3069 count = sizeof (struct header) / sizeof (unsigned long);
3070 for (i = 0; i < count; i++)
3071 checksum ^= *(buffer + i);
3072
3073 return checksum;
3074 }
3075
3076 /* Build and write, in one big chunk, the entire symbol table for
3077 this BFD. */
3078
3079 static boolean
3080 som_build_and_write_symbol_table (abfd)
3081 bfd *abfd;
3082 {
3083 unsigned int num_syms = bfd_get_symcount (abfd);
3084 file_ptr symtab_location = obj_som_file_hdr (abfd)->symbol_location;
3085 asymbol **bfd_syms = bfd_get_outsymbols (abfd);
3086 struct symbol_dictionary_record *som_symtab;
3087 int i, symtab_size;
3088
3089 /* Compute total symbol table size and allocate a chunk of memory
3090 to hold the symbol table as we build it. */
3091 symtab_size = num_syms * sizeof (struct symbol_dictionary_record);
3092 som_symtab = (struct symbol_dictionary_record *) alloca (symtab_size);
3093 bzero (som_symtab, symtab_size);
3094
3095 /* Walk over each symbol. */
3096 for (i = 0; i < num_syms; i++)
3097 {
3098 /* This is really an index into the symbol strings table.
3099 By the time we get here, the index has already been
3100 computed and stored into the name field in the BFD symbol. */
3101 som_symtab[i].name.n_strx = (int) bfd_syms[i]->name;
3102
3103 /* The HP SOM linker requires detailed type information about
3104 all symbols (including undefined symbols!). Unfortunately,
3105 the type specified in an import/export statement does not
3106 always match what the linker wants. Severe braindamage. */
3107
3108 /* Section symbols will not have a SOM symbol type assigned to
3109 them yet. Assign all section symbols type ST_DATA. */
3110 if (bfd_syms[i]->flags & BSF_SECTION_SYM)
3111 som_symtab[i].symbol_type = ST_DATA;
3112 else
3113 {
3114 /* Common symbols must have scope SS_UNSAT and type
3115 ST_STORAGE or the linker will choke. */
3116 if (bfd_syms[i]->section == &bfd_com_section)
3117 {
3118 som_symtab[i].symbol_scope = SS_UNSAT;
3119 som_symtab[i].symbol_type = ST_STORAGE;
3120 }
3121
3122 /* It is possible to have a symbol without an associated
3123 type. This happens if the user imported the symbol
3124 without a type and the symbol was never defined
3125 locally. If BSF_FUNCTION is set for this symbol, then
3126 assign it type ST_CODE (the HP linker requires undefined
3127 external functions to have type ST_CODE rather than ST_ENTRY. */
3128 else if (((*som_symbol_data (bfd_syms[i]))->som_type
3129 == SYMBOL_TYPE_UNKNOWN)
3130 && (bfd_syms[i]->section == &bfd_und_section)
3131 && (bfd_syms[i]->flags & BSF_FUNCTION))
3132 som_symtab[i].symbol_type = ST_CODE;
3133
3134 /* Handle function symbols which were defined in this file.
3135 They should have type ST_ENTRY. Also retrieve the argument
3136 relocation bits from the SOM backend information. */
3137 else if (((*som_symbol_data (bfd_syms[i]))->som_type
3138 == SYMBOL_TYPE_ENTRY)
3139 || (((*som_symbol_data (bfd_syms[i]))->som_type
3140 == SYMBOL_TYPE_CODE)
3141 && (bfd_syms[i]->flags & BSF_FUNCTION))
3142 || (((*som_symbol_data (bfd_syms[i]))->som_type
3143 == SYMBOL_TYPE_UNKNOWN)
3144 && (bfd_syms[i]->flags & BSF_FUNCTION)))
3145 {
3146 som_symtab[i].symbol_type = ST_ENTRY;
3147 som_symtab[i].arg_reloc
3148 = (*som_symbol_data (bfd_syms[i]))->tc_data.hppa_arg_reloc;
3149 }
3150
3151 /* If the type is unknown at this point, it should be
3152 ST_DATA (functions were handled as special cases above). */
3153 else if ((*som_symbol_data (bfd_syms[i]))->som_type
3154 == SYMBOL_TYPE_UNKNOWN)
3155 som_symtab[i].symbol_type = ST_DATA;
3156
3157 /* From now on it's a very simple mapping. */
3158 else if ((*som_symbol_data (bfd_syms[i]))->som_type
3159 == SYMBOL_TYPE_ABSOLUTE)
3160 som_symtab[i].symbol_type = ST_ABSOLUTE;
3161 else if ((*som_symbol_data (bfd_syms[i]))->som_type
3162 == SYMBOL_TYPE_CODE)
3163 som_symtab[i].symbol_type = ST_CODE;
3164 else if ((*som_symbol_data (bfd_syms[i]))->som_type
3165 == SYMBOL_TYPE_DATA)
3166 som_symtab[i].symbol_type = ST_DATA;
3167 else if ((*som_symbol_data (bfd_syms[i]))->som_type
3168 == SYMBOL_TYPE_MILLICODE)
3169 som_symtab[i].symbol_type = ST_MILLICODE;
3170 else if ((*som_symbol_data (bfd_syms[i]))->som_type
3171 == SYMBOL_TYPE_PLABEL)
3172 som_symtab[i].symbol_type = ST_PLABEL;
3173 else if ((*som_symbol_data (bfd_syms[i]))->som_type
3174 == SYMBOL_TYPE_PRI_PROG)
3175 som_symtab[i].symbol_type = ST_PRI_PROG;
3176 else if ((*som_symbol_data (bfd_syms[i]))->som_type
3177 == SYMBOL_TYPE_SEC_PROG)
3178 som_symtab[i].symbol_type = ST_SEC_PROG;
3179 }
3180
3181 /* Now handle the symbol's scope. Exported data which is not
3182 in the common section has scope SS_UNIVERSAL. Note scope
3183 of common symbols was handled earlier! */
3184 if (bfd_syms[i]->flags & BSF_EXPORT
3185 && bfd_syms[i]->section != &bfd_com_section)
3186 som_symtab[i].symbol_scope = SS_UNIVERSAL;
3187 /* Any undefined symbol at this point has a scope SS_UNSAT. */
3188 else if (bfd_syms[i]->section == &bfd_und_section)
3189 som_symtab[i].symbol_scope = SS_UNSAT;
3190 /* Anything else which is not in the common section has scope
3191 SS_LOCAL. */
3192 else if (bfd_syms[i]->section != &bfd_com_section)
3193 som_symtab[i].symbol_scope = SS_LOCAL;
3194
3195 /* Now set the symbol_info field. It has no real meaning
3196 for undefined or common symbols, but the HP linker will
3197 choke if it's not set to some "reasonable" value. We
3198 use zero as a reasonable value. */
3199 if (bfd_syms[i]->section == &bfd_com_section
3200 || bfd_syms[i]->section == &bfd_und_section)
3201 som_symtab[i].symbol_info = 0;
3202 /* For all other symbols, the symbol_info field contains the
3203 subspace index of the space this symbol is contained in. */
3204 else
3205 som_symtab[i].symbol_info
3206 = som_section_data (bfd_syms[i]->section)->subspace_index;
3207
3208 /* Set the symbol's value. */
3209 som_symtab[i].symbol_value
3210 = bfd_syms[i]->value + bfd_syms[i]->section->vma;
3211 }
3212
3213 /* Egad. Everything is ready, seek to the right location and
3214 scribble out the symbol table. */
3215 if (bfd_seek (abfd, symtab_location, SEEK_SET) != 0)
3216 {
3217 bfd_error = system_call_error;
3218 return false;
3219 }
3220
3221 if (bfd_write ((PTR) som_symtab, symtab_size, 1, abfd) != symtab_size)
3222 {
3223 bfd_error = system_call_error;
3224 return false;
3225 }
3226 return true;
3227 }
3228
3229 /* Write an object in SOM format. */
3230
3231 static boolean
3232 som_write_object_contents (abfd)
3233 bfd *abfd;
3234 {
3235 if (abfd->output_has_begun == false)
3236 {
3237 /* Set up fixed parts of the file, space, and subspace headers.
3238 Notify the world that output has begun. */
3239 som_prep_headers (abfd);
3240 abfd->output_has_begun = true;
3241 /* Start writing the object file. This include all the string
3242 tables, fixup streams, and other portions of the object file. */
3243 som_begin_writing (abfd);
3244 }
3245
3246 /* Now that the symbol table information is complete, build and
3247 write the symbol table. */
3248 if (som_build_and_write_symbol_table (abfd) == false)
3249 return false;
3250
3251 /* Compute the checksum for the file header just before writing
3252 the header to disk. */
3253 obj_som_file_hdr (abfd)->checksum = som_compute_checksum (abfd);
3254 return (som_write_headers (abfd));
3255 }
3256
3257 \f
3258 /* Read and save the string table associated with the given BFD. */
3259
3260 static boolean
3261 som_slurp_string_table (abfd)
3262 bfd *abfd;
3263 {
3264 char *stringtab;
3265
3266 /* Use the saved version if its available. */
3267 if (obj_som_stringtab (abfd) != NULL)
3268 return true;
3269
3270 /* Allocate and read in the string table. */
3271 stringtab = bfd_zalloc (abfd, obj_som_stringtab_size (abfd));
3272 if (stringtab == NULL)
3273 {
3274 bfd_error = no_memory;
3275 return false;
3276 }
3277
3278 if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) < 0)
3279 {
3280 bfd_error = system_call_error;
3281 return false;
3282 }
3283
3284 if (bfd_read (stringtab, obj_som_stringtab_size (abfd), 1, abfd)
3285 != obj_som_stringtab_size (abfd))
3286 {
3287 bfd_error = system_call_error;
3288 return false;
3289 }
3290
3291 /* Save our results and return success. */
3292 obj_som_stringtab (abfd) = stringtab;
3293 return true;
3294 }
3295
3296 /* Return the amount of data (in bytes) required to hold the symbol
3297 table for this object. */
3298
3299 static unsigned int
3300 som_get_symtab_upper_bound (abfd)
3301 bfd *abfd;
3302 {
3303 if (!som_slurp_symbol_table (abfd))
3304 return 0;
3305
3306 return (bfd_get_symcount (abfd) + 1) * (sizeof (som_symbol_type *));
3307 }
3308
3309 /* Convert from a SOM subspace index to a BFD section. */
3310
3311 static asection *
3312 som_section_from_subspace_index (abfd, index)
3313 bfd *abfd;
3314 unsigned int index;
3315 {
3316 asection *section;
3317
3318 for (section = abfd->sections; section != NULL; section = section->next)
3319 if (som_section_data (section)->subspace_index == index)
3320 return section;
3321
3322 /* Should never happen. */
3323 abort();
3324 }
3325
3326 /* Read and save the symbol table associated with the given BFD. */
3327
3328 static unsigned int
3329 som_slurp_symbol_table (abfd)
3330 bfd *abfd;
3331 {
3332 int symbol_count = bfd_get_symcount (abfd);
3333 int symsize = sizeof (struct symbol_dictionary_record);
3334 char *stringtab;
3335 struct symbol_dictionary_record *buf, *bufp, *endbufp;
3336 som_symbol_type *sym, *symbase;
3337
3338 /* Return saved value if it exists. */
3339 if (obj_som_symtab (abfd) != NULL)
3340 return true;
3341
3342 /* Sanity checking. Make sure there are some symbols and that
3343 we can read the string table too. */
3344 if (symbol_count == 0)
3345 {
3346 bfd_error = no_symbols;
3347 return false;
3348 }
3349
3350 if (!som_slurp_string_table (abfd))
3351 return false;
3352
3353 stringtab = obj_som_stringtab (abfd);
3354
3355 symbase = (som_symbol_type *)
3356 bfd_zalloc (abfd, symbol_count * sizeof (som_symbol_type));
3357 if (symbase == NULL)
3358 {
3359 bfd_error = no_memory;
3360 return false;
3361 }
3362
3363 /* Read in the external SOM representation. */
3364 buf = alloca (symbol_count * symsize);
3365 if (buf == NULL)
3366 {
3367 bfd_error = no_memory;
3368 return false;
3369 }
3370 if (bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET) < 0)
3371 {
3372 bfd_error = system_call_error;
3373 return false;
3374 }
3375 if (bfd_read (buf, symbol_count * symsize, 1, abfd)
3376 != symbol_count * symsize)
3377 {
3378 bfd_error = no_symbols;
3379 return (false);
3380 }
3381
3382 /* Iterate over all the symbols and internalize them. */
3383 endbufp = buf + symbol_count;
3384 for (bufp = buf, sym = symbase; bufp < endbufp; ++bufp)
3385 {
3386
3387 /* I don't think we care about these. */
3388 if (bufp->symbol_type == ST_SYM_EXT
3389 || bufp->symbol_type == ST_ARG_EXT)
3390 continue;
3391
3392 /* Some reasonable defaults. */
3393 sym->symbol.the_bfd = abfd;
3394 sym->symbol.name = bufp->name.n_strx + stringtab;
3395 sym->symbol.value = bufp->symbol_value;
3396 sym->symbol.section = 0;
3397 sym->symbol.flags = 0;
3398
3399 switch (bufp->symbol_type)
3400 {
3401 case ST_ENTRY:
3402 case ST_PRI_PROG:
3403 case ST_SEC_PROG:
3404 case ST_MILLICODE:
3405 sym->symbol.flags |= BSF_FUNCTION;
3406 sym->symbol.value &= ~0x3;
3407 break;
3408
3409 case ST_STUB:
3410 case ST_CODE:
3411 sym->symbol.value &= ~0x3;
3412
3413 default:
3414 break;
3415 }
3416
3417 /* Handle scoping and section information. */
3418 switch (bufp->symbol_scope)
3419 {
3420 /* symbol_info field is undefined for SS_EXTERNAL and SS_UNSAT symbols,
3421 so the section associated with this symbol can't be known. */
3422 case SS_EXTERNAL:
3423 case SS_UNSAT:
3424 if (bufp->symbol_type != ST_STORAGE)
3425 sym->symbol.section = &bfd_und_section;
3426 else
3427 sym->symbol.section = &bfd_com_section;
3428 sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
3429 break;
3430
3431 case SS_UNIVERSAL:
3432 sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
3433 sym->symbol.section
3434 = som_section_from_subspace_index (abfd, bufp->symbol_info);
3435 sym->symbol.value -= sym->symbol.section->vma;
3436 break;
3437
3438 #if 0
3439 /* SS_GLOBAL and SS_LOCAL are two names for the same thing.
3440 Sound dumb? It is. */
3441 case SS_GLOBAL:
3442 #endif
3443 case SS_LOCAL:
3444 sym->symbol.flags |= BSF_LOCAL;
3445 sym->symbol.section
3446 = som_section_from_subspace_index (abfd, bufp->symbol_info);
3447 sym->symbol.value -= sym->symbol.section->vma;
3448 break;
3449 }
3450
3451 /* Mark symbols left around by the debugger. */
3452 if (strlen (sym->symbol.name) >= 2
3453 && sym->symbol.name[0] == 'L'
3454 && (sym->symbol.name[1] == '$' || sym->symbol.name[2] == '$'
3455 || sym->symbol.name[3] == '$'))
3456 sym->symbol.flags |= BSF_DEBUGGING;
3457
3458 /* Note increment at bottom of loop, since we skip some symbols
3459 we can not include it as part of the for statement. */
3460 sym++;
3461 }
3462
3463 /* Save our results and return success. */
3464 obj_som_symtab (abfd) = symbase;
3465 return (true);
3466 }
3467
3468 /* Canonicalize a SOM symbol table. Return the number of entries
3469 in the symbol table. */
3470
3471 static unsigned int
3472 som_get_symtab (abfd, location)
3473 bfd *abfd;
3474 asymbol **location;
3475 {
3476 int i;
3477 som_symbol_type *symbase;
3478
3479 if (!som_slurp_symbol_table (abfd))
3480 return 0;
3481
3482 i = bfd_get_symcount (abfd);
3483 symbase = obj_som_symtab (abfd);
3484
3485 for (; i > 0; i--, location++, symbase++)
3486 *location = &symbase->symbol;
3487
3488 /* Final null pointer. */
3489 *location = 0;
3490 return (bfd_get_symcount (abfd));
3491 }
3492
3493 /* Make a SOM symbol. There is nothing special to do here. */
3494
3495 static asymbol *
3496 som_make_empty_symbol (abfd)
3497 bfd *abfd;
3498 {
3499 som_symbol_type *new =
3500 (som_symbol_type *) bfd_zalloc (abfd, sizeof (som_symbol_type));
3501 if (new == NULL)
3502 {
3503 bfd_error = no_memory;
3504 return 0;
3505 }
3506 new->symbol.the_bfd = abfd;
3507
3508 return &new->symbol;
3509 }
3510
3511 /* Print symbol information. */
3512
3513 static void
3514 som_print_symbol (ignore_abfd, afile, symbol, how)
3515 bfd *ignore_abfd;
3516 PTR afile;
3517 asymbol *symbol;
3518 bfd_print_symbol_type how;
3519 {
3520 FILE *file = (FILE *) afile;
3521 switch (how)
3522 {
3523 case bfd_print_symbol_name:
3524 fprintf (file, "%s", symbol->name);
3525 break;
3526 case bfd_print_symbol_more:
3527 fprintf (file, "som ");
3528 fprintf_vma (file, symbol->value);
3529 fprintf (file, " %lx", (long) symbol->flags);
3530 break;
3531 case bfd_print_symbol_all:
3532 {
3533 CONST char *section_name;
3534 section_name = symbol->section ? symbol->section->name : "(*none*)";
3535 bfd_print_symbol_vandf ((PTR) file, symbol);
3536 fprintf (file, " %s\t%s", section_name, symbol->name);
3537 break;
3538 }
3539 }
3540 }
3541
3542 /* Count or process variable-length SOM fixup records.
3543
3544 To avoid code duplication we use this code both to compute the number
3545 of relocations requested by a stream, and to internalize the stream.
3546
3547 When computing the number of relocations requested by a stream the
3548 variables rptr, section, and symbols have no meaning.
3549
3550 Return the number of relocations requested by the fixup stream. When
3551 not just counting
3552
3553 This needs at least two or three more passes to get it cleaned up. */
3554
3555 static unsigned int
3556 som_set_reloc_info (fixup, end, internal_relocs, section, symbols, just_count)
3557 unsigned char *fixup;
3558 unsigned int end;
3559 arelent *internal_relocs;
3560 asection *section;
3561 asymbol **symbols;
3562 boolean just_count;
3563 {
3564 unsigned int op, varname;
3565 unsigned char *end_fixups = &fixup[end];
3566 const struct fixup_format *fp;
3567 char *cp;
3568 unsigned char *save_fixup;
3569 int variables[26], stack[20], c, v, count, prev_fixup, *sp;
3570 const int *subop;
3571 arelent *rptr= internal_relocs;
3572 unsigned int offset = just_count ? 0 : section->vma;
3573
3574 #define var(c) variables[(c) - 'A']
3575 #define push(v) (*sp++ = (v))
3576 #define pop() (*--sp)
3577 #define emptystack() (sp == stack)
3578
3579 som_initialize_reloc_queue (reloc_queue);
3580 bzero (variables, sizeof (variables));
3581 bzero (stack, sizeof (stack));
3582 count = 0;
3583 prev_fixup = 0;
3584 sp = stack;
3585
3586 while (fixup < end_fixups)
3587 {
3588
3589 /* Save pointer to the start of this fixup. We'll use
3590 it later to determine if it is necessary to put this fixup
3591 on the queue. */
3592 save_fixup = fixup;
3593
3594 /* Get the fixup code and its associated format. */
3595 op = *fixup++;
3596 fp = &som_fixup_formats[op];
3597
3598 /* Handle a request for a previous fixup. */
3599 if (*fp->format == 'P')
3600 {
3601 /* Get pointer to the beginning of the prev fixup, move
3602 the repeated fixup to the head of the queue. */
3603 fixup = reloc_queue[fp->D].reloc;
3604 som_reloc_queue_fix (reloc_queue, fp->D);
3605 prev_fixup = 1;
3606
3607 /* Get the fixup code and its associated format. */
3608 op = *fixup++;
3609 fp = &som_fixup_formats[op];
3610 }
3611
3612 /* If we are not just counting, set some reasonable defaults. */
3613 if (! just_count)
3614 {
3615 rptr->address = offset;
3616 rptr->howto = &som_hppa_howto_table[op];
3617 rptr->addend = 0;
3618 rptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
3619 }
3620
3621 /* Set default input length to 0. Get the opcode class index
3622 into D. */
3623 var ('L') = 0;
3624 var ('D') = fp->D;
3625
3626 /* Get the opcode format. */
3627 cp = fp->format;
3628
3629 /* Process the format string. Parsing happens in two phases,
3630 parse RHS, then assign to LHS. Repeat until no more
3631 characters in the format string. */
3632 while (*cp)
3633 {
3634 /* The variable this pass is going to compute a value for. */
3635 varname = *cp++;
3636
3637 /* Start processing RHS. Continue until a NULL or '=' is found. */
3638 do
3639 {
3640 c = *cp++;
3641
3642 /* If this is a variable, push it on the stack. */
3643 if (isupper (c))
3644 push (var (c));
3645
3646 /* If this is a lower case letter, then it represents
3647 additional data from the fixup stream to be pushed onto
3648 the stack. */
3649 else if (islower (c))
3650 {
3651 for (v = 0; c > 'a'; --c)
3652 v = (v << 8) | *fixup++;
3653 push (v);
3654 }
3655
3656 /* A decimal constant. Push it on the stack. */
3657 else if (isdigit (c))
3658 {
3659 v = c - '0';
3660 while (isdigit (*cp))
3661 v = (v * 10) + (*cp++ - '0');
3662 push (v);
3663 }
3664 else
3665
3666 /* An operator. Pop two two values from the stack and
3667 use them as operands to the given operation. Push
3668 the result of the operation back on the stack. */
3669 switch (c)
3670 {
3671 case '+':
3672 v = pop ();
3673 v += pop ();
3674 push (v);
3675 break;
3676 case '*':
3677 v = pop ();
3678 v *= pop ();
3679 push (v);
3680 break;
3681 case '<':
3682 v = pop ();
3683 v = pop () << v;
3684 push (v);
3685 break;
3686 default:
3687 abort ();
3688 }
3689 }
3690 while (*cp && *cp != '=');
3691
3692 /* Move over the equal operator. */
3693 cp++;
3694
3695 /* Pop the RHS off the stack. */
3696 c = pop ();
3697
3698 /* Perform the assignment. */
3699 var (varname) = c;
3700
3701 /* Handle side effects. and special 'O' stack cases. */
3702 switch (varname)
3703 {
3704 /* Consume some bytes from the input space. */
3705 case 'L':
3706 offset += c;
3707 break;
3708 /* A symbol to use in the relocation. Make a note
3709 of this if we are not just counting. */
3710 case 'S':
3711 if (! just_count)
3712 rptr->sym_ptr_ptr = &symbols[c];
3713 break;
3714 /* Handle the linker expression stack. */
3715 case 'O':
3716 switch (op)
3717 {
3718 case R_COMP1:
3719 subop = comp1_opcodes;
3720 break;
3721 case R_COMP2:
3722 subop = comp2_opcodes;
3723 break;
3724 case R_COMP3:
3725 subop = comp3_opcodes;
3726 break;
3727 default:
3728 abort ();
3729 }
3730 while (*subop <= (unsigned char) c)
3731 ++subop;
3732 --subop;
3733 break;
3734 default:
3735 break;
3736 }
3737 }
3738
3739 /* If we used a previous fixup, clean up after it. */
3740 if (prev_fixup)
3741 {
3742 fixup = save_fixup + 1;
3743 prev_fixup = 0;
3744 }
3745 /* Queue it. */
3746 else if (fixup > save_fixup + 1)
3747 som_reloc_queue_insert (save_fixup, fixup - save_fixup, reloc_queue);
3748
3749 /* We do not pass R_DATA_OVERRIDE or R_NO_RELOCATION
3750 fixups to BFD. */
3751 if (som_hppa_howto_table[op].type != R_DATA_OVERRIDE
3752 && som_hppa_howto_table[op].type != R_NO_RELOCATION)
3753 {
3754 /* Done with a single reloction. Loop back to the top. */
3755 if (! just_count)
3756 {
3757 rptr->addend = var ('V');
3758 rptr++;
3759 }
3760 count++;
3761 /* Now that we've handled a "full" relocation, reset
3762 some state. */
3763 bzero (variables, sizeof (variables));
3764 bzero (stack, sizeof (stack));
3765 }
3766 }
3767 return count;
3768
3769 #undef var
3770 #undef push
3771 #undef pop
3772 #undef emptystack
3773 }
3774
3775 /* Read in the relocs (aka fixups in SOM terms) for a section.
3776
3777 som_get_reloc_upper_bound calls this routine with JUST_COUNT
3778 set to true to indicate it only needs a count of the number
3779 of actual relocations. */
3780
3781 static boolean
3782 som_slurp_reloc_table (abfd, section, symbols, just_count)
3783 bfd *abfd;
3784 asection *section;
3785 asymbol **symbols;
3786 boolean just_count;
3787 {
3788 char *external_relocs;
3789 unsigned int fixup_stream_size;
3790 arelent *internal_relocs;
3791 unsigned int num_relocs;
3792
3793 fixup_stream_size = som_section_data (section)->reloc_size;
3794 /* If there were no relocations, then there is nothing to do. */
3795 if (section->reloc_count == 0)
3796 return true;
3797
3798 /* If reloc_count is -1, then the relocation stream has not been
3799 parsed. We must do so now to know how many relocations exist. */
3800 if (section->reloc_count == -1)
3801 {
3802 external_relocs = (char *) bfd_zalloc (abfd, fixup_stream_size);
3803 if (external_relocs == (char *) NULL)
3804 {
3805 bfd_error = no_memory;
3806 return false;
3807 }
3808 /* Read in the external forms. */
3809 if (bfd_seek (abfd,
3810 obj_som_reloc_filepos (abfd) + section->rel_filepos,
3811 SEEK_SET)
3812 != 0)
3813 {
3814 bfd_error = system_call_error;
3815 return false;
3816 }
3817 if (bfd_read (external_relocs, 1, fixup_stream_size, abfd)
3818 != fixup_stream_size)
3819 {
3820 bfd_error = system_call_error;
3821 return false;
3822 }
3823 /* Let callers know how many relocations found.
3824 also save the relocation stream as we will
3825 need it again. */
3826 section->reloc_count = som_set_reloc_info (external_relocs,
3827 fixup_stream_size,
3828 NULL, NULL, NULL, true);
3829
3830 som_section_data (section)->reloc_stream = external_relocs;
3831 }
3832
3833 /* If the caller only wanted a count, then return now. */
3834 if (just_count)
3835 return true;
3836
3837 num_relocs = section->reloc_count;
3838 external_relocs = som_section_data (section)->reloc_stream;
3839 /* Return saved information about the relocations if it is available. */
3840 if (section->relocation != (arelent *) NULL)
3841 return true;
3842
3843 internal_relocs = (arelent *) bfd_zalloc (abfd,
3844 num_relocs * sizeof (arelent));
3845 if (internal_relocs == (arelent *) NULL)
3846 {
3847 bfd_error = no_memory;
3848 return false;
3849 }
3850
3851 /* Process and internalize the relocations. */
3852 som_set_reloc_info (external_relocs, fixup_stream_size,
3853 internal_relocs, section, symbols, false);
3854
3855 /* Save our results and return success. */
3856 section->relocation = internal_relocs;
3857 return (true);
3858 }
3859
3860 /* Return the number of bytes required to store the relocation
3861 information associated with the given section. */
3862
3863 static unsigned int
3864 som_get_reloc_upper_bound (abfd, asect)
3865 bfd *abfd;
3866 sec_ptr asect;
3867 {
3868 /* If section has relocations, then read in the relocation stream
3869 and parse it to determine how many relocations exist. */
3870 if (asect->flags & SEC_RELOC)
3871 {
3872 if (som_slurp_reloc_table (abfd, asect, NULL, true))
3873 return (asect->reloc_count + 1) * sizeof (arelent);
3874 }
3875 /* Either there are no relocations or an error occurred while
3876 reading and parsing the relocation stream. */
3877 return 0;
3878 }
3879
3880 /* Convert relocations from SOM (external) form into BFD internal
3881 form. Return the number of relocations. */
3882
3883 static unsigned int
3884 som_canonicalize_reloc (abfd, section, relptr, symbols)
3885 bfd *abfd;
3886 sec_ptr section;
3887 arelent **relptr;
3888 asymbol **symbols;
3889 {
3890 arelent *tblptr;
3891 int count;
3892
3893 if (som_slurp_reloc_table (abfd, section, symbols, false) == false)
3894 return 0;
3895
3896 count = section->reloc_count;
3897 tblptr = section->relocation;
3898 if (tblptr == (arelent *) NULL)
3899 return 0;
3900
3901 while (count--)
3902 *relptr++ = tblptr++;
3903
3904 *relptr = (arelent *) NULL;
3905 return section->reloc_count;
3906 }
3907
3908 extern bfd_target som_vec;
3909
3910 /* A hook to set up object file dependent section information. */
3911
3912 static boolean
3913 som_new_section_hook (abfd, newsect)
3914 bfd *abfd;
3915 asection *newsect;
3916 {
3917 newsect->used_by_bfd =
3918 (PTR) bfd_zalloc (abfd, sizeof (struct som_section_data_struct));
3919 if (!newsect->used_by_bfd)
3920 {
3921 bfd_error = no_memory;
3922 return false;
3923 }
3924 newsect->alignment_power = 3;
3925
3926 /* Initialize the subspace_index field to -1 so that it does
3927 not match a subspace with an index of 0. */
3928 som_section_data (newsect)->subspace_index = -1;
3929
3930 /* We allow more than three sections internally */
3931 return true;
3932 }
3933
3934 /* Set backend info for sections which can not be described
3935 in the BFD data structures. */
3936
3937 void
3938 bfd_som_set_section_attributes (section, defined, private, sort_key, spnum)
3939 asection *section;
3940 int defined;
3941 int private;
3942 unsigned char sort_key;
3943 int spnum;
3944 {
3945 struct space_dictionary_record *space_dict;
3946
3947 som_section_data (section)->is_space = 1;
3948 space_dict = &som_section_data (section)->space_dict;
3949 space_dict->is_defined = defined;
3950 space_dict->is_private = private;
3951 space_dict->sort_key = sort_key;
3952 space_dict->space_number = spnum;
3953 }
3954
3955 /* Set backend info for subsections which can not be described
3956 in the BFD data structures. */
3957
3958 void
3959 bfd_som_set_subsection_attributes (section, container, access,
3960 sort_key, quadrant)
3961 asection *section;
3962 asection *container;
3963 int access;
3964 unsigned int sort_key;
3965 int quadrant;
3966 {
3967 struct subspace_dictionary_record *subspace_dict;
3968 som_section_data (section)->is_subspace = 1;
3969 subspace_dict = &som_section_data (section)->subspace_dict;
3970 subspace_dict->access_control_bits = access;
3971 subspace_dict->sort_key = sort_key;
3972 subspace_dict->quadrant = quadrant;
3973 som_section_data (section)->containing_space = container;
3974 }
3975
3976 /* Set the full SOM symbol type. SOM needs far more symbol information
3977 than any other object file format I'm aware of. It is mandatory
3978 to be able to know if a symbol is an entry point, millicode, data,
3979 code, absolute, storage request, or procedure label. If you get
3980 the symbol type wrong your program will not link. */
3981
3982 void
3983 bfd_som_set_symbol_type (symbol, type)
3984 asymbol *symbol;
3985 unsigned int type;
3986 {
3987 (*som_symbol_data (symbol))->som_type = type;
3988 }
3989
3990 /* Attach 64bits of unwind information to a symbol (which hopefully
3991 is a function of some kind!). It would be better to keep this
3992 in the R_ENTRY relocation, but there is not enough space. */
3993
3994 void
3995 bfd_som_attach_unwind_info (symbol, unwind_desc)
3996 asymbol *symbol;
3997 char *unwind_desc;
3998 {
3999 (*som_symbol_data (symbol))->unwind = unwind_desc;
4000 }
4001
4002 /* Attach an auxiliary header to the BFD backend so that it may be
4003 written into the object file. */
4004 void
4005 bfd_som_attach_aux_hdr (abfd, type, string)
4006 bfd *abfd;
4007 int type;
4008 char *string;
4009 {
4010 if (type == VERSION_AUX_ID)
4011 {
4012 int len = strlen (string);
4013 int pad = 0;
4014
4015 if (len % 4)
4016 pad = (4 - (len % 4));
4017 obj_som_version_hdr (abfd) = (struct user_string_aux_hdr *)
4018 bfd_zalloc (abfd, sizeof (struct aux_id)
4019 + sizeof (unsigned int) + len + pad);
4020 if (!obj_som_version_hdr (abfd))
4021 {
4022 bfd_error = no_memory;
4023 abort(); /* FIXME */
4024 }
4025 obj_som_version_hdr (abfd)->header_id.type = VERSION_AUX_ID;
4026 obj_som_version_hdr (abfd)->header_id.length = len + pad;
4027 obj_som_version_hdr (abfd)->header_id.length += sizeof (int);
4028 obj_som_version_hdr (abfd)->string_length = len;
4029 strncpy (obj_som_version_hdr (abfd)->user_string, string, len);
4030 }
4031 else if (type == COPYRIGHT_AUX_ID)
4032 {
4033 int len = strlen (string);
4034 int pad = 0;
4035
4036 if (len % 4)
4037 pad = (4 - (len % 4));
4038 obj_som_copyright_hdr (abfd) = (struct copyright_aux_hdr *)
4039 bfd_zalloc (abfd, sizeof (struct aux_id)
4040 + sizeof (unsigned int) + len + pad);
4041 if (!obj_som_copyright_hdr (abfd))
4042 {
4043 bfd_error = no_error;
4044 abort(); /* FIXME */
4045 }
4046 obj_som_copyright_hdr (abfd)->header_id.type = COPYRIGHT_AUX_ID;
4047 obj_som_copyright_hdr (abfd)->header_id.length = len + pad;
4048 obj_som_copyright_hdr (abfd)->header_id.length += sizeof (int);
4049 obj_som_copyright_hdr (abfd)->string_length = len;
4050 strcpy (obj_som_copyright_hdr (abfd)->copyright, string);
4051 }
4052 else
4053 abort ();
4054 }
4055
4056 static boolean
4057 som_set_section_contents (abfd, section, location, offset, count)
4058 bfd *abfd;
4059 sec_ptr section;
4060 PTR location;
4061 file_ptr offset;
4062 bfd_size_type count;
4063 {
4064 if (abfd->output_has_begun == false)
4065 {
4066 /* Set up fixed parts of the file, space, and subspace headers.
4067 Notify the world that output has begun. */
4068 som_prep_headers (abfd);
4069 abfd->output_has_begun = true;
4070 /* Start writing the object file. This include all the string
4071 tables, fixup streams, and other portions of the object file. */
4072 som_begin_writing (abfd);
4073 }
4074
4075 /* Only write subspaces which have "real" contents (eg. the contents
4076 are not generated at run time by the OS). */
4077 if (som_section_data (section)->is_subspace != 1
4078 || ((section->flags & (SEC_LOAD | SEC_DEBUGGING)) == 0))
4079 return true;
4080
4081 /* Seek to the proper offset within the object file and write the
4082 data. */
4083 offset += som_section_data (section)->subspace_dict.file_loc_init_value;
4084 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
4085 {
4086 bfd_error = system_call_error;
4087 return false;
4088 }
4089
4090 if (bfd_write ((PTR) location, 1, count, abfd) != count)
4091 {
4092 bfd_error = system_call_error;
4093 return false;
4094 }
4095 return true;
4096 }
4097
4098 static boolean
4099 som_set_arch_mach (abfd, arch, machine)
4100 bfd *abfd;
4101 enum bfd_architecture arch;
4102 unsigned long machine;
4103 {
4104 /* Allow any architecture to be supported by the SOM backend */
4105 return bfd_default_set_arch_mach (abfd, arch, machine);
4106 }
4107
4108 static boolean
4109 som_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
4110 functionname_ptr, line_ptr)
4111 bfd *abfd;
4112 asection *section;
4113 asymbol **symbols;
4114 bfd_vma offset;
4115 CONST char **filename_ptr;
4116 CONST char **functionname_ptr;
4117 unsigned int *line_ptr;
4118 {
4119 fprintf (stderr, "som_find_nearest_line unimplemented\n");
4120 fflush (stderr);
4121 abort ();
4122 return (false);
4123 }
4124
4125 static int
4126 som_sizeof_headers (abfd, reloc)
4127 bfd *abfd;
4128 boolean reloc;
4129 {
4130 fprintf (stderr, "som_sizeof_headers unimplemented\n");
4131 fflush (stderr);
4132 abort ();
4133 return (0);
4134 }
4135
4136 /* Return the single-character symbol type corresponding to
4137 SOM section S, or '?' for an unknown SOM section. */
4138
4139 static char
4140 som_section_type (s)
4141 const char *s;
4142 {
4143 const struct section_to_type *t;
4144
4145 for (t = &stt[0]; t->section; t++)
4146 if (!strcmp (s, t->section))
4147 return t->type;
4148 return '?';
4149 }
4150
4151 static int
4152 som_decode_symclass (symbol)
4153 asymbol *symbol;
4154 {
4155 char c;
4156
4157 if (bfd_is_com_section (symbol->section))
4158 return 'C';
4159 if (symbol->section == &bfd_und_section)
4160 return 'U';
4161 if (symbol->section == &bfd_ind_section)
4162 return 'I';
4163 if (!(symbol->flags & (BSF_GLOBAL|BSF_LOCAL)))
4164 return '?';
4165
4166 if (symbol->section == &bfd_abs_section)
4167 c = 'a';
4168 else if (symbol->section)
4169 c = som_section_type (symbol->section->name);
4170 else
4171 return '?';
4172 if (symbol->flags & BSF_GLOBAL)
4173 c = toupper (c);
4174 return c;
4175 }
4176
4177 /* Return information about SOM symbol SYMBOL in RET. */
4178
4179 static void
4180 som_get_symbol_info (ignore_abfd, symbol, ret)
4181 bfd *ignore_abfd;
4182 asymbol *symbol;
4183 symbol_info *ret;
4184 {
4185 ret->type = som_decode_symclass (symbol);
4186 if (ret->type != 'U')
4187 ret->value = symbol->value+symbol->section->vma;
4188 else
4189 ret->value = 0;
4190 ret->name = symbol->name;
4191 }
4192
4193 /* End of miscellaneous support functions. */
4194
4195 #define som_bfd_debug_info_start bfd_void
4196 #define som_bfd_debug_info_end bfd_void
4197 #define som_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
4198
4199 #define som_openr_next_archived_file bfd_generic_openr_next_archived_file
4200 #define som_generic_stat_arch_elt bfd_generic_stat_arch_elt
4201 #define som_slurp_armap bfd_false
4202 #define som_slurp_extended_name_table _bfd_slurp_extended_name_table
4203 #define som_truncate_arname (void (*)())bfd_nullvoidptr
4204 #define som_write_armap 0
4205
4206 #define som_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
4207 #define som_close_and_cleanup bfd_generic_close_and_cleanup
4208 #define som_get_section_contents bfd_generic_get_section_contents
4209
4210 #define som_bfd_get_relocated_section_contents \
4211 bfd_generic_get_relocated_section_contents
4212 #define som_bfd_relax_section bfd_generic_relax_section
4213 #define som_bfd_make_debug_symbol \
4214 ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
4215 #define som_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4216 #define som_bfd_link_add_symbols _bfd_generic_link_add_symbols
4217 #define som_bfd_final_link _bfd_generic_final_link
4218
4219 /* Core file support is in the hpux-core backend. */
4220 #define som_core_file_failing_command _bfd_dummy_core_file_failing_command
4221 #define som_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4222 #define som_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
4223
4224 bfd_target som_vec =
4225 {
4226 "som", /* name */
4227 bfd_target_som_flavour,
4228 true, /* target byte order */
4229 true, /* target headers byte order */
4230 (HAS_RELOC | EXEC_P | /* object flags */
4231 HAS_LINENO | HAS_DEBUG |
4232 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
4233 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
4234 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
4235
4236 /* leading_symbol_char: is the first char of a user symbol
4237 predictable, and if so what is it */
4238 0,
4239 ' ', /* ar_pad_char */
4240 16, /* ar_max_namelen */
4241 3, /* minimum alignment */
4242 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
4243 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
4244 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
4245 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
4246 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
4247 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
4248 {_bfd_dummy_target,
4249 som_object_p, /* bfd_check_format */
4250 bfd_generic_archive_p,
4251 _bfd_dummy_target
4252 },
4253 {
4254 bfd_false,
4255 som_mkobject,
4256 _bfd_generic_mkarchive,
4257 bfd_false
4258 },
4259 {
4260 bfd_false,
4261 som_write_object_contents,
4262 _bfd_write_archive_contents,
4263 bfd_false,
4264 },
4265 #undef som
4266 JUMP_TABLE (som),
4267 (PTR) 0
4268 };
4269
4270 #endif /* HOST_HPPAHPUX || HOST_HPPABSD || HOST_HPPAOSF */