1 /* BFD semi-generic back-end for a.out binaries.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
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 3 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., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
23
24 /*
25 SECTION
26 a.out backends
27
28 DESCRIPTION
29
30 BFD supports a number of different flavours of a.out format,
31 though the major differences are only the sizes of the
32 structures on disk, and the shape of the relocation
33 information.
34
35 The support is split into a basic support file @file{aoutx.h}
36 and other files which derive functions from the base. One
37 derivation file is @file{aoutf1.h} (for a.out flavour 1), and
38 adds to the basic a.out functions support for sun3, sun4, 386
39 and 29k a.out files, to create a target jump vector for a
40 specific target.
41
42 This information is further split out into more specific files
43 for each machine, including @file{sunos.c} for sun3 and sun4,
44 @file{newsos3.c} for the Sony NEWS, and @file{demo64.c} for a
45 demonstration of a 64 bit a.out format.
46
47 The base file @file{aoutx.h} defines general mechanisms for
48 reading and writing records to and from disk and various
49 other methods which BFD requires. It is included by
50 @file{aout32.c} and @file{aout64.c} to form the names
51 <<aout_32_swap_exec_header_in>>, <<aout_64_swap_exec_header_in>>, etc.
52
53 As an example, this is what goes on to make the back end for a
54 sun4, from @file{aout32.c}:
55
56 | #define ARCH_SIZE 32
57 | #include "aoutx.h"
58
59 Which exports names:
60
61 | ...
62 | aout_32_canonicalize_reloc
63 | aout_32_find_nearest_line
64 | aout_32_get_lineno
65 | aout_32_get_reloc_upper_bound
66 | ...
67
68 from @file{sunos.c}:
69
70 | #define TARGET_NAME "a.out-sunos-big"
71 | #define VECNAME sunos_big_vec
72 | #include "aoutf1.h"
73
74 requires all the names from @file{aout32.c}, and produces the jump vector
75
76 | sunos_big_vec
77
78 The file @file{host-aout.c} is a special case. It is for a large set
79 of hosts that use ``more or less standard'' a.out files, and
80 for which cross-debugging is not interesting. It uses the
81 standard 32-bit a.out support routines, but determines the
82 file offsets and addresses of the text, data, and BSS
83 sections, the machine architecture and machine type, and the
84 entry point address, in a host-dependent manner. Once these
85 values have been determined, generic code is used to handle
86 the object file.
87
88 When porting it to run on a new system, you must supply:
89
90 | HOST_PAGE_SIZE
91 | HOST_SEGMENT_SIZE
92 | HOST_MACHINE_ARCH (optional)
93 | HOST_MACHINE_MACHINE (optional)
94 | HOST_TEXT_START_ADDR
95 | HOST_STACK_END_ADDR
96
97 in the file @file{../include/sys/h-@var{XXX}.h} (for your host). These
98 values, plus the structures and macros defined in @file{a.out.h} on
99 your host system, will produce a BFD target that will access
100 ordinary a.out files on your host. To configure a new machine
101 to use @file{host-aout.c}, specify:
102
103 | TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
104 | TDEPFILES= host-aout.o trad-core.o
105
106 in the @file{config/@var{XXX}.mt} file, and modify @file{configure.in}
107 to use the
108 @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
109 configuration is selected. */
110
111 /* Some assumptions:
112 * Any BFD with D_PAGED set is ZMAGIC, and vice versa.
113 Doesn't matter what the setting of WP_TEXT is on output, but it'll
114 get set on input.
115 * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC.
116 * Any BFD with both flags clear is OMAGIC.
117 (Just want to make these explicit, so the conditions tested in this
118 file make sense if you're more familiar with a.out than with BFD.) */
119
120 #define KEEPIT udata.i
121
122 #include "sysdep.h"
123 #include "bfd.h"
124 #include "safe-ctype.h"
125 #include "bfdlink.h"
126
127 #include "libaout.h"
128 #include "libbfd.h"
129 #include "aout/aout64.h"
130 #include "aout/stab_gnu.h"
131 #include "aout/ar.h"
132
133 /*
134 SUBSECTION
135 Relocations
136
137 DESCRIPTION
138 The file @file{aoutx.h} provides for both the @emph{standard}
139 and @emph{extended} forms of a.out relocation records.
140
141 The standard records contain only an
142 address, a symbol index, and a type field. The extended records
143 (used on 29ks and sparcs) also have a full integer for an
144 addend. */
145
146 #ifndef CTOR_TABLE_RELOC_HOWTO
147 #define CTOR_TABLE_RELOC_IDX 2
148 #define CTOR_TABLE_RELOC_HOWTO(BFD) \
149 ((obj_reloc_entry_size (BFD) == RELOC_EXT_SIZE \
150 ? howto_table_ext : howto_table_std) \
151 + CTOR_TABLE_RELOC_IDX)
152 #endif
153
154 #ifndef MY_swap_std_reloc_in
155 #define MY_swap_std_reloc_in NAME (aout, swap_std_reloc_in)
156 #endif
157
158 #ifndef MY_swap_ext_reloc_in
159 #define MY_swap_ext_reloc_in NAME (aout, swap_ext_reloc_in)
160 #endif
161
162 #ifndef MY_swap_std_reloc_out
163 #define MY_swap_std_reloc_out NAME (aout, swap_std_reloc_out)
164 #endif
165
166 #ifndef MY_swap_ext_reloc_out
167 #define MY_swap_ext_reloc_out NAME (aout, swap_ext_reloc_out)
168 #endif
169
170 #ifndef MY_final_link_relocate
171 #define MY_final_link_relocate _bfd_final_link_relocate
172 #endif
173
174 #ifndef MY_relocate_contents
175 #define MY_relocate_contents _bfd_relocate_contents
176 #endif
177
178 #define howto_table_ext NAME (aout, ext_howto_table)
179 #define howto_table_std NAME (aout, std_howto_table)
180
181 reloc_howto_type howto_table_ext[] =
182 {
183 /* Type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
184 HOWTO (RELOC_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, 0, "8", FALSE, 0, 0x000000ff, FALSE),
185 HOWTO (RELOC_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 0, "16", FALSE, 0, 0x0000ffff, FALSE),
186 HOWTO (RELOC_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "32", FALSE, 0, 0xffffffff, FALSE),
187 HOWTO (RELOC_DISP8, 0, 0, 8, TRUE, 0, complain_overflow_signed, 0, "DISP8", FALSE, 0, 0x000000ff, FALSE),
188 HOWTO (RELOC_DISP16, 0, 1, 16, TRUE, 0, complain_overflow_signed, 0, "DISP16", FALSE, 0, 0x0000ffff, FALSE),
189 HOWTO (RELOC_DISP32, 0, 2, 32, TRUE, 0, complain_overflow_signed, 0, "DISP32", FALSE, 0, 0xffffffff, FALSE),
190 HOWTO (RELOC_WDISP30, 2, 2, 30, TRUE, 0, complain_overflow_signed, 0, "WDISP30", FALSE, 0, 0x3fffffff, FALSE),
191 HOWTO (RELOC_WDISP22, 2, 2, 22, TRUE, 0, complain_overflow_signed, 0, "WDISP22", FALSE, 0, 0x003fffff, FALSE),
192 HOWTO (RELOC_HI22, 10, 2, 22, FALSE, 0, complain_overflow_bitfield, 0, "HI22", FALSE, 0, 0x003fffff, FALSE),
193 HOWTO (RELOC_22, 0, 2, 22, FALSE, 0, complain_overflow_bitfield, 0, "22", FALSE, 0, 0x003fffff, FALSE),
194 HOWTO (RELOC_13, 0, 2, 13, FALSE, 0, complain_overflow_bitfield, 0, "13", FALSE, 0, 0x00001fff, FALSE),
195 HOWTO (RELOC_LO10, 0, 2, 10, FALSE, 0, complain_overflow_dont, 0, "LO10", FALSE, 0, 0x000003ff, FALSE),
196 HOWTO (RELOC_SFA_BASE,0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "SFA_BASE", FALSE, 0, 0xffffffff, FALSE),
197 HOWTO (RELOC_SFA_OFF13,0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "SFA_OFF13", FALSE, 0, 0xffffffff, FALSE),
198 HOWTO (RELOC_BASE10, 0, 2, 10, FALSE, 0, complain_overflow_dont, 0, "BASE10", FALSE, 0, 0x000003ff, FALSE),
199 HOWTO (RELOC_BASE13, 0, 2, 13, FALSE, 0, complain_overflow_signed, 0, "BASE13", FALSE, 0, 0x00001fff, FALSE),
200 HOWTO (RELOC_BASE22, 10, 2, 22, FALSE, 0, complain_overflow_bitfield, 0, "BASE22", FALSE, 0, 0x003fffff, FALSE),
201 HOWTO (RELOC_PC10, 0, 2, 10, TRUE, 0, complain_overflow_dont, 0, "PC10", FALSE, 0, 0x000003ff, TRUE),
202 HOWTO (RELOC_PC22, 10, 2, 22, TRUE, 0, complain_overflow_signed, 0, "PC22", FALSE, 0, 0x003fffff, TRUE),
203 HOWTO (RELOC_JMP_TBL, 2, 2, 30, TRUE, 0, complain_overflow_signed, 0, "JMP_TBL", FALSE, 0, 0x3fffffff, FALSE),
204 HOWTO (RELOC_SEGOFF16,0, 2, 0, FALSE, 0, complain_overflow_bitfield, 0, "SEGOFF16", FALSE, 0, 0x00000000, FALSE),
205 HOWTO (RELOC_GLOB_DAT,0, 2, 0, FALSE, 0, complain_overflow_bitfield, 0, "GLOB_DAT", FALSE, 0, 0x00000000, FALSE),
206 HOWTO (RELOC_JMP_SLOT,0, 2, 0, FALSE, 0, complain_overflow_bitfield, 0, "JMP_SLOT", FALSE, 0, 0x00000000, FALSE),
207 HOWTO (RELOC_RELATIVE,0, 2, 0, FALSE, 0, complain_overflow_bitfield, 0, "RELATIVE", FALSE, 0, 0x00000000, FALSE),
208 HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, 0, "R_SPARC_NONE",FALSE, 0, 0x00000000, TRUE),
209 HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, 0, "R_SPARC_NONE",FALSE, 0, 0x00000000, TRUE),
210 #define RELOC_SPARC_REV32 RELOC_WDISP19
211 HOWTO (RELOC_SPARC_REV32, 0, 2, 32, FALSE, 0, complain_overflow_dont, 0,"R_SPARC_REV32",FALSE, 0, 0xffffffff, FALSE),
212 };
213
214 /* Convert standard reloc records to "arelent" format (incl byte swap). */
215
216 reloc_howto_type howto_table_std[] =
217 {
218 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
219 HOWTO ( 0, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,0,"8", TRUE, 0x000000ff,0x000000ff, FALSE),
220 HOWTO ( 1, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,0,"16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
221 HOWTO ( 2, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"32", TRUE, 0xffffffff,0xffffffff, FALSE),
222 HOWTO ( 3, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,0,"64", TRUE, 0xdeaddead,0xdeaddead, FALSE),
223 HOWTO ( 4, 0, 0, 8, TRUE, 0, complain_overflow_signed, 0,"DISP8", TRUE, 0x000000ff,0x000000ff, FALSE),
224 HOWTO ( 5, 0, 1, 16, TRUE, 0, complain_overflow_signed, 0,"DISP16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
225 HOWTO ( 6, 0, 2, 32, TRUE, 0, complain_overflow_signed, 0,"DISP32", TRUE, 0xffffffff,0xffffffff, FALSE),
226 HOWTO ( 7, 0, 4, 64, TRUE, 0, complain_overflow_signed, 0,"DISP64", TRUE, 0xfeedface,0xfeedface, FALSE),
227 HOWTO ( 8, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"GOT_REL", FALSE, 0,0x00000000, FALSE),
228 HOWTO ( 9, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,0,"BASE16", FALSE,0xffffffff,0xffffffff, FALSE),
229 HOWTO (10, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"BASE32", FALSE,0xffffffff,0xffffffff, FALSE),
230 EMPTY_HOWTO (-1),
231 EMPTY_HOWTO (-1),
232 EMPTY_HOWTO (-1),
233 EMPTY_HOWTO (-1),
234 EMPTY_HOWTO (-1),
235 HOWTO (16, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"JMP_TABLE", FALSE, 0,0x00000000, FALSE),
236 EMPTY_HOWTO (-1),
237 EMPTY_HOWTO (-1),
238 EMPTY_HOWTO (-1),
239 EMPTY_HOWTO (-1),
240 EMPTY_HOWTO (-1),
241 EMPTY_HOWTO (-1),
242 EMPTY_HOWTO (-1),
243 EMPTY_HOWTO (-1),
244 EMPTY_HOWTO (-1),
245 EMPTY_HOWTO (-1),
246 EMPTY_HOWTO (-1),
247 EMPTY_HOWTO (-1),
248 EMPTY_HOWTO (-1),
249 EMPTY_HOWTO (-1),
250 EMPTY_HOWTO (-1),
251 HOWTO (32, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"RELATIVE", FALSE, 0,0x00000000, FALSE),
252 EMPTY_HOWTO (-1),
253 EMPTY_HOWTO (-1),
254 EMPTY_HOWTO (-1),
255 EMPTY_HOWTO (-1),
256 EMPTY_HOWTO (-1),
257 EMPTY_HOWTO (-1),
258 EMPTY_HOWTO (-1),
259 HOWTO (40, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"BASEREL", FALSE, 0,0x00000000, FALSE),
260 };
261
262 #define TABLE_SIZE(TABLE) (sizeof (TABLE) / sizeof (TABLE[0]))
263
264 reloc_howto_type *
NAME(aout,reloc_type_lookup)265 NAME (aout, reloc_type_lookup) (bfd *abfd, bfd_reloc_code_real_type code)
266 {
267 #define EXT(i, j) case i: return & howto_table_ext [j]
268 #define STD(i, j) case i: return & howto_table_std [j]
269 int ext = obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE;
270
271 if (code == BFD_RELOC_CTOR)
272 switch (bfd_arch_bits_per_address (abfd))
273 {
274 case 32:
275 code = BFD_RELOC_32;
276 break;
277 case 64:
278 code = BFD_RELOC_64;
279 break;
280 }
281
282 if (ext)
283 switch (code)
284 {
285 EXT (BFD_RELOC_8, 0);
286 EXT (BFD_RELOC_16, 1);
287 EXT (BFD_RELOC_32, 2);
288 EXT (BFD_RELOC_HI22, 8);
289 EXT (BFD_RELOC_LO10, 11);
290 EXT (BFD_RELOC_32_PCREL_S2, 6);
291 EXT (BFD_RELOC_SPARC_WDISP22, 7);
292 EXT (BFD_RELOC_SPARC13, 10);
293 EXT (BFD_RELOC_SPARC_GOT10, 14);
294 EXT (BFD_RELOC_SPARC_BASE13, 15);
295 EXT (BFD_RELOC_SPARC_GOT13, 15);
296 EXT (BFD_RELOC_SPARC_GOT22, 16);
297 EXT (BFD_RELOC_SPARC_PC10, 17);
298 EXT (BFD_RELOC_SPARC_PC22, 18);
299 EXT (BFD_RELOC_SPARC_WPLT30, 19);
300 EXT (BFD_RELOC_SPARC_REV32, 26);
301 default:
302 return NULL;
303 }
304 else
305 /* std relocs. */
306 switch (code)
307 {
308 STD (BFD_RELOC_8, 0);
309 STD (BFD_RELOC_16, 1);
310 STD (BFD_RELOC_32, 2);
311 STD (BFD_RELOC_8_PCREL, 4);
312 STD (BFD_RELOC_16_PCREL, 5);
313 STD (BFD_RELOC_32_PCREL, 6);
314 STD (BFD_RELOC_16_BASEREL, 9);
315 STD (BFD_RELOC_32_BASEREL, 10);
316 default:
317 return NULL;
318 }
319 }
320
321 reloc_howto_type *
NAME(aout,reloc_name_lookup)322 NAME (aout, reloc_name_lookup) (bfd *abfd, const char *r_name)
323 {
324 unsigned int i, size;
325 reloc_howto_type *howto_table;
326
327 if (obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE)
328 {
329 howto_table = howto_table_ext;
330 size = sizeof (howto_table_ext) / sizeof (howto_table_ext[0]);
331 }
332 else
333 {
334 howto_table = howto_table_std;
335 size = sizeof (howto_table_std) / sizeof (howto_table_std[0]);
336 }
337
338 for (i = 0; i < size; i++)
339 if (howto_table[i].name != NULL
340 && strcasecmp (howto_table[i].name, r_name) == 0)
341 return &howto_table[i];
342
343 return NULL;
344 }
345
346 /*
347 SUBSECTION
348 Internal entry points
349
350 DESCRIPTION
351 @file{aoutx.h} exports several routines for accessing the
352 contents of an a.out file, which are gathered and exported in
353 turn by various format specific files (eg sunos.c).
354 */
355
356 /*
357 FUNCTION
358 aout_@var{size}_swap_exec_header_in
359
360 SYNOPSIS
361 void aout_@var{size}_swap_exec_header_in,
362 (bfd *abfd,
363 struct external_exec *bytes,
364 struct internal_exec *execp);
365
366 DESCRIPTION
367 Swap the information in an executable header @var{raw_bytes} taken
368 from a raw byte stream memory image into the internal exec header
369 structure @var{execp}.
370 */
371
372 #ifndef NAME_swap_exec_header_in
373 void
NAME(aout,swap_exec_header_in)374 NAME (aout, swap_exec_header_in) (bfd *abfd,
375 struct external_exec *bytes,
376 struct internal_exec *execp)
377 {
378 /* The internal_exec structure has some fields that are unused in this
379 configuration (IE for i960), so ensure that all such uninitialized
380 fields are zero'd out. There are places where two of these structs
381 are memcmp'd, and thus the contents do matter. */
382 memset ((void *) execp, 0, sizeof (struct internal_exec));
383 /* Now fill in fields in the execp, from the bytes in the raw data. */
384 execp->a_info = H_GET_32 (abfd, bytes->e_info);
385 execp->a_text = GET_WORD (abfd, bytes->e_text);
386 execp->a_data = GET_WORD (abfd, bytes->e_data);
387 execp->a_bss = GET_WORD (abfd, bytes->e_bss);
388 execp->a_syms = GET_WORD (abfd, bytes->e_syms);
389 execp->a_entry = GET_WORD (abfd, bytes->e_entry);
390 execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
391 execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
392 }
393 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
394 #endif
395
396 /*
397 FUNCTION
398 aout_@var{size}_swap_exec_header_out
399
400 SYNOPSIS
401 void aout_@var{size}_swap_exec_header_out
402 (bfd *abfd,
403 struct internal_exec *execp,
404 struct external_exec *raw_bytes);
405
406 DESCRIPTION
407 Swap the information in an internal exec header structure
408 @var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
409 */
410 void
NAME(aout,swap_exec_header_out)411 NAME (aout, swap_exec_header_out) (bfd *abfd,
412 struct internal_exec *execp,
413 struct external_exec *bytes)
414 {
415 /* Now fill in fields in the raw data, from the fields in the exec struct. */
416 H_PUT_32 (abfd, execp->a_info , bytes->e_info);
417 PUT_WORD (abfd, execp->a_text , bytes->e_text);
418 PUT_WORD (abfd, execp->a_data , bytes->e_data);
419 PUT_WORD (abfd, execp->a_bss , bytes->e_bss);
420 PUT_WORD (abfd, execp->a_syms , bytes->e_syms);
421 PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
422 PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
423 PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
424 }
425
426 /* Make all the section for an a.out file. */
427
428 bfd_boolean
NAME(aout,make_sections)429 NAME (aout, make_sections) (bfd *abfd)
430 {
431 if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL)
432 return FALSE;
433 if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL)
434 return FALSE;
435 if (obj_bsssec (abfd) == NULL && bfd_make_section (abfd, ".bss") == NULL)
436 return FALSE;
437 return TRUE;
438 }
439
440 /*
441 FUNCTION
442 aout_@var{size}_some_aout_object_p
443
444 SYNOPSIS
445 const bfd_target *aout_@var{size}_some_aout_object_p
446 (bfd *abfd,
447 struct internal_exec *execp,
448 const bfd_target *(*callback_to_real_object_p) (bfd *));
449
450 DESCRIPTION
451 Some a.out variant thinks that the file open in @var{abfd}
452 checking is an a.out file. Do some more checking, and set up
453 for access if it really is. Call back to the calling
454 environment's "finish up" function just before returning, to
455 handle any last-minute setup.
456 */
457
458 const bfd_target *
NAME(aout,some_aout_object_p)459 NAME (aout, some_aout_object_p) (bfd *abfd,
460 struct internal_exec *execp,
461 const bfd_target *(*callback_to_real_object_p) (bfd *))
462 {
463 struct aout_data_struct *rawptr, *oldrawptr;
464 const bfd_target *result;
465 bfd_size_type amt = sizeof (* rawptr);
466
467 rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
468 if (rawptr == NULL)
469 return NULL;
470
471 oldrawptr = abfd->tdata.aout_data;
472 abfd->tdata.aout_data = rawptr;
473
474 /* Copy the contents of the old tdata struct.
475 In particular, we want the subformat, since for hpux it was set in
476 hp300hpux.c:swap_exec_header_in and will be used in
477 hp300hpux.c:callback. */
478 if (oldrawptr != NULL)
479 *abfd->tdata.aout_data = *oldrawptr;
480
481 abfd->tdata.aout_data->a.hdr = &rawptr->e;
482 /* Copy in the internal_exec struct. */
483 *(abfd->tdata.aout_data->a.hdr) = *execp;
484 execp = abfd->tdata.aout_data->a.hdr;
485
486 /* Set the file flags. */
487 abfd->flags = BFD_NO_FLAGS;
488 if (execp->a_drsize || execp->a_trsize)
489 abfd->flags |= HAS_RELOC;
490 /* Setting of EXEC_P has been deferred to the bottom of this function. */
491 if (execp->a_syms)
492 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
493 if (N_DYNAMIC (*execp))
494 abfd->flags |= DYNAMIC;
495
496 if (N_MAGIC (*execp) == ZMAGIC)
497 {
498 abfd->flags |= D_PAGED | WP_TEXT;
499 adata (abfd).magic = z_magic;
500 }
501 else if (N_MAGIC (*execp) == QMAGIC)
502 {
503 abfd->flags |= D_PAGED | WP_TEXT;
504 adata (abfd).magic = z_magic;
505 adata (abfd).subformat = q_magic_format;
506 }
507 else if (N_MAGIC (*execp) == NMAGIC)
508 {
509 abfd->flags |= WP_TEXT;
510 adata (abfd).magic = n_magic;
511 }
512 else if (N_MAGIC (*execp) == OMAGIC
513 || N_MAGIC (*execp) == BMAGIC)
514 adata (abfd).magic = o_magic;
515 else
516 /* Should have been checked with N_BADMAG before this routine
517 was called. */
518 abort ();
519
520 bfd_get_start_address (abfd) = execp->a_entry;
521
522 obj_aout_symbols (abfd) = NULL;
523 bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
524
525 /* The default relocation entry size is that of traditional V7 Unix. */
526 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
527
528 /* The default symbol entry size is that of traditional Unix. */
529 obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
530
531 #ifdef USE_MMAP
532 bfd_init_window (&obj_aout_sym_window (abfd));
533 bfd_init_window (&obj_aout_string_window (abfd));
534 #endif
535 obj_aout_external_syms (abfd) = NULL;
536 obj_aout_external_strings (abfd) = NULL;
537 obj_aout_sym_hashes (abfd) = NULL;
538
539 if (! NAME (aout, make_sections) (abfd))
540 goto error_ret;
541
542 obj_datasec (abfd)->size = execp->a_data;
543 obj_bsssec (abfd)->size = execp->a_bss;
544
545 obj_textsec (abfd)->flags =
546 (execp->a_trsize != 0
547 ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
548 : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
549 obj_datasec (abfd)->flags =
550 (execp->a_drsize != 0
551 ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
552 : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
553 obj_bsssec (abfd)->flags = SEC_ALLOC;
554
555 #ifdef THIS_IS_ONLY_DOCUMENTATION
556 /* The common code can't fill in these things because they depend
557 on either the start address of the text segment, the rounding
558 up of virtual addresses between segments, or the starting file
559 position of the text segment -- all of which varies among different
560 versions of a.out. */
561
562 /* Call back to the format-dependent code to fill in the rest of the
563 fields and do any further cleanup. Things that should be filled
564 in by the callback: */
565
566 struct exec *execp = exec_hdr (abfd);
567
568 obj_textsec (abfd)->size = N_TXTSIZE (*execp);
569 /* Data and bss are already filled in since they're so standard. */
570
571 /* The virtual memory addresses of the sections. */
572 obj_textsec (abfd)->vma = N_TXTADDR (*execp);
573 obj_datasec (abfd)->vma = N_DATADDR (*execp);
574 obj_bsssec (abfd)->vma = N_BSSADDR (*execp);
575
576 /* The file offsets of the sections. */
577 obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
578 obj_datasec (abfd)->filepos = N_DATOFF (*execp);
579
580 /* The file offsets of the relocation info. */
581 obj_textsec (abfd)->rel_filepos = N_TRELOFF (*execp);
582 obj_datasec (abfd)->rel_filepos = N_DRELOFF (*execp);
583
584 /* The file offsets of the string table and symbol table. */
585 obj_str_filepos (abfd) = N_STROFF (*execp);
586 obj_sym_filepos (abfd) = N_SYMOFF (*execp);
587
588 /* Determine the architecture and machine type of the object file. */
589 switch (N_MACHTYPE (*exec_hdr (abfd)))
590 {
591 default:
592 abfd->obj_arch = bfd_arch_obscure;
593 break;
594 }
595
596 adata (abfd)->page_size = TARGET_PAGE_SIZE;
597 adata (abfd)->segment_size = SEGMENT_SIZE;
598 adata (abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
599
600 return abfd->xvec;
601
602 /* The architecture is encoded in various ways in various a.out variants,
603 or is not encoded at all in some of them. The relocation size depends
604 on the architecture and the a.out variant. Finally, the return value
605 is the bfd_target vector in use. If an error occurs, return zero and
606 set bfd_error to the appropriate error code.
607
608 Formats such as b.out, which have additional fields in the a.out
609 header, should cope with them in this callback as well. */
610 #endif /* DOCUMENTATION */
611
612 result = (*callback_to_real_object_p) (abfd);
613
614 /* Now that the segment addresses have been worked out, take a better
615 guess at whether the file is executable. If the entry point
616 is within the text segment, assume it is. (This makes files
617 executable even if their entry point address is 0, as long as
618 their text starts at zero.).
619
620 This test had to be changed to deal with systems where the text segment
621 runs at a different location than the default. The problem is that the
622 entry address can appear to be outside the text segment, thus causing an
623 erroneous conclusion that the file isn't executable.
624
625 To fix this, we now accept any non-zero entry point as an indication of
626 executability. This will work most of the time, since only the linker
627 sets the entry point, and that is likely to be non-zero for most systems. */
628
629 if (execp->a_entry != 0
630 || (execp->a_entry >= obj_textsec (abfd)->vma
631 && execp->a_entry < (obj_textsec (abfd)->vma
632 + obj_textsec (abfd)->size)
633 && execp->a_trsize == 0
634 && execp->a_drsize == 0))
635 abfd->flags |= EXEC_P;
636 #ifdef STAT_FOR_EXEC
637 else
638 {
639 struct stat stat_buf;
640
641 /* The original heuristic doesn't work in some important cases.
642 The a.out file has no information about the text start
643 address. For files (like kernels) linked to non-standard
644 addresses (ld -Ttext nnn) the entry point may not be between
645 the default text start (obj_textsec(abfd)->vma) and
646 (obj_textsec(abfd)->vma) + text size. This is not just a mach
647 issue. Many kernels are loaded at non standard addresses. */
648 if (abfd->iostream != NULL
649 && (abfd->flags & BFD_IN_MEMORY) == 0
650 && (fstat (fileno ((FILE *) (abfd->iostream)), &stat_buf) == 0)
651 && ((stat_buf.st_mode & 0111) != 0))
652 abfd->flags |= EXEC_P;
653 }
654 #endif /* STAT_FOR_EXEC */
655
656 if (result)
657 return result;
658
659 error_ret:
660 bfd_release (abfd, rawptr);
661 abfd->tdata.aout_data = oldrawptr;
662 return NULL;
663 }
664
665 /*
666 FUNCTION
667 aout_@var{size}_mkobject
668
669 SYNOPSIS
670 bfd_boolean aout_@var{size}_mkobject, (bfd *abfd);
671
672 DESCRIPTION
673 Initialize BFD @var{abfd} for use with a.out files.
674 */
675
676 bfd_boolean
NAME(aout,mkobject)677 NAME (aout, mkobject) (bfd *abfd)
678 {
679 struct aout_data_struct *rawptr;
680 bfd_size_type amt = sizeof (* rawptr);
681
682 bfd_set_error (bfd_error_system_call);
683
684 rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
685 if (rawptr == NULL)
686 return FALSE;
687
688 abfd->tdata.aout_data = rawptr;
689 exec_hdr (abfd) = &(rawptr->e);
690
691 obj_textsec (abfd) = NULL;
692 obj_datasec (abfd) = NULL;
693 obj_bsssec (abfd) = NULL;
694
695 return TRUE;
696 }
697
698 /*
699 FUNCTION
700 aout_@var{size}_machine_type
701
702 SYNOPSIS
703 enum machine_type aout_@var{size}_machine_type
704 (enum bfd_architecture arch,
705 unsigned long machine,
706 bfd_boolean *unknown);
707
708 DESCRIPTION
709 Keep track of machine architecture and machine type for
710 a.out's. Return the <<machine_type>> for a particular
711 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
712 and machine can't be represented in a.out format.
713
714 If the architecture is understood, machine type 0 (default)
715 is always understood.
716 */
717
718 enum machine_type
NAME(aout,machine_type)719 NAME (aout, machine_type) (enum bfd_architecture arch,
720 unsigned long machine,
721 bfd_boolean *unknown)
722 {
723 enum machine_type arch_flags;
724
725 arch_flags = M_UNKNOWN;
726 *unknown = TRUE;
727
728 switch (arch)
729 {
730 case bfd_arch_sparc:
731 if (machine == 0
732 || machine == bfd_mach_sparc
733 || machine == bfd_mach_sparc_sparclite
734 || machine == bfd_mach_sparc_sparclite_le
735 || machine == bfd_mach_sparc_v8plus
736 || machine == bfd_mach_sparc_v8plusa
737 || machine == bfd_mach_sparc_v8plusb
738 || machine == bfd_mach_sparc_v9
739 || machine == bfd_mach_sparc_v9a
740 || machine == bfd_mach_sparc_v9b)
741 arch_flags = M_SPARC;
742 else if (machine == bfd_mach_sparc_sparclet)
743 arch_flags = M_SPARCLET;
744 break;
745
746 case bfd_arch_m68k:
747 switch (machine)
748 {
749 case 0: arch_flags = M_68010; break;
750 case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = FALSE; break;
751 case bfd_mach_m68010: arch_flags = M_68010; break;
752 case bfd_mach_m68020: arch_flags = M_68020; break;
753 default: arch_flags = M_UNKNOWN; break;
754 }
755 break;
756
757 case bfd_arch_i386:
758 if (machine == 0
759 || machine == bfd_mach_i386_i386
760 || machine == bfd_mach_i386_i386_intel_syntax)
761 arch_flags = M_386;
762 break;
763
764 case bfd_arch_arm:
765 if (machine == 0)
766 arch_flags = M_ARM;
767 break;
768
769 case bfd_arch_mips:
770 switch (machine)
771 {
772 case 0:
773 case bfd_mach_mips3000:
774 case bfd_mach_mips3900:
775 arch_flags = M_MIPS1;
776 break;
777 case bfd_mach_mips6000:
778 arch_flags = M_MIPS2;
779 break;
780 case bfd_mach_mips4000:
781 case bfd_mach_mips4010:
782 case bfd_mach_mips4100:
783 case bfd_mach_mips4300:
784 case bfd_mach_mips4400:
785 case bfd_mach_mips4600:
786 case bfd_mach_mips4650:
787 case bfd_mach_mips8000:
788 case bfd_mach_mips9000:
789 case bfd_mach_mips10000:
790 case bfd_mach_mips12000:
791 case bfd_mach_mips14000:
792 case bfd_mach_mips16000:
793 case bfd_mach_mips16:
794 case bfd_mach_mipsisa32:
795 case bfd_mach_mipsisa32r2:
796 case bfd_mach_mips5:
797 case bfd_mach_mipsisa64:
798 case bfd_mach_mipsisa64r2:
799 case bfd_mach_mips_sb1:
800 case bfd_mach_mips_xlr:
801 /* FIXME: These should be MIPS3, MIPS4, MIPS16, MIPS32, etc. */
802 arch_flags = M_MIPS2;
803 break;
804 default:
805 arch_flags = M_UNKNOWN;
806 break;
807 }
808 break;
809
810 case bfd_arch_ns32k:
811 switch (machine)
812 {
813 case 0: arch_flags = M_NS32532; break;
814 case 32032: arch_flags = M_NS32032; break;
815 case 32532: arch_flags = M_NS32532; break;
816 default: arch_flags = M_UNKNOWN; break;
817 }
818 break;
819
820 case bfd_arch_vax:
821 *unknown = FALSE;
822 break;
823
824 case bfd_arch_cris:
825 if (machine == 0 || machine == 255)
826 arch_flags = M_CRIS;
827 break;
828
829 case bfd_arch_m88k:
830 *unknown = FALSE;
831 break;
832
833 default:
834 arch_flags = M_UNKNOWN;
835 }
836
837 if (arch_flags != M_UNKNOWN)
838 *unknown = FALSE;
839
840 return arch_flags;
841 }
842
843 /*
844 FUNCTION
845 aout_@var{size}_set_arch_mach
846
847 SYNOPSIS
848 bfd_boolean aout_@var{size}_set_arch_mach,
849 (bfd *,
850 enum bfd_architecture arch,
851 unsigned long machine);
852
853 DESCRIPTION
854 Set the architecture and the machine of the BFD @var{abfd} to the
855 values @var{arch} and @var{machine}. Verify that @var{abfd}'s format
856 can support the architecture required.
857 */
858
859 bfd_boolean
NAME(aout,set_arch_mach)860 NAME (aout, set_arch_mach) (bfd *abfd,
861 enum bfd_architecture arch,
862 unsigned long machine)
863 {
864 if (! bfd_default_set_arch_mach (abfd, arch, machine))
865 return FALSE;
866
867 if (arch != bfd_arch_unknown)
868 {
869 bfd_boolean unknown;
870
871 NAME (aout, machine_type) (arch, machine, &unknown);
872 if (unknown)
873 return FALSE;
874 }
875
876 /* Determine the size of a relocation entry. */
877 switch (arch)
878 {
879 case bfd_arch_sparc:
880 case bfd_arch_mips:
881 obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE;
882 break;
883 default:
884 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
885 break;
886 }
887
888 return (*aout_backend_info (abfd)->set_sizes) (abfd);
889 }
890
891 static void
adjust_o_magic(bfd * abfd,struct internal_exec * execp)892 adjust_o_magic (bfd *abfd, struct internal_exec *execp)
893 {
894 file_ptr pos = adata (abfd).exec_bytes_size;
895 bfd_vma vma = 0;
896 int pad = 0;
897
898 /* Text. */
899 obj_textsec (abfd)->filepos = pos;
900 if (!obj_textsec (abfd)->user_set_vma)
901 obj_textsec (abfd)->vma = vma;
902 else
903 vma = obj_textsec (abfd)->vma;
904
905 pos += obj_textsec (abfd)->size;
906 vma += obj_textsec (abfd)->size;
907
908 /* Data. */
909 if (!obj_datasec (abfd)->user_set_vma)
910 {
911 obj_textsec (abfd)->size += pad;
912 pos += pad;
913 vma += pad;
914 obj_datasec (abfd)->vma = vma;
915 }
916 else
917 vma = obj_datasec (abfd)->vma;
918 obj_datasec (abfd)->filepos = pos;
919 pos += obj_datasec (abfd)->size;
920 vma += obj_datasec (abfd)->size;
921
922 /* BSS. */
923 if (!obj_bsssec (abfd)->user_set_vma)
924 {
925 obj_datasec (abfd)->size += pad;
926 pos += pad;
927 vma += pad;
928 obj_bsssec (abfd)->vma = vma;
929 }
930 else
931 {
932 /* The VMA of the .bss section is set by the VMA of the
933 .data section plus the size of the .data section. We may
934 need to add padding bytes to make this true. */
935 pad = obj_bsssec (abfd)->vma - vma;
936 if (pad > 0)
937 {
938 obj_datasec (abfd)->size += pad;
939 pos += pad;
940 }
941 }
942 obj_bsssec (abfd)->filepos = pos;
943
944 /* Fix up the exec header. */
945 execp->a_text = obj_textsec (abfd)->size;
946 execp->a_data = obj_datasec (abfd)->size;
947 execp->a_bss = obj_bsssec (abfd)->size;
948 N_SET_MAGIC (*execp, OMAGIC);
949 }
950
951 static void
adjust_z_magic(bfd * abfd,struct internal_exec * execp)952 adjust_z_magic (bfd *abfd, struct internal_exec *execp)
953 {
954 bfd_size_type data_pad, text_pad;
955 file_ptr text_end;
956 const struct aout_backend_data *abdp;
957 /* TRUE if text includes exec header. */
958 bfd_boolean ztih;
959
960 abdp = aout_backend_info (abfd);
961
962 /* Text. */
963 ztih = (abdp != NULL
964 && (abdp->text_includes_header
965 || obj_aout_subformat (abfd) == q_magic_format));
966 obj_textsec (abfd)->filepos = (ztih
967 ? adata (abfd).exec_bytes_size
968 : adata (abfd).zmagic_disk_block_size);
969 if (! obj_textsec (abfd)->user_set_vma)
970 {
971 /* ?? Do we really need to check for relocs here? */
972 obj_textsec (abfd)->vma = ((abfd->flags & HAS_RELOC)
973 ? 0
974 : (ztih
975 ? (abdp->default_text_vma
976 + adata (abfd).exec_bytes_size)
977 : abdp->default_text_vma));
978 text_pad = 0;
979 }
980 else
981 {
982 /* The .text section is being loaded at an unusual address. We
983 may need to pad it such that the .data section starts at a page
984 boundary. */
985 if (ztih)
986 text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
987 & (adata (abfd).page_size - 1));
988 else
989 text_pad = ((- obj_textsec (abfd)->vma)
990 & (adata (abfd).page_size - 1));
991 }
992
993 /* Find start of data. */
994 if (ztih)
995 {
996 text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size;
997 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
998 }
999 else
1000 {
1001 /* Note that if page_size == zmagic_disk_block_size, then
1002 filepos == page_size, and this case is the same as the ztih
1003 case. */
1004 text_end = obj_textsec (abfd)->size;
1005 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
1006 text_end += obj_textsec (abfd)->filepos;
1007 }
1008 obj_textsec (abfd)->size += text_pad;
1009 text_end += text_pad;
1010
1011 /* Data. */
1012 if (!obj_datasec (abfd)->user_set_vma)
1013 {
1014 bfd_vma vma;
1015 vma = obj_textsec (abfd)->vma + obj_textsec (abfd)->size;
1016 obj_datasec (abfd)->vma = BFD_ALIGN (vma, adata (abfd).segment_size);
1017 }
1018 if (abdp && abdp->zmagic_mapped_contiguous)
1019 {
1020 asection * text = obj_textsec (abfd);
1021 asection * data = obj_datasec (abfd);
1022
1023 text_pad = data->vma - (text->vma + text->size);
1024 /* Only pad the text section if the data
1025 section is going to be placed after it. */
1026 if (text_pad > 0)
1027 text->size += text_pad;
1028 }
1029 obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
1030 + obj_textsec (abfd)->size);
1031
1032 /* Fix up exec header while we're at it. */
1033 execp->a_text = obj_textsec (abfd)->size;
1034 if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
1035 execp->a_text += adata (abfd).exec_bytes_size;
1036 if (obj_aout_subformat (abfd) == q_magic_format)
1037 N_SET_MAGIC (*execp, QMAGIC);
1038 else
1039 N_SET_MAGIC (*execp, ZMAGIC);
1040
1041 /* Spec says data section should be rounded up to page boundary. */
1042 obj_datasec (abfd)->size
1043 = align_power (obj_datasec (abfd)->size,
1044 obj_bsssec (abfd)->alignment_power);
1045 execp->a_data = BFD_ALIGN (obj_datasec (abfd)->size,
1046 adata (abfd).page_size);
1047 data_pad = execp->a_data - obj_datasec (abfd)->size;
1048
1049 /* BSS. */
1050 if (!obj_bsssec (abfd)->user_set_vma)
1051 obj_bsssec (abfd)->vma = (obj_datasec (abfd)->vma
1052 + obj_datasec (abfd)->size);
1053 /* If the BSS immediately follows the data section and extra space
1054 in the page is left after the data section, fudge data
1055 in the header so that the bss section looks smaller by that
1056 amount. We'll start the bss section there, and lie to the OS.
1057 (Note that a linker script, as well as the above assignment,
1058 could have explicitly set the BSS vma to immediately follow
1059 the data section.) */
1060 if (align_power (obj_bsssec (abfd)->vma, obj_bsssec (abfd)->alignment_power)
1061 == obj_datasec (abfd)->vma + obj_datasec (abfd)->size)
1062 execp->a_bss = (data_pad > obj_bsssec (abfd)->size
1063 ? 0 : obj_bsssec (abfd)->size - data_pad);
1064 else
1065 execp->a_bss = obj_bsssec (abfd)->size;
1066 }
1067
1068 static void
adjust_n_magic(bfd * abfd,struct internal_exec * execp)1069 adjust_n_magic (bfd *abfd, struct internal_exec *execp)
1070 {
1071 file_ptr pos = adata (abfd).exec_bytes_size;
1072 bfd_vma vma = 0;
1073 int pad;
1074
1075 /* Text. */
1076 obj_textsec (abfd)->filepos = pos;
1077 if (!obj_textsec (abfd)->user_set_vma)
1078 obj_textsec (abfd)->vma = vma;
1079 else
1080 vma = obj_textsec (abfd)->vma;
1081 pos += obj_textsec (abfd)->size;
1082 vma += obj_textsec (abfd)->size;
1083
1084 /* Data. */
1085 obj_datasec (abfd)->filepos = pos;
1086 if (!obj_datasec (abfd)->user_set_vma)
1087 obj_datasec (abfd)->vma = BFD_ALIGN (vma, adata (abfd).segment_size);
1088 vma = obj_datasec (abfd)->vma;
1089
1090 /* Since BSS follows data immediately, see if it needs alignment. */
1091 vma += obj_datasec (abfd)->size;
1092 pad = align_power (vma, obj_bsssec (abfd)->alignment_power) - vma;
1093 obj_datasec (abfd)->size += pad;
1094 pos += obj_datasec (abfd)->size;
1095
1096 /* BSS. */
1097 if (!obj_bsssec (abfd)->user_set_vma)
1098 obj_bsssec (abfd)->vma = vma;
1099 else
1100 vma = obj_bsssec (abfd)->vma;
1101
1102 /* Fix up exec header. */
1103 execp->a_text = obj_textsec (abfd)->size;
1104 execp->a_data = obj_datasec (abfd)->size;
1105 execp->a_bss = obj_bsssec (abfd)->size;
1106 N_SET_MAGIC (*execp, NMAGIC);
1107 }
1108
1109 bfd_boolean
NAME(aout,adjust_sizes_and_vmas)1110 NAME (aout, adjust_sizes_and_vmas) (bfd *abfd,
1111 bfd_size_type *text_size,
1112 file_ptr *text_end ATTRIBUTE_UNUSED)
1113 {
1114 struct internal_exec *execp = exec_hdr (abfd);
1115
1116 if (! NAME (aout, make_sections) (abfd))
1117 return FALSE;
1118
1119 if (adata (abfd).magic != undecided_magic)
1120 return TRUE;
1121
1122 obj_textsec (abfd)->size =
1123 align_power (obj_textsec (abfd)->size,
1124 obj_textsec (abfd)->alignment_power);
1125
1126 *text_size = obj_textsec (abfd)->size;
1127 /* Rule (heuristic) for when to pad to a new page. Note that there
1128 are (at least) two ways demand-paged (ZMAGIC) files have been
1129 handled. Most Berkeley-based systems start the text segment at
1130 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1131 segment right after the exec header; the latter is counted in the
1132 text segment size, and is paged in by the kernel with the rest of
1133 the text. */
1134
1135 /* This perhaps isn't the right way to do this, but made it simpler for me
1136 to understand enough to implement it. Better would probably be to go
1137 right from BFD flags to alignment/positioning characteristics. But the
1138 old code was sloppy enough about handling the flags, and had enough
1139 other magic, that it was a little hard for me to understand. I think
1140 I understand it better now, but I haven't time to do the cleanup this
1141 minute. */
1142
1143 if (abfd->flags & D_PAGED)
1144 /* Whether or not WP_TEXT is set -- let D_PAGED override. */
1145 adata (abfd).magic = z_magic;
1146 else if (abfd->flags & WP_TEXT)
1147 adata (abfd).magic = n_magic;
1148 else
1149 adata (abfd).magic = o_magic;
1150
1151 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1152 #if __GNUC__ >= 2
1153 fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1154 ({ char *str;
1155 switch (adata (abfd).magic)
1156 {
1157 case n_magic: str = "NMAGIC"; break;
1158 case o_magic: str = "OMAGIC"; break;
1159 case z_magic: str = "ZMAGIC"; break;
1160 default: abort ();
1161 }
1162 str;
1163 }),
1164 obj_textsec (abfd)->vma, obj_textsec (abfd)->size,
1165 obj_textsec (abfd)->alignment_power,
1166 obj_datasec (abfd)->vma, obj_datasec (abfd)->size,
1167 obj_datasec (abfd)->alignment_power,
1168 obj_bsssec (abfd)->vma, obj_bsssec (abfd)->size,
1169 obj_bsssec (abfd)->alignment_power);
1170 #endif
1171 #endif
1172
1173 switch (adata (abfd).magic)
1174 {
1175 case o_magic:
1176 adjust_o_magic (abfd, execp);
1177 break;
1178 case z_magic:
1179 adjust_z_magic (abfd, execp);
1180 break;
1181 case n_magic:
1182 adjust_n_magic (abfd, execp);
1183 break;
1184 default:
1185 abort ();
1186 }
1187
1188 #ifdef BFD_AOUT_DEBUG
1189 fprintf (stderr, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1190 obj_textsec (abfd)->vma, obj_textsec (abfd)->size,
1191 obj_textsec (abfd)->filepos,
1192 obj_datasec (abfd)->vma, obj_datasec (abfd)->size,
1193 obj_datasec (abfd)->filepos,
1194 obj_bsssec (abfd)->vma, obj_bsssec (abfd)->size);
1195 #endif
1196
1197 return TRUE;
1198 }
1199
1200 /*
1201 FUNCTION
1202 aout_@var{size}_new_section_hook
1203
1204 SYNOPSIS
1205 bfd_boolean aout_@var{size}_new_section_hook,
1206 (bfd *abfd,
1207 asection *newsect);
1208
1209 DESCRIPTION
1210 Called by the BFD in response to a @code{bfd_make_section}
1211 request.
1212 */
1213 bfd_boolean
NAME(aout,new_section_hook)1214 NAME (aout, new_section_hook) (bfd *abfd, asection *newsect)
1215 {
1216 /* Align to double at least. */
1217 newsect->alignment_power = bfd_get_arch_info (abfd)->section_align_power;
1218
1219 if (bfd_get_format (abfd) == bfd_object)
1220 {
1221 if (obj_textsec (abfd) == NULL && !strcmp (newsect->name, ".text"))
1222 {
1223 obj_textsec (abfd)= newsect;
1224 newsect->target_index = N_TEXT;
1225 }
1226 else if (obj_datasec (abfd) == NULL && !strcmp (newsect->name, ".data"))
1227 {
1228 obj_datasec (abfd) = newsect;
1229 newsect->target_index = N_DATA;
1230 }
1231 else if (obj_bsssec (abfd) == NULL && !strcmp (newsect->name, ".bss"))
1232 {
1233 obj_bsssec (abfd) = newsect;
1234 newsect->target_index = N_BSS;
1235 }
1236 }
1237
1238 /* We allow more than three sections internally. */
1239 return _bfd_generic_new_section_hook (abfd, newsect);
1240 }
1241
1242 bfd_boolean
NAME(aout,set_section_contents)1243 NAME (aout, set_section_contents) (bfd *abfd,
1244 sec_ptr section,
1245 const void * location,
1246 file_ptr offset,
1247 bfd_size_type count)
1248 {
1249 file_ptr text_end;
1250 bfd_size_type text_size;
1251
1252 if (! abfd->output_has_begun)
1253 {
1254 if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
1255 return FALSE;
1256 }
1257
1258 if (section == obj_bsssec (abfd))
1259 {
1260 bfd_set_error (bfd_error_no_contents);
1261 return FALSE;
1262 }
1263
1264 if (section != obj_textsec (abfd)
1265 && section != obj_datasec (abfd))
1266 {
1267 if (aout_section_merge_with_text_p (abfd, section))
1268 section->filepos = obj_textsec (abfd)->filepos +
1269 (section->vma - obj_textsec (abfd)->vma);
1270 else
1271 {
1272 (*_bfd_error_handler)
1273 (_("%s: can not represent section `%s' in a.out object file format"),
1274 bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
1275 bfd_set_error (bfd_error_nonrepresentable_section);
1276 return FALSE;
1277 }
1278 }
1279
1280 if (count != 0)
1281 {
1282 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1283 || bfd_bwrite (location, count, abfd) != count)
1284 return FALSE;
1285 }
1286
1287 return TRUE;
1288 }
1289
1290 /* Read the external symbols from an a.out file. */
1291
1292 static bfd_boolean
aout_get_external_symbols(bfd * abfd)1293 aout_get_external_symbols (bfd *abfd)
1294 {
1295 if (obj_aout_external_syms (abfd) == NULL)
1296 {
1297 bfd_size_type count;
1298 struct external_nlist *syms;
1299
1300 count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
1301 if (count == 0)
1302 return TRUE; /* Nothing to do. */
1303
1304 #ifdef USE_MMAP
1305 if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd),
1306 exec_hdr (abfd)->a_syms,
1307 &obj_aout_sym_window (abfd), TRUE))
1308 return FALSE;
1309 syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
1310 #else
1311 /* We allocate using malloc to make the values easy to free
1312 later on. If we put them on the objalloc it might not be
1313 possible to free them. */
1314 syms = (struct external_nlist *) bfd_malloc (count * EXTERNAL_NLIST_SIZE);
1315 if (syms == NULL)
1316 return FALSE;
1317
1318 {
1319 bfd_size_type amt;
1320 amt = exec_hdr (abfd)->a_syms;
1321 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1322 || bfd_bread (syms, amt, abfd) != amt)
1323 {
1324 free (syms);
1325 return FALSE;
1326 }
1327 }
1328 #endif
1329
1330 obj_aout_external_syms (abfd) = syms;
1331 obj_aout_external_sym_count (abfd) = count;
1332 }
1333
1334 if (obj_aout_external_strings (abfd) == NULL
1335 && exec_hdr (abfd)->a_syms != 0)
1336 {
1337 unsigned char string_chars[BYTES_IN_WORD];
1338 bfd_size_type stringsize;
1339 char *strings;
1340 bfd_size_type amt = BYTES_IN_WORD;
1341
1342 /* Get the size of the strings. */
1343 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
1344 || bfd_bread ((void *) string_chars, amt, abfd) != amt)
1345 return FALSE;
1346 stringsize = GET_WORD (abfd, string_chars);
1347
1348 #ifdef USE_MMAP
1349 if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
1350 &obj_aout_string_window (abfd), TRUE))
1351 return FALSE;
1352 strings = (char *) obj_aout_string_window (abfd).data;
1353 #else
1354 strings = (char *) bfd_malloc (stringsize + 1);
1355 if (strings == NULL)
1356 return FALSE;
1357
1358 /* Skip space for the string count in the buffer for convenience
1359 when using indexes. */
1360 amt = stringsize - BYTES_IN_WORD;
1361 if (bfd_bread (strings + BYTES_IN_WORD, amt, abfd) != amt)
1362 {
1363 free (strings);
1364 return FALSE;
1365 }
1366 #endif
1367
1368 /* Ensure that a zero index yields an empty string. */
1369 strings[0] = '\0';
1370
1371 strings[stringsize - 1] = 0;
1372
1373 obj_aout_external_strings (abfd) = strings;
1374 obj_aout_external_string_size (abfd) = stringsize;
1375 }
1376
1377 return TRUE;
1378 }
1379
1380 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1381 and symbol->value fields of CACHE_PTR will be set from the a.out
1382 nlist structure. This function is responsible for setting
1383 symbol->flags and symbol->section, and adjusting symbol->value. */
1384
1385 static bfd_boolean
translate_from_native_sym_flags(bfd * abfd,aout_symbol_type * cache_ptr)1386 translate_from_native_sym_flags (bfd *abfd, aout_symbol_type *cache_ptr)
1387 {
1388 flagword visible;
1389
1390 if ((cache_ptr->type & N_STAB) != 0
1391 || cache_ptr->type == N_FN)
1392 {
1393 asection *sec;
1394
1395 /* This is a debugging symbol. */
1396 cache_ptr->symbol.flags = BSF_DEBUGGING;
1397
1398 /* Work out the symbol section. */
1399 switch (cache_ptr->type & N_TYPE)
1400 {
1401 case N_TEXT:
1402 case N_FN:
1403 sec = obj_textsec (abfd);
1404 break;
1405 case N_DATA:
1406 sec = obj_datasec (abfd);
1407 break;
1408 case N_BSS:
1409 sec = obj_bsssec (abfd);
1410 break;
1411 default:
1412 case N_ABS:
1413 sec = bfd_abs_section_ptr;
1414 break;
1415 }
1416
1417 cache_ptr->symbol.section = sec;
1418 cache_ptr->symbol.value -= sec->vma;
1419
1420 return TRUE;
1421 }
1422
1423 /* Get the default visibility. This does not apply to all types, so
1424 we just hold it in a local variable to use if wanted. */
1425 if ((cache_ptr->type & N_EXT) == 0)
1426 visible = BSF_LOCAL;
1427 else
1428 visible = BSF_GLOBAL;
1429
1430 switch (cache_ptr->type)
1431 {
1432 default:
1433 case N_ABS: case N_ABS | N_EXT:
1434 cache_ptr->symbol.section = bfd_abs_section_ptr;
1435 cache_ptr->symbol.flags = visible;
1436 break;
1437
1438 case N_UNDF | N_EXT:
1439 if (cache_ptr->symbol.value != 0)
1440 {
1441 /* This is a common symbol. */
1442 cache_ptr->symbol.flags = BSF_GLOBAL;
1443 cache_ptr->symbol.section = bfd_com_section_ptr;
1444 }
1445 else
1446 {
1447 cache_ptr->symbol.flags = 0;
1448 cache_ptr->symbol.section = bfd_und_section_ptr;
1449 }
1450 break;
1451
1452 case N_TEXT: case N_TEXT | N_EXT:
1453 cache_ptr->symbol.section = obj_textsec (abfd);
1454 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1455 cache_ptr->symbol.flags = visible;
1456 break;
1457
1458 /* N_SETV symbols used to represent set vectors placed in the
1459 data section. They are no longer generated. Theoretically,
1460 it was possible to extract the entries and combine them with
1461 new ones, although I don't know if that was ever actually
1462 done. Unless that feature is restored, treat them as data
1463 symbols. */
1464 case N_SETV: case N_SETV | N_EXT:
1465 case N_DATA: case N_DATA | N_EXT:
1466 cache_ptr->symbol.section = obj_datasec (abfd);
1467 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1468 cache_ptr->symbol.flags = visible;
1469 break;
1470
1471 case N_BSS: case N_BSS | N_EXT:
1472 cache_ptr->symbol.section = obj_bsssec (abfd);
1473 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1474 cache_ptr->symbol.flags = visible;
1475 break;
1476
1477 case N_SETA: case N_SETA | N_EXT:
1478 case N_SETT: case N_SETT | N_EXT:
1479 case N_SETD: case N_SETD | N_EXT:
1480 case N_SETB: case N_SETB | N_EXT:
1481 {
1482 /* This code is no longer needed. It used to be used to make
1483 the linker handle set symbols, but they are now handled in
1484 the add_symbols routine instead. */
1485 switch (cache_ptr->type & N_TYPE)
1486 {
1487 case N_SETA:
1488 cache_ptr->symbol.section = bfd_abs_section_ptr;
1489 break;
1490 case N_SETT:
1491 cache_ptr->symbol.section = obj_textsec (abfd);
1492 break;
1493 case N_SETD:
1494 cache_ptr->symbol.section = obj_datasec (abfd);
1495 break;
1496 case N_SETB:
1497 cache_ptr->symbol.section = obj_bsssec (abfd);
1498 break;
1499 }
1500
1501 cache_ptr->symbol.flags |= BSF_CONSTRUCTOR;
1502 }
1503 break;
1504
1505 case N_WARNING:
1506 /* This symbol is the text of a warning message. The next
1507 symbol is the symbol to associate the warning with. If a
1508 reference is made to that symbol, a warning is issued. */
1509 cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_WARNING;
1510 cache_ptr->symbol.section = bfd_abs_section_ptr;
1511 break;
1512
1513 case N_INDR: case N_INDR | N_EXT:
1514 /* An indirect symbol. This consists of two symbols in a row.
1515 The first symbol is the name of the indirection. The second
1516 symbol is the name of the target. A reference to the first
1517 symbol becomes a reference to the second. */
1518 cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_INDIRECT | visible;
1519 cache_ptr->symbol.section = bfd_ind_section_ptr;
1520 break;
1521
1522 case N_WEAKU:
1523 cache_ptr->symbol.section = bfd_und_section_ptr;
1524 cache_ptr->symbol.flags = BSF_WEAK;
1525 break;
1526
1527 case N_WEAKA:
1528 cache_ptr->symbol.section = bfd_abs_section_ptr;
1529 cache_ptr->symbol.flags = BSF_WEAK;
1530 break;
1531
1532 case N_WEAKT:
1533 cache_ptr->symbol.section = obj_textsec (abfd);
1534 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1535 cache_ptr->symbol.flags = BSF_WEAK;
1536 break;
1537
1538 case N_WEAKD:
1539 cache_ptr->symbol.section = obj_datasec (abfd);
1540 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1541 cache_ptr->symbol.flags = BSF_WEAK;
1542 break;
1543
1544 case N_WEAKB:
1545 cache_ptr->symbol.section = obj_bsssec (abfd);
1546 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1547 cache_ptr->symbol.flags = BSF_WEAK;
1548 break;
1549 }
1550
1551 return TRUE;
1552 }
1553
1554 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1555
1556 static bfd_boolean
translate_to_native_sym_flags(bfd * abfd,asymbol * cache_ptr,struct external_nlist * sym_pointer)1557 translate_to_native_sym_flags (bfd *abfd,
1558 asymbol *cache_ptr,
1559 struct external_nlist *sym_pointer)
1560 {
1561 bfd_vma value = cache_ptr->value;
1562 asection *sec;
1563 bfd_vma off;
1564
1565 /* Mask out any existing type bits in case copying from one section
1566 to another. */
1567 sym_pointer->e_type[0] &= ~N_TYPE;
1568
1569 sec = bfd_get_section (cache_ptr);
1570 off = 0;
1571
1572 if (sec == NULL)
1573 {
1574 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1575 file. */
1576 (*_bfd_error_handler)
1577 (_("%s: can not represent section for symbol `%s' in a.out object file format"),
1578 bfd_get_filename (abfd),
1579 cache_ptr->name != NULL ? cache_ptr->name : _("*unknown*"));
1580 bfd_set_error (bfd_error_nonrepresentable_section);
1581 return FALSE;
1582 }
1583
1584 if (sec->output_section != NULL)
1585 {
1586 off = sec->output_offset;
1587 sec = sec->output_section;
1588 }
1589
1590 if (bfd_is_abs_section (sec))
1591 sym_pointer->e_type[0] |= N_ABS;
1592 else if (sec == obj_textsec (abfd))
1593 sym_pointer->e_type[0] |= N_TEXT;
1594 else if (sec == obj_datasec (abfd))
1595 sym_pointer->e_type[0] |= N_DATA;
1596 else if (sec == obj_bsssec (abfd))
1597 sym_pointer->e_type[0] |= N_BSS;
1598 else if (bfd_is_und_section (sec))
1599 sym_pointer->e_type[0] = N_UNDF | N_EXT;
1600 else if (bfd_is_ind_section (sec))
1601 sym_pointer->e_type[0] = N_INDR;
1602 else if (bfd_is_com_section (sec))
1603 sym_pointer->e_type[0] = N_UNDF | N_EXT;
1604 else
1605 {
1606 if (aout_section_merge_with_text_p (abfd, sec))
1607 sym_pointer->e_type[0] |= N_TEXT;
1608 else
1609 {
1610 (*_bfd_error_handler)
1611 (_("%s: can not represent section `%s' in a.out object file format"),
1612 bfd_get_filename (abfd), bfd_get_section_name (abfd, sec));
1613 bfd_set_error (bfd_error_nonrepresentable_section);
1614 return FALSE;
1615 }
1616 }
1617
1618 /* Turn the symbol from section relative to absolute again. */
1619 value += sec->vma + off;
1620
1621 if ((cache_ptr->flags & BSF_WARNING) != 0)
1622 sym_pointer->e_type[0] = N_WARNING;
1623
1624 if ((cache_ptr->flags & BSF_DEBUGGING) != 0)
1625 sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type;
1626 else if ((cache_ptr->flags & BSF_GLOBAL) != 0)
1627 sym_pointer->e_type[0] |= N_EXT;
1628 else if ((cache_ptr->flags & BSF_LOCAL) != 0)
1629 sym_pointer->e_type[0] &= ~N_EXT;
1630
1631 if ((cache_ptr->flags & BSF_CONSTRUCTOR) != 0)
1632 {
1633 int type = ((aout_symbol_type *) cache_ptr)->type;
1634
1635 switch (type)
1636 {
1637 case N_ABS: type = N_SETA; break;
1638 case N_TEXT: type = N_SETT; break;
1639 case N_DATA: type = N_SETD; break;
1640 case N_BSS: type = N_SETB; break;
1641 }
1642 sym_pointer->e_type[0] = type;
1643 }
1644
1645 if ((cache_ptr->flags & BSF_WEAK) != 0)
1646 {
1647 int type;
1648
1649 switch (sym_pointer->e_type[0] & N_TYPE)
1650 {
1651 default:
1652 case N_ABS: type = N_WEAKA; break;
1653 case N_TEXT: type = N_WEAKT; break;
1654 case N_DATA: type = N_WEAKD; break;
1655 case N_BSS: type = N_WEAKB; break;
1656 case N_UNDF: type = N_WEAKU; break;
1657 }
1658 sym_pointer->e_type[0] = type;
1659 }
1660
1661 PUT_WORD (abfd, value, sym_pointer->e_value);
1662
1663 return TRUE;
1664 }
1665
1666 /* Native-level interface to symbols. */
1667
1668 asymbol *
NAME(aout,make_empty_symbol)1669 NAME (aout, make_empty_symbol) (bfd *abfd)
1670 {
1671 bfd_size_type amt = sizeof (aout_symbol_type);
1672
1673 aout_symbol_type *new_symbol = (aout_symbol_type *) bfd_zalloc (abfd, amt);
1674 if (!new_symbol)
1675 return NULL;
1676 new_symbol->symbol.the_bfd = abfd;
1677
1678 return &new_symbol->symbol;
1679 }
1680
1681 /* Translate a set of internal symbols into external symbols. */
1682
1683 bfd_boolean
NAME(aout,translate_symbol_table)1684 NAME (aout, translate_symbol_table) (bfd *abfd,
1685 aout_symbol_type *in,
1686 struct external_nlist *ext,
1687 bfd_size_type count,
1688 char *str,
1689 bfd_size_type strsize,
1690 bfd_boolean dynamic)
1691 {
1692 struct external_nlist *ext_end;
1693
1694 ext_end = ext + count;
1695 for (; ext < ext_end; ext++, in++)
1696 {
1697 bfd_vma x;
1698
1699 x = GET_WORD (abfd, ext->e_strx);
1700 in->symbol.the_bfd = abfd;
1701
1702 /* For the normal symbols, the zero index points at the number
1703 of bytes in the string table but is to be interpreted as the
1704 null string. For the dynamic symbols, the number of bytes in
1705 the string table is stored in the __DYNAMIC structure and the
1706 zero index points at an actual string. */
1707 if (x == 0 && ! dynamic)
1708 in->symbol.name = "";
1709 else if (x < strsize)
1710 in->symbol.name = str + x;
1711 else
1712 return FALSE;
1713
1714 in->symbol.value = GET_SWORD (abfd, ext->e_value);
1715 in->desc = H_GET_16 (abfd, ext->e_desc);
1716 in->other = H_GET_8 (abfd, ext->e_other);
1717 in->type = H_GET_8 (abfd, ext->e_type);
1718 in->symbol.udata.p = NULL;
1719
1720 if (! translate_from_native_sym_flags (abfd, in))
1721 return FALSE;
1722
1723 if (dynamic)
1724 in->symbol.flags |= BSF_DYNAMIC;
1725 }
1726
1727 return TRUE;
1728 }
1729
1730 /* We read the symbols into a buffer, which is discarded when this
1731 function exits. We read the strings into a buffer large enough to
1732 hold them all plus all the cached symbol entries. */
1733
1734 bfd_boolean
NAME(aout,slurp_symbol_table)1735 NAME (aout, slurp_symbol_table) (bfd *abfd)
1736 {
1737 struct external_nlist *old_external_syms;
1738 aout_symbol_type *cached;
1739 bfd_size_type cached_size;
1740
1741 /* If there's no work to be done, don't do any. */
1742 if (obj_aout_symbols (abfd) != NULL)
1743 return TRUE;
1744
1745 old_external_syms = obj_aout_external_syms (abfd);
1746
1747 if (! aout_get_external_symbols (abfd))
1748 return FALSE;
1749
1750 cached_size = obj_aout_external_sym_count (abfd);
1751 if (cached_size == 0)
1752 return TRUE; /* Nothing to do. */
1753
1754 cached_size *= sizeof (aout_symbol_type);
1755 cached = (aout_symbol_type *) bfd_zmalloc (cached_size);
1756 if (cached == NULL)
1757 return FALSE;
1758
1759 /* Convert from external symbol information to internal. */
1760 if (! (NAME (aout, translate_symbol_table)
1761 (abfd, cached,
1762 obj_aout_external_syms (abfd),
1763 obj_aout_external_sym_count (abfd),
1764 obj_aout_external_strings (abfd),
1765 obj_aout_external_string_size (abfd),
1766 FALSE)))
1767 {
1768 free (cached);
1769 return FALSE;
1770 }
1771
1772 bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1773
1774 obj_aout_symbols (abfd) = cached;
1775
1776 /* It is very likely that anybody who calls this function will not
1777 want the external symbol information, so if it was allocated
1778 because of our call to aout_get_external_symbols, we free it up
1779 right away to save space. */
1780 if (old_external_syms == NULL
1781 && obj_aout_external_syms (abfd) != NULL)
1782 {
1783 #ifdef USE_MMAP
1784 bfd_free_window (&obj_aout_sym_window (abfd));
1785 #else
1786 free (obj_aout_external_syms (abfd));
1787 #endif
1788 obj_aout_external_syms (abfd) = NULL;
1789 }
1790
1791 return TRUE;
1792 }
1793
1794 /* We use a hash table when writing out symbols so that we only write
1795 out a particular string once. This helps particularly when the
1796 linker writes out stabs debugging entries, because each different
1797 contributing object file tends to have many duplicate stabs
1798 strings.
1799
1800 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1801 if BFD_TRADITIONAL_FORMAT is set. */
1802
1803 /* Get the index of a string in a strtab, adding it if it is not
1804 already present. */
1805
1806 static inline bfd_size_type
add_to_stringtab(bfd * abfd,struct bfd_strtab_hash * tab,const char * str,bfd_boolean copy)1807 add_to_stringtab (bfd *abfd,
1808 struct bfd_strtab_hash *tab,
1809 const char *str,
1810 bfd_boolean copy)
1811 {
1812 bfd_boolean hash;
1813 bfd_size_type str_index;
1814
1815 /* An index of 0 always means the empty string. */
1816 if (str == 0 || *str == '\0')
1817 return 0;
1818
1819 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1820 doesn't understand a hashed string table. */
1821 hash = TRUE;
1822 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1823 hash = FALSE;
1824
1825 str_index = _bfd_stringtab_add (tab, str, hash, copy);
1826
1827 if (str_index != (bfd_size_type) -1)
1828 /* Add BYTES_IN_WORD to the return value to account for the
1829 space taken up by the string table size. */
1830 str_index += BYTES_IN_WORD;
1831
1832 return str_index;
1833 }
1834
1835 /* Write out a strtab. ABFD is already at the right location in the
1836 file. */
1837
1838 static bfd_boolean
emit_stringtab(bfd * abfd,struct bfd_strtab_hash * tab)1839 emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab)
1840 {
1841 bfd_byte buffer[BYTES_IN_WORD];
1842 bfd_size_type amt = BYTES_IN_WORD;
1843
1844 /* The string table starts with the size. */
1845 PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer);
1846 if (bfd_bwrite ((void *) buffer, amt, abfd) != amt)
1847 return FALSE;
1848
1849 return _bfd_stringtab_emit (abfd, tab);
1850 }
1851
1852 bfd_boolean
NAME(aout,write_syms)1853 NAME (aout, write_syms) (bfd *abfd)
1854 {
1855 unsigned int count ;
1856 asymbol **generic = bfd_get_outsymbols (abfd);
1857 struct bfd_strtab_hash *strtab;
1858
1859 strtab = _bfd_stringtab_init ();
1860 if (strtab == NULL)
1861 return FALSE;
1862
1863 for (count = 0; count < bfd_get_symcount (abfd); count++)
1864 {
1865 asymbol *g = generic[count];
1866 bfd_size_type indx;
1867 struct external_nlist nsp;
1868 bfd_size_type amt;
1869
1870 indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
1871 if (indx == (bfd_size_type) -1)
1872 goto error_return;
1873 PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx);
1874
1875 if (bfd_asymbol_flavour (g) == abfd->xvec->flavour)
1876 {
1877 H_PUT_16 (abfd, aout_symbol (g)->desc, nsp.e_desc);
1878 H_PUT_8 (abfd, aout_symbol (g)->other, nsp.e_other);
1879 H_PUT_8 (abfd, aout_symbol (g)->type, nsp.e_type);
1880 }
1881 else
1882 {
1883 H_PUT_16 (abfd, 0, nsp.e_desc);
1884 H_PUT_8 (abfd, 0, nsp.e_other);
1885 H_PUT_8 (abfd, 0, nsp.e_type);
1886 }
1887
1888 if (! translate_to_native_sym_flags (abfd, g, &nsp))
1889 goto error_return;
1890
1891 amt = EXTERNAL_NLIST_SIZE;
1892 if (bfd_bwrite ((void *) &nsp, amt, abfd) != amt)
1893 goto error_return;
1894
1895 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1896 here, at the end. */
1897 g->KEEPIT = count;
1898 }
1899
1900 if (! emit_stringtab (abfd, strtab))
1901 goto error_return;
1902
1903 _bfd_stringtab_free (strtab);
1904
1905 return TRUE;
1906
1907 error_return:
1908 _bfd_stringtab_free (strtab);
1909 return FALSE;
1910 }
1911
1912 long
NAME(aout,canonicalize_symtab)1913 NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location)
1914 {
1915 unsigned int counter = 0;
1916 aout_symbol_type *symbase;
1917
1918 if (!NAME (aout, slurp_symbol_table) (abfd))
1919 return -1;
1920
1921 for (symbase = obj_aout_symbols (abfd);
1922 counter++ < bfd_get_symcount (abfd);
1923 )
1924 *(location++) = (asymbol *) (symbase++);
1925 *location++ =0;
1926 return bfd_get_symcount (abfd);
1927 }
1928
1929 /* Standard reloc stuff. */
1930 /* Output standard relocation information to a file in target byte order. */
1931
1932 extern void NAME (aout, swap_std_reloc_out)
1933 (bfd *, arelent *, struct reloc_std_external *);
1934
1935 void
NAME(aout,swap_std_reloc_out)1936 NAME (aout, swap_std_reloc_out) (bfd *abfd,
1937 arelent *g,
1938 struct reloc_std_external *natptr)
1939 {
1940 int r_index;
1941 asymbol *sym = *(g->sym_ptr_ptr);
1942 int r_extern;
1943 unsigned int r_length;
1944 int r_pcrel;
1945 int r_baserel, r_jmptable, r_relative;
1946 asection *output_section = sym->section->output_section;
1947
1948 PUT_WORD (abfd, g->address, natptr->r_address);
1949
1950 r_length = g->howto->size ; /* Size as a power of two. */
1951 r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
1952 /* XXX This relies on relocs coming from a.out files. */
1953 r_baserel = (g->howto->type & 8) != 0;
1954 r_jmptable = (g->howto->type & 16) != 0;
1955 r_relative = (g->howto->type & 32) != 0;
1956
1957 /* Name was clobbered by aout_write_syms to be symbol index. */
1958
1959 /* If this relocation is relative to a symbol then set the
1960 r_index to the symbols index, and the r_extern bit.
1961
1962 Absolute symbols can come in in two ways, either as an offset
1963 from the abs section, or as a symbol which has an abs value.
1964 check for that here. */
1965
1966 if (bfd_is_com_section (output_section)
1967 || bfd_is_abs_section (output_section)
1968 || bfd_is_und_section (output_section)
1969 /* PR gas/3041 a.out relocs against weak symbols
1970 must be treated as if they were against externs. */
1971 || (sym->flags & BSF_WEAK))
1972 {
1973 if (bfd_abs_section_ptr->symbol == sym)
1974 {
1975 /* Whoops, looked like an abs symbol, but is
1976 really an offset from the abs section. */
1977 r_index = N_ABS;
1978 r_extern = 0;
1979 }
1980 else
1981 {
1982 /* Fill in symbol. */
1983 r_extern = 1;
1984 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
1985 }
1986 }
1987 else
1988 {
1989 /* Just an ordinary section. */
1990 r_extern = 0;
1991 r_index = output_section->target_index;
1992 }
1993
1994 /* Now the fun stuff. */
1995 if (bfd_header_big_endian (abfd))
1996 {
1997 natptr->r_index[0] = r_index >> 16;
1998 natptr->r_index[1] = r_index >> 8;
1999 natptr->r_index[2] = r_index;
2000 natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
2001 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
2002 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
2003 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
2004 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
2005 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
2006 }
2007 else
2008 {
2009 natptr->r_index[2] = r_index >> 16;
2010 natptr->r_index[1] = r_index >> 8;
2011 natptr->r_index[0] = r_index;
2012 natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
2013 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
2014 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
2015 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
2016 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
2017 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
2018 }
2019 }
2020
2021 /* Extended stuff. */
2022 /* Output extended relocation information to a file in target byte order. */
2023
2024 extern void NAME (aout, swap_ext_reloc_out)
2025 (bfd *, arelent *, struct reloc_ext_external *);
2026
2027 void
NAME(aout,swap_ext_reloc_out)2028 NAME (aout, swap_ext_reloc_out) (bfd *abfd,
2029 arelent *g,
2030 struct reloc_ext_external *natptr)
2031 {
2032 int r_index;
2033 int r_extern;
2034 unsigned int r_type;
2035 bfd_vma r_addend;
2036 asymbol *sym = *(g->sym_ptr_ptr);
2037 asection *output_section = sym->section->output_section;
2038
2039 PUT_WORD (abfd, g->address, natptr->r_address);
2040
2041 r_type = (unsigned int) g->howto->type;
2042
2043 r_addend = g->addend;
2044 if ((sym->flags & BSF_SECTION_SYM) != 0)
2045 r_addend += (*(g->sym_ptr_ptr))->section->output_section->vma;
2046
2047 /* If this relocation is relative to a symbol then set the
2048 r_index to the symbols index, and the r_extern bit.
2049
2050 Absolute symbols can come in in two ways, either as an offset
2051 from the abs section, or as a symbol which has an abs value.
2052 check for that here. */
2053 if (bfd_is_abs_section (bfd_get_section (sym)))
2054 {
2055 r_extern = 0;
2056 r_index = N_ABS;
2057 }
2058 else if ((sym->flags & BSF_SECTION_SYM) == 0)
2059 {
2060 if (bfd_is_und_section (bfd_get_section (sym))
2061 || (sym->flags & BSF_GLOBAL) != 0)
2062 r_extern = 1;
2063 else
2064 r_extern = 0;
2065 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2066 }
2067 else
2068 {
2069 /* Just an ordinary section. */
2070 r_extern = 0;
2071 r_index = output_section->target_index;
2072 }
2073
2074 /* Now the fun stuff. */
2075 if (bfd_header_big_endian (abfd))
2076 {
2077 natptr->r_index[0] = r_index >> 16;
2078 natptr->r_index[1] = r_index >> 8;
2079 natptr->r_index[2] = r_index;
2080 natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
2081 | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
2082 }
2083 else
2084 {
2085 natptr->r_index[2] = r_index >> 16;
2086 natptr->r_index[1] = r_index >> 8;
2087 natptr->r_index[0] = r_index;
2088 natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
2089 | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2090 }
2091
2092 PUT_WORD (abfd, r_addend, natptr->r_addend);
2093 }
2094
2095 /* BFD deals internally with all things based from the section they're
2096 in. so, something in 10 bytes into a text section with a base of
2097 50 would have a symbol (.text+10) and know .text vma was 50.
2098
2099 Aout keeps all it's symbols based from zero, so the symbol would
2100 contain 60. This macro subs the base of each section from the value
2101 to give the true offset from the section. */
2102
2103 #define MOVE_ADDRESS(ad) \
2104 if (r_extern) \
2105 { \
2106 /* Undefined symbol. */ \
2107 cache_ptr->sym_ptr_ptr = symbols + r_index; \
2108 cache_ptr->addend = ad; \
2109 } \
2110 else \
2111 { \
2112 /* Defined, section relative. Replace symbol with pointer to \
2113 symbol which points to section. */ \
2114 switch (r_index) \
2115 { \
2116 case N_TEXT: \
2117 case N_TEXT | N_EXT: \
2118 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
2119 cache_ptr->addend = ad - su->textsec->vma; \
2120 break; \
2121 case N_DATA: \
2122 case N_DATA | N_EXT: \
2123 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
2124 cache_ptr->addend = ad - su->datasec->vma; \
2125 break; \
2126 case N_BSS: \
2127 case N_BSS | N_EXT: \
2128 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
2129 cache_ptr->addend = ad - su->bsssec->vma; \
2130 break; \
2131 default: \
2132 case N_ABS: \
2133 case N_ABS | N_EXT: \
2134 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2135 cache_ptr->addend = ad; \
2136 break; \
2137 } \
2138 }
2139
2140 void
NAME(aout,swap_ext_reloc_in)2141 NAME (aout, swap_ext_reloc_in) (bfd *abfd,
2142 struct reloc_ext_external *bytes,
2143 arelent *cache_ptr,
2144 asymbol **symbols,
2145 bfd_size_type symcount)
2146 {
2147 unsigned int r_index;
2148 int r_extern;
2149 unsigned int r_type;
2150 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2151
2152 cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
2153
2154 /* Now the fun stuff. */
2155 if (bfd_header_big_endian (abfd))
2156 {
2157 r_index = (((unsigned int) bytes->r_index[0] << 16)
2158 | ((unsigned int) bytes->r_index[1] << 8)
2159 | bytes->r_index[2]);
2160 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
2161 r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2162 >> RELOC_EXT_BITS_TYPE_SH_BIG);
2163 }
2164 else
2165 {
2166 r_index = (((unsigned int) bytes->r_index[2] << 16)
2167 | ((unsigned int) bytes->r_index[1] << 8)
2168 | bytes->r_index[0]);
2169 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
2170 r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2171 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
2172 }
2173
2174 if (r_type < TABLE_SIZE (howto_table_ext))
2175 cache_ptr->howto = howto_table_ext + r_type;
2176 else
2177 cache_ptr->howto = NULL;
2178
2179 /* Base relative relocs are always against the symbol table,
2180 regardless of the setting of r_extern. r_extern just reflects
2181 whether the symbol the reloc is against is local or global. */
2182 if (r_type == (unsigned int) RELOC_BASE10
2183 || r_type == (unsigned int) RELOC_BASE13
2184 || r_type == (unsigned int) RELOC_BASE22)
2185 r_extern = 1;
2186
2187 if (r_extern && r_index > symcount)
2188 {
2189 /* We could arrange to return an error, but it might be useful
2190 to see the file even if it is bad. */
2191 r_extern = 0;
2192 r_index = N_ABS;
2193 }
2194
2195 MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
2196 }
2197
2198 void
NAME(aout,swap_std_reloc_in)2199 NAME (aout, swap_std_reloc_in) (bfd *abfd,
2200 struct reloc_std_external *bytes,
2201 arelent *cache_ptr,
2202 asymbol **symbols,
2203 bfd_size_type symcount)
2204 {
2205 unsigned int r_index;
2206 int r_extern;
2207 unsigned int r_length;
2208 int r_pcrel;
2209 int r_baserel, r_jmptable, r_relative;
2210 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2211 unsigned int howto_idx;
2212
2213 cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
2214
2215 /* Now the fun stuff. */
2216 if (bfd_header_big_endian (abfd))
2217 {
2218 r_index = (((unsigned int) bytes->r_index[0] << 16)
2219 | ((unsigned int) bytes->r_index[1] << 8)
2220 | bytes->r_index[2]);
2221 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
2222 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2223 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2224 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2225 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
2226 r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
2227 >> RELOC_STD_BITS_LENGTH_SH_BIG);
2228 }
2229 else
2230 {
2231 r_index = (((unsigned int) bytes->r_index[2] << 16)
2232 | ((unsigned int) bytes->r_index[1] << 8)
2233 | bytes->r_index[0]);
2234 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
2235 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2236 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2237 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2238 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
2239 r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
2240 >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
2241 }
2242
2243 howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
2244 + 16 * r_jmptable + 32 * r_relative);
2245 if (howto_idx < TABLE_SIZE (howto_table_std))
2246 {
2247 cache_ptr->howto = howto_table_std + howto_idx;
2248 if (cache_ptr->howto->type == (unsigned int) -1)
2249 cache_ptr->howto = NULL;
2250 }
2251 else
2252 cache_ptr->howto = NULL;
2253
2254 /* Base relative relocs are always against the symbol table,
2255 regardless of the setting of r_extern. r_extern just reflects
2256 whether the symbol the reloc is against is local or global. */
2257 if (r_baserel)
2258 r_extern = 1;
2259
2260 if (r_extern && r_index > symcount)
2261 {
2262 /* We could arrange to return an error, but it might be useful
2263 to see the file even if it is bad. */
2264 r_extern = 0;
2265 r_index = N_ABS;
2266 }
2267
2268 MOVE_ADDRESS (0);
2269 }
2270
2271 /* Read and swap the relocs for a section. */
2272
2273 bfd_boolean
NAME(aout,slurp_reloc_table)2274 NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
2275 {
2276 bfd_size_type count;
2277 bfd_size_type reloc_size;
2278 void * relocs;
2279 arelent *reloc_cache;
2280 size_t each_size;
2281 unsigned int counter = 0;
2282 arelent *cache_ptr;
2283 bfd_size_type amt;
2284
2285 if (asect->relocation)
2286 return TRUE;
2287
2288 if (asect->flags & SEC_CONSTRUCTOR)
2289 return TRUE;
2290
2291 if (asect == obj_datasec (abfd))
2292 reloc_size = exec_hdr (abfd)->a_drsize;
2293 else if (asect == obj_textsec (abfd))
2294 reloc_size = exec_hdr (abfd)->a_trsize;
2295 else if (asect == obj_bsssec (abfd))
2296 reloc_size = 0;
2297 else
2298 {
2299 bfd_set_error (bfd_error_invalid_operation);
2300 return FALSE;
2301 }
2302
2303 if (reloc_size == 0)
2304 return TRUE; /* Nothing to be done. */
2305
2306 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
2307 return FALSE;
2308
2309 each_size = obj_reloc_entry_size (abfd);
2310
2311 count = reloc_size / each_size;
2312 if (count == 0)
2313 return TRUE; /* Nothing to be done. */
2314
2315 amt = count * sizeof (arelent);
2316 reloc_cache = (arelent *) bfd_zmalloc (amt);
2317 if (reloc_cache == NULL)
2318 return FALSE;
2319
2320 relocs = bfd_malloc (reloc_size);
2321 if (relocs == NULL)
2322 {
2323 free (reloc_cache);
2324 return FALSE;
2325 }
2326
2327 if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
2328 {
2329 free (relocs);
2330 free (reloc_cache);
2331 return FALSE;
2332 }
2333
2334 cache_ptr = reloc_cache;
2335 if (each_size == RELOC_EXT_SIZE)
2336 {
2337 struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
2338
2339 for (; counter < count; counter++, rptr++, cache_ptr++)
2340 MY_swap_ext_reloc_in (abfd, rptr, cache_ptr, symbols,
2341 (bfd_size_type) bfd_get_symcount (abfd));
2342 }
2343 else
2344 {
2345 struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
2346
2347 for (; counter < count; counter++, rptr++, cache_ptr++)
2348 MY_swap_std_reloc_in (abfd, rptr, cache_ptr, symbols,
2349 (bfd_size_type) bfd_get_symcount (abfd));
2350 }
2351
2352 free (relocs);
2353
2354 asect->relocation = reloc_cache;
2355 asect->reloc_count = cache_ptr - reloc_cache;
2356
2357 return TRUE;
2358 }
2359
2360 /* Write out a relocation section into an object file. */
2361
2362 bfd_boolean
NAME(aout,squirt_out_relocs)2363 NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
2364 {
2365 arelent **generic;
2366 unsigned char *native, *natptr;
2367 size_t each_size;
2368
2369 unsigned int count = section->reloc_count;
2370 bfd_size_type natsize;
2371
2372 if (count == 0 || section->orelocation == NULL)
2373 return TRUE;
2374
2375 each_size = obj_reloc_entry_size (abfd);
2376 natsize = (bfd_size_type) each_size * count;
2377 native = (unsigned char *) bfd_zalloc (abfd, natsize);
2378 if (!native)
2379 return FALSE;
2380
2381 generic = section->orelocation;
2382
2383 if (each_size == RELOC_EXT_SIZE)
2384 {
2385 for (natptr = native;
2386 count != 0;
2387 --count, natptr += each_size, ++generic)
2388 MY_swap_ext_reloc_out (abfd, *generic,
2389 (struct reloc_ext_external *) natptr);
2390 }
2391 else
2392 {
2393 for (natptr = native;
2394 count != 0;
2395 --count, natptr += each_size, ++generic)
2396 MY_swap_std_reloc_out (abfd, *generic,
2397 (struct reloc_std_external *) natptr);
2398 }
2399
2400 if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
2401 {
2402 bfd_release (abfd, native);
2403 return FALSE;
2404 }
2405 bfd_release (abfd, native);
2406
2407 return TRUE;
2408 }
2409
2410 /* This is stupid. This function should be a boolean predicate. */
2411
2412 long
NAME(aout,canonicalize_reloc)2413 NAME (aout, canonicalize_reloc) (bfd *abfd,
2414 sec_ptr section,
2415 arelent **relptr,
2416 asymbol **symbols)
2417 {
2418 arelent *tblptr = section->relocation;
2419 unsigned int count;
2420
2421 if (section == obj_bsssec (abfd))
2422 {
2423 *relptr = NULL;
2424 return 0;
2425 }
2426
2427 if (!(tblptr || NAME (aout, slurp_reloc_table) (abfd, section, symbols)))
2428 return -1;
2429
2430 if (section->flags & SEC_CONSTRUCTOR)
2431 {
2432 arelent_chain *chain = section->constructor_chain;
2433 for (count = 0; count < section->reloc_count; count ++)
2434 {
2435 *relptr ++ = &chain->relent;
2436 chain = chain->next;
2437 }
2438 }
2439 else
2440 {
2441 tblptr = section->relocation;
2442
2443 for (count = 0; count++ < section->reloc_count; )
2444 {
2445 *relptr++ = tblptr++;
2446 }
2447 }
2448 *relptr = 0;
2449
2450 return section->reloc_count;
2451 }
2452
2453 long
NAME(aout,get_reloc_upper_bound)2454 NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect)
2455 {
2456 if (bfd_get_format (abfd) != bfd_object)
2457 {
2458 bfd_set_error (bfd_error_invalid_operation);
2459 return -1;
2460 }
2461
2462 if (asect->flags & SEC_CONSTRUCTOR)
2463 return sizeof (arelent *) * (asect->reloc_count + 1);
2464
2465 if (asect == obj_datasec (abfd))
2466 return sizeof (arelent *)
2467 * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd))
2468 + 1);
2469
2470 if (asect == obj_textsec (abfd))
2471 return sizeof (arelent *)
2472 * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
2473 + 1);
2474
2475 if (asect == obj_bsssec (abfd))
2476 return sizeof (arelent *);
2477
2478 if (asect == obj_bsssec (abfd))
2479 return 0;
2480
2481 bfd_set_error (bfd_error_invalid_operation);
2482 return -1;
2483 }
2484
2485 long
NAME(aout,get_symtab_upper_bound)2486 NAME (aout, get_symtab_upper_bound) (bfd *abfd)
2487 {
2488 if (!NAME (aout, slurp_symbol_table) (abfd))
2489 return -1;
2490
2491 return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
2492 }
2493
2494 alent *
NAME(aout,get_lineno)2495 NAME (aout, get_lineno) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2496 asymbol *ignore_symbol ATTRIBUTE_UNUSED)
2497 {
2498 return NULL;
2499 }
2500
2501 void
NAME(aout,get_symbol_info)2502 NAME (aout, get_symbol_info) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2503 asymbol *symbol,
2504 symbol_info *ret)
2505 {
2506 bfd_symbol_info (symbol, ret);
2507
2508 if (ret->type == '?')
2509 {
2510 int type_code = aout_symbol (symbol)->type & 0xff;
2511 const char *stab_name = bfd_get_stab_name (type_code);
2512 static char buf[10];
2513
2514 if (stab_name == NULL)
2515 {
2516 sprintf (buf, "(%d)", type_code);
2517 stab_name = buf;
2518 }
2519 ret->type = '-';
2520 ret->stab_type = type_code;
2521 ret->stab_other = (unsigned) (aout_symbol (symbol)->other & 0xff);
2522 ret->stab_desc = (unsigned) (aout_symbol (symbol)->desc & 0xffff);
2523 ret->stab_name = stab_name;
2524 }
2525 }
2526
2527 void
NAME(aout,print_symbol)2528 NAME (aout, print_symbol) (bfd *abfd,
2529 void * afile,
2530 asymbol *symbol,
2531 bfd_print_symbol_type how)
2532 {
2533 FILE *file = (FILE *)afile;
2534
2535 switch (how)
2536 {
2537 case bfd_print_symbol_name:
2538 if (symbol->name)
2539 fprintf (file,"%s", symbol->name);
2540 break;
2541 case bfd_print_symbol_more:
2542 fprintf (file,"%4x %2x %2x",
2543 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2544 (unsigned) (aout_symbol (symbol)->other & 0xff),
2545 (unsigned) (aout_symbol (symbol)->type));
2546 break;
2547 case bfd_print_symbol_all:
2548 {
2549 const char *section_name = symbol->section->name;
2550
2551 bfd_print_symbol_vandf (abfd, (void *)file, symbol);
2552
2553 fprintf (file," %-5s %04x %02x %02x",
2554 section_name,
2555 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2556 (unsigned) (aout_symbol (symbol)->other & 0xff),
2557 (unsigned) (aout_symbol (symbol)->type & 0xff));
2558 if (symbol->name)
2559 fprintf (file," %s", symbol->name);
2560 }
2561 break;
2562 }
2563 }
2564
2565 /* If we don't have to allocate more than 1MB to hold the generic
2566 symbols, we use the generic minisymbol methord: it's faster, since
2567 it only translates the symbols once, not multiple times. */
2568 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2569
2570 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2571 symbols. The minisymbol_to_symbol function translates these into
2572 BFD asymbol structures. */
2573
2574 long
NAME(aout,read_minisymbols)2575 NAME (aout, read_minisymbols) (bfd *abfd,
2576 bfd_boolean dynamic,
2577 void * *minisymsp,
2578 unsigned int *sizep)
2579 {
2580 if (dynamic)
2581 /* We could handle the dynamic symbols here as well, but it's
2582 easier to hand them off. */
2583 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2584
2585 if (! aout_get_external_symbols (abfd))
2586 return -1;
2587
2588 if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2589 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2590
2591 *minisymsp = (void *) obj_aout_external_syms (abfd);
2592
2593 /* By passing the external symbols back from this routine, we are
2594 giving up control over the memory block. Clear
2595 obj_aout_external_syms, so that we do not try to free it
2596 ourselves. */
2597 obj_aout_external_syms (abfd) = NULL;
2598
2599 *sizep = EXTERNAL_NLIST_SIZE;
2600 return obj_aout_external_sym_count (abfd);
2601 }
2602
2603 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2604 unmodified a.out symbol. The SYM argument is a structure returned
2605 by bfd_make_empty_symbol, which we fill in here. */
2606
2607 asymbol *
NAME(aout,minisymbol_to_symbol)2608 NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2609 bfd_boolean dynamic,
2610 const void * minisym,
2611 asymbol *sym)
2612 {
2613 if (dynamic
2614 || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2615 return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2616
2617 memset (sym, 0, sizeof (aout_symbol_type));
2618
2619 /* We call translate_symbol_table to translate a single symbol. */
2620 if (! (NAME (aout, translate_symbol_table)
2621 (abfd,
2622 (aout_symbol_type *) sym,
2623 (struct external_nlist *) minisym,
2624 (bfd_size_type) 1,
2625 obj_aout_external_strings (abfd),
2626 obj_aout_external_string_size (abfd),
2627 FALSE)))
2628 return NULL;
2629
2630 return sym;
2631 }
2632
2633 /* Provided a BFD, a section and an offset into the section, calculate
2634 and return the name of the source file and the line nearest to the
2635 wanted location. */
2636
2637 bfd_boolean
NAME(aout,find_nearest_line)2638 NAME (aout, find_nearest_line) (bfd *abfd,
2639 asection *section,
2640 asymbol **symbols,
2641 bfd_vma offset,
2642 const char **filename_ptr,
2643 const char **functionname_ptr,
2644 unsigned int *line_ptr)
2645 {
2646 /* Run down the file looking for the filename, function and linenumber. */
2647 asymbol **p;
2648 const char *directory_name = NULL;
2649 const char *main_file_name = NULL;
2650 const char *current_file_name = NULL;
2651 const char *line_file_name = NULL; /* Value of current_file_name at line number. */
2652 const char *line_directory_name = NULL; /* Value of directory_name at line number. */
2653 bfd_vma low_line_vma = 0;
2654 bfd_vma low_func_vma = 0;
2655 asymbol *func = 0;
2656 bfd_size_type filelen, funclen;
2657 char *buf;
2658
2659 *filename_ptr = abfd->filename;
2660 *functionname_ptr = 0;
2661 *line_ptr = 0;
2662
2663 if (symbols != NULL)
2664 {
2665 for (p = symbols; *p; p++)
2666 {
2667 aout_symbol_type *q = (aout_symbol_type *) (*p);
2668 next:
2669 switch (q->type)
2670 {
2671 case N_TEXT:
2672 /* If this looks like a file name symbol, and it comes after
2673 the line number we have found so far, but before the
2674 offset, then we have probably not found the right line
2675 number. */
2676 if (q->symbol.value <= offset
2677 && ((q->symbol.value > low_line_vma
2678 && (line_file_name != NULL
2679 || *line_ptr != 0))
2680 || (q->symbol.value > low_func_vma
2681 && func != NULL)))
2682 {
2683 const char *symname;
2684
2685 symname = q->symbol.name;
2686 if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2687 {
2688 if (q->symbol.value > low_line_vma)
2689 {
2690 *line_ptr = 0;
2691 line_file_name = NULL;
2692 }
2693 if (q->symbol.value > low_func_vma)
2694 func = NULL;
2695 }
2696 }
2697 break;
2698
2699 case N_SO:
2700 /* If this symbol is less than the offset, but greater than
2701 the line number we have found so far, then we have not
2702 found the right line number. */
2703 if (q->symbol.value <= offset)
2704 {
2705 if (q->symbol.value > low_line_vma)
2706 {
2707 *line_ptr = 0;
2708 line_file_name = NULL;
2709 }
2710 if (q->symbol.value > low_func_vma)
2711 func = NULL;
2712 }
2713
2714 main_file_name = current_file_name = q->symbol.name;
2715 /* Look ahead to next symbol to check if that too is an N_SO. */
2716 p++;
2717 if (*p == NULL)
2718 goto done;
2719 q = (aout_symbol_type *) (*p);
2720 if (q->type != (int)N_SO)
2721 goto next;
2722
2723 /* Found a second N_SO First is directory; second is filename. */
2724 directory_name = current_file_name;
2725 main_file_name = current_file_name = q->symbol.name;
2726 if (obj_textsec (abfd) != section)
2727 goto done;
2728 break;
2729 case N_SOL:
2730 current_file_name = q->symbol.name;
2731 break;
2732
2733 case N_SLINE:
2734
2735 case N_DSLINE:
2736 case N_BSLINE:
2737 /* We'll keep this if it resolves nearer than the one we have
2738 already. */
2739 if (q->symbol.value >= low_line_vma
2740 && q->symbol.value <= offset)
2741 {
2742 *line_ptr = q->desc;
2743 low_line_vma = q->symbol.value;
2744 line_file_name = current_file_name;
2745 line_directory_name = directory_name;
2746 }
2747 break;
2748 case N_FUN:
2749 {
2750 /* We'll keep this if it is nearer than the one we have already. */
2751 if (q->symbol.value >= low_func_vma &&
2752 q->symbol.value <= offset)
2753 {
2754 low_func_vma = q->symbol.value;
2755 func = (asymbol *)q;
2756 }
2757 else if (q->symbol.value > offset)
2758 goto done;
2759 }
2760 break;
2761 }
2762 }
2763 }
2764
2765 done:
2766 if (*line_ptr != 0)
2767 {
2768 main_file_name = line_file_name;
2769 directory_name = line_directory_name;
2770 }
2771
2772 if (main_file_name == NULL
2773 || IS_ABSOLUTE_PATH (main_file_name)
2774 || directory_name == NULL)
2775 filelen = 0;
2776 else
2777 filelen = strlen (directory_name) + strlen (main_file_name);
2778
2779 if (func == NULL)
2780 funclen = 0;
2781 else
2782 funclen = strlen (bfd_asymbol_name (func));
2783
2784 if (adata (abfd).line_buf != NULL)
2785 free (adata (abfd).line_buf);
2786
2787 if (filelen + funclen == 0)
2788 adata (abfd).line_buf = buf = NULL;
2789 else
2790 {
2791 buf = (char *) bfd_malloc (filelen + funclen + 3);
2792 adata (abfd).line_buf = buf;
2793 if (buf == NULL)
2794 return FALSE;
2795 }
2796
2797 if (main_file_name != NULL)
2798 {
2799 if (IS_ABSOLUTE_PATH (main_file_name) || directory_name == NULL)
2800 *filename_ptr = main_file_name;
2801 else
2802 {
2803 sprintf (buf, "%s%s", directory_name, main_file_name);
2804 *filename_ptr = buf;
2805 buf += filelen + 1;
2806 }
2807 }
2808
2809 if (func)
2810 {
2811 const char *function = func->name;
2812 char *colon;
2813
2814 /* The caller expects a symbol name. We actually have a
2815 function name, without the leading underscore. Put the
2816 underscore back in, so that the caller gets a symbol name. */
2817 if (bfd_get_symbol_leading_char (abfd) == '\0')
2818 strcpy (buf, function);
2819 else
2820 {
2821 buf[0] = bfd_get_symbol_leading_char (abfd);
2822 strcpy (buf + 1, function);
2823 }
2824 /* Have to remove : stuff. */
2825 colon = strchr (buf, ':');
2826 if (colon != NULL)
2827 *colon = '\0';
2828 *functionname_ptr = buf;
2829 }
2830
2831 return TRUE;
2832 }
2833
2834 int
NAME(aout,sizeof_headers)2835 NAME (aout, sizeof_headers) (bfd *abfd,
2836 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2837 {
2838 return adata (abfd).exec_bytes_size;
2839 }
2840
2841 /* Free all information we have cached for this BFD. We can always
2842 read it again later if we need it. */
2843
2844 bfd_boolean
NAME(aout,bfd_free_cached_info)2845 NAME (aout, bfd_free_cached_info) (bfd *abfd)
2846 {
2847 asection *o;
2848
2849 if (bfd_get_format (abfd) != bfd_object
2850 || abfd->tdata.aout_data == NULL)
2851 return TRUE;
2852
2853 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2854 BFCI_FREE (obj_aout_symbols (abfd));
2855 #ifdef USE_MMAP
2856 obj_aout_external_syms (abfd) = 0;
2857 bfd_free_window (&obj_aout_sym_window (abfd));
2858 bfd_free_window (&obj_aout_string_window (abfd));
2859 obj_aout_external_strings (abfd) = 0;
2860 #else
2861 BFCI_FREE (obj_aout_external_syms (abfd));
2862 BFCI_FREE (obj_aout_external_strings (abfd));
2863 #endif
2864 for (o = abfd->sections; o != NULL; o = o->next)
2865 BFCI_FREE (o->relocation);
2866 #undef BFCI_FREE
2867
2868 return TRUE;
2869 }
2870
2871 /* a.out link code. */
2872
2873 /* Routine to create an entry in an a.out link hash table. */
2874
2875 struct bfd_hash_entry *
NAME(aout,link_hash_newfunc)2876 NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2877 struct bfd_hash_table *table,
2878 const char *string)
2879 {
2880 struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2881
2882 /* Allocate the structure if it has not already been allocated by a
2883 subclass. */
2884 if (ret == NULL)
2885 ret = (struct aout_link_hash_entry *) bfd_hash_allocate (table,
2886 sizeof (* ret));
2887 if (ret == NULL)
2888 return NULL;
2889
2890 /* Call the allocation method of the superclass. */
2891 ret = ((struct aout_link_hash_entry *)
2892 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2893 table, string));
2894 if (ret)
2895 {
2896 /* Set local fields. */
2897 ret->written = FALSE;
2898 ret->indx = -1;
2899 }
2900
2901 return (struct bfd_hash_entry *) ret;
2902 }
2903
2904 /* Initialize an a.out link hash table. */
2905
2906 bfd_boolean
NAME(aout,link_hash_table_init)2907 NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2908 bfd *abfd,
2909 struct bfd_hash_entry *(*newfunc)
2910 (struct bfd_hash_entry *, struct bfd_hash_table *,
2911 const char *),
2912 unsigned int entsize)
2913 {
2914 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
2915 }
2916
2917 /* Create an a.out link hash table. */
2918
2919 struct bfd_link_hash_table *
NAME(aout,link_hash_table_create)2920 NAME (aout, link_hash_table_create) (bfd *abfd)
2921 {
2922 struct aout_link_hash_table *ret;
2923 bfd_size_type amt = sizeof (* ret);
2924
2925 ret = (struct aout_link_hash_table *) bfd_malloc (amt);
2926 if (ret == NULL)
2927 return NULL;
2928
2929 if (!NAME (aout, link_hash_table_init) (ret, abfd,
2930 NAME (aout, link_hash_newfunc),
2931 sizeof (struct aout_link_hash_entry)))
2932 {
2933 free (ret);
2934 return NULL;
2935 }
2936 return &ret->root;
2937 }
2938
2939 /* Add all symbols from an object file to the hash table. */
2940
2941 static bfd_boolean
aout_link_add_symbols(bfd * abfd,struct bfd_link_info * info)2942 aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
2943 {
2944 bfd_boolean (*add_one_symbol)
2945 (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2946 bfd_vma, const char *, bfd_boolean, bfd_boolean,
2947 struct bfd_link_hash_entry **);
2948 struct external_nlist *syms;
2949 bfd_size_type sym_count;
2950 char *strings;
2951 bfd_boolean copy;
2952 struct aout_link_hash_entry **sym_hash;
2953 struct external_nlist *p;
2954 struct external_nlist *pend;
2955 bfd_size_type amt;
2956
2957 syms = obj_aout_external_syms (abfd);
2958 sym_count = obj_aout_external_sym_count (abfd);
2959 strings = obj_aout_external_strings (abfd);
2960 if (info->keep_memory)
2961 copy = FALSE;
2962 else
2963 copy = TRUE;
2964
2965 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
2966 {
2967 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2968 (abfd, info, &syms, &sym_count, &strings)))
2969 return FALSE;
2970 }
2971
2972 if (sym_count == 0)
2973 return TRUE; /* Nothing to do. */
2974
2975 /* We keep a list of the linker hash table entries that correspond
2976 to particular symbols. We could just look them up in the hash
2977 table, but keeping the list is more efficient. Perhaps this
2978 should be conditional on info->keep_memory. */
2979 amt = sym_count * sizeof (struct aout_link_hash_entry *);
2980 sym_hash = (struct aout_link_hash_entry **) bfd_alloc (abfd, amt);
2981 if (sym_hash == NULL)
2982 return FALSE;
2983 obj_aout_sym_hashes (abfd) = sym_hash;
2984
2985 add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2986 if (add_one_symbol == NULL)
2987 add_one_symbol = _bfd_generic_link_add_one_symbol;
2988
2989 p = syms;
2990 pend = p + sym_count;
2991 for (; p < pend; p++, sym_hash++)
2992 {
2993 int type;
2994 const char *name;
2995 bfd_vma value;
2996 asection *section;
2997 flagword flags;
2998 const char *string;
2999
3000 *sym_hash = NULL;
3001
3002 type = H_GET_8 (abfd, p->e_type);
3003
3004 /* Ignore debugging symbols. */
3005 if ((type & N_STAB) != 0)
3006 continue;
3007
3008 name = strings + GET_WORD (abfd, p->e_strx);
3009 value = GET_WORD (abfd, p->e_value);
3010 flags = BSF_GLOBAL;
3011 string = NULL;
3012 switch (type)
3013 {
3014 default:
3015 abort ();
3016
3017 case N_UNDF:
3018 case N_ABS:
3019 case N_TEXT:
3020 case N_DATA:
3021 case N_BSS:
3022 case N_FN_SEQ:
3023 case N_COMM:
3024 case N_SETV:
3025 case N_FN:
3026 /* Ignore symbols that are not externally visible. */
3027 continue;
3028 case N_INDR:
3029 /* Ignore local indirect symbol. */
3030 ++p;
3031 ++sym_hash;
3032 continue;
3033
3034 case N_UNDF | N_EXT:
3035 if (value == 0)
3036 {
3037 section = bfd_und_section_ptr;
3038 flags = 0;
3039 }
3040 else
3041 section = bfd_com_section_ptr;
3042 break;
3043 case N_ABS | N_EXT:
3044 section = bfd_abs_section_ptr;
3045 break;
3046 case N_TEXT | N_EXT:
3047 section = obj_textsec (abfd);
3048 value -= bfd_get_section_vma (abfd, section);
3049 break;
3050 case N_DATA | N_EXT:
3051 case N_SETV | N_EXT:
3052 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3053 translate_from_native_sym_flags. */
3054 section = obj_datasec (abfd);
3055 value -= bfd_get_section_vma (abfd, section);
3056 break;
3057 case N_BSS | N_EXT:
3058 section = obj_bsssec (abfd);
3059 value -= bfd_get_section_vma (abfd, section);
3060 break;
3061 case N_INDR | N_EXT:
3062 /* An indirect symbol. The next symbol is the symbol
3063 which this one really is. */
3064 BFD_ASSERT (p + 1 < pend);
3065 ++p;
3066 string = strings + GET_WORD (abfd, p->e_strx);
3067 section = bfd_ind_section_ptr;
3068 flags |= BSF_INDIRECT;
3069 break;
3070 case N_COMM | N_EXT:
3071 section = bfd_com_section_ptr;
3072 break;
3073 case N_SETA: case N_SETA | N_EXT:
3074 section = bfd_abs_section_ptr;
3075 flags |= BSF_CONSTRUCTOR;
3076 break;
3077 case N_SETT: case N_SETT | N_EXT:
3078 section = obj_textsec (abfd);
3079 flags |= BSF_CONSTRUCTOR;
3080 value -= bfd_get_section_vma (abfd, section);
3081 break;
3082 case N_SETD: case N_SETD | N_EXT:
3083 section = obj_datasec (abfd);
3084 flags |= BSF_CONSTRUCTOR;
3085 value -= bfd_get_section_vma (abfd, section);
3086 break;
3087 case N_SETB: case N_SETB | N_EXT:
3088 section = obj_bsssec (abfd);
3089 flags |= BSF_CONSTRUCTOR;
3090 value -= bfd_get_section_vma (abfd, section);
3091 break;
3092 case N_WARNING:
3093 /* A warning symbol. The next symbol is the one to warn
3094 about. If there is no next symbol, just look away. */
3095 if (p + 1 >= pend)
3096 return TRUE;
3097 ++p;
3098 string = name;
3099 name = strings + GET_WORD (abfd, p->e_strx);
3100 section = bfd_und_section_ptr;
3101 flags |= BSF_WARNING;
3102 break;
3103 case N_WEAKU:
3104 section = bfd_und_section_ptr;
3105 flags = BSF_WEAK;
3106 break;
3107 case N_WEAKA:
3108 section = bfd_abs_section_ptr;
3109 flags = BSF_WEAK;
3110 break;
3111 case N_WEAKT:
3112 section = obj_textsec (abfd);
3113 value -= bfd_get_section_vma (abfd, section);
3114 flags = BSF_WEAK;
3115 break;
3116 case N_WEAKD:
3117 section = obj_datasec (abfd);
3118 value -= bfd_get_section_vma (abfd, section);
3119 flags = BSF_WEAK;
3120 break;
3121 case N_WEAKB:
3122 section = obj_bsssec (abfd);
3123 value -= bfd_get_section_vma (abfd, section);
3124 flags = BSF_WEAK;
3125 break;
3126 }
3127
3128 if (! ((*add_one_symbol)
3129 (info, abfd, name, flags, section, value, string, copy, FALSE,
3130 (struct bfd_link_hash_entry **) sym_hash)))
3131 return FALSE;
3132
3133 /* Restrict the maximum alignment of a common symbol based on
3134 the architecture, since a.out has no way to represent
3135 alignment requirements of a section in a .o file. FIXME:
3136 This isn't quite right: it should use the architecture of the
3137 output file, not the input files. */
3138 if ((*sym_hash)->root.type == bfd_link_hash_common
3139 && ((*sym_hash)->root.u.c.p->alignment_power >
3140 bfd_get_arch_info (abfd)->section_align_power))
3141 (*sym_hash)->root.u.c.p->alignment_power =
3142 bfd_get_arch_info (abfd)->section_align_power;
3143
3144 /* If this is a set symbol, and we are not building sets, then
3145 it is possible for the hash entry to not have been set. In
3146 such a case, treat the symbol as not globally defined. */
3147 if ((*sym_hash)->root.type == bfd_link_hash_new)
3148 {
3149 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3150 *sym_hash = NULL;
3151 }
3152
3153 if (type == (N_INDR | N_EXT) || type == N_WARNING)
3154 ++sym_hash;
3155 }
3156
3157 return TRUE;
3158 }
3159
3160 /* Free up the internal symbols read from an a.out file. */
3161
3162 static bfd_boolean
aout_link_free_symbols(bfd * abfd)3163 aout_link_free_symbols (bfd *abfd)
3164 {
3165 if (obj_aout_external_syms (abfd) != NULL)
3166 {
3167 #ifdef USE_MMAP
3168 bfd_free_window (&obj_aout_sym_window (abfd));
3169 #else
3170 free ((void *) obj_aout_external_syms (abfd));
3171 #endif
3172 obj_aout_external_syms (abfd) = NULL;
3173 }
3174 if (obj_aout_external_strings (abfd) != NULL)
3175 {
3176 #ifdef USE_MMAP
3177 bfd_free_window (&obj_aout_string_window (abfd));
3178 #else
3179 free ((void *) obj_aout_external_strings (abfd));
3180 #endif
3181 obj_aout_external_strings (abfd) = NULL;
3182 }
3183 return TRUE;
3184 }
3185
3186 /* Add symbols from an a.out object file. */
3187
3188 static bfd_boolean
aout_link_add_object_symbols(bfd * abfd,struct bfd_link_info * info)3189 aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3190 {
3191 if (! aout_get_external_symbols (abfd))
3192 return FALSE;
3193 if (! aout_link_add_symbols (abfd, info))
3194 return FALSE;
3195 if (! info->keep_memory)
3196 {
3197 if (! aout_link_free_symbols (abfd))
3198 return FALSE;
3199 }
3200 return TRUE;
3201 }
3202
3203 /* Look through the internal symbols to see if this object file should
3204 be included in the link. We should include this object file if it
3205 defines any symbols which are currently undefined. If this object
3206 file defines a common symbol, then we may adjust the size of the
3207 known symbol but we do not include the object file in the link
3208 (unless there is some other reason to include it). */
3209
3210 static bfd_boolean
aout_link_check_ar_symbols(bfd * abfd,struct bfd_link_info * info,bfd_boolean * pneeded,bfd ** subsbfd)3211 aout_link_check_ar_symbols (bfd *abfd,
3212 struct bfd_link_info *info,
3213 bfd_boolean *pneeded,
3214 bfd **subsbfd)
3215 {
3216 struct external_nlist *p;
3217 struct external_nlist *pend;
3218 char *strings;
3219
3220 *pneeded = FALSE;
3221
3222 /* Look through all the symbols. */
3223 p = obj_aout_external_syms (abfd);
3224 pend = p + obj_aout_external_sym_count (abfd);
3225 strings = obj_aout_external_strings (abfd);
3226 for (; p < pend; p++)
3227 {
3228 int type = H_GET_8 (abfd, p->e_type);
3229 const char *name;
3230 struct bfd_link_hash_entry *h;
3231
3232 /* Ignore symbols that are not externally visible. This is an
3233 optimization only, as we check the type more thoroughly
3234 below. */
3235 if (((type & N_EXT) == 0
3236 || (type & N_STAB) != 0
3237 || type == N_FN)
3238 && type != N_WEAKA
3239 && type != N_WEAKT
3240 && type != N_WEAKD
3241 && type != N_WEAKB)
3242 {
3243 if (type == N_WARNING
3244 || type == N_INDR)
3245 ++p;
3246 continue;
3247 }
3248
3249 name = strings + GET_WORD (abfd, p->e_strx);
3250 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3251
3252 /* We are only interested in symbols that are currently
3253 undefined or common. */
3254 if (h == NULL
3255 || (h->type != bfd_link_hash_undefined
3256 && h->type != bfd_link_hash_common))
3257 {
3258 if (type == (N_INDR | N_EXT))
3259 ++p;
3260 continue;
3261 }
3262
3263 if (type == (N_TEXT | N_EXT)
3264 || type == (N_DATA | N_EXT)
3265 || type == (N_BSS | N_EXT)
3266 || type == (N_ABS | N_EXT)
3267 || type == (N_INDR | N_EXT))
3268 {
3269 /* This object file defines this symbol. We must link it
3270 in. This is true regardless of whether the current
3271 definition of the symbol is undefined or common.
3272
3273 If the current definition is common, we have a case in
3274 which we have already seen an object file including:
3275 int a;
3276 and this object file from the archive includes:
3277 int a = 5;
3278 In such a case, whether to include this object is target
3279 dependant for backward compatibility.
3280
3281 FIXME: The SunOS 4.1.3 linker will pull in the archive
3282 element if the symbol is defined in the .data section,
3283 but not if it is defined in the .text section. That
3284 seems a bit crazy to me, and it has not been implemented
3285 yet. However, it might be correct. */
3286 if (h->type == bfd_link_hash_common)
3287 {
3288 int skip = 0;
3289
3290 switch (info->common_skip_ar_symbols)
3291 {
3292 case bfd_link_common_skip_text:
3293 skip = (type == (N_TEXT | N_EXT));
3294 break;
3295 case bfd_link_common_skip_data:
3296 skip = (type == (N_DATA | N_EXT));
3297 break;
3298 default:
3299 case bfd_link_common_skip_all:
3300 skip = 1;
3301 break;
3302 }
3303
3304 if (skip)
3305 continue;
3306 }
3307
3308 if (!(*info->callbacks
3309 ->add_archive_element) (info, abfd, name, subsbfd))
3310 return FALSE;
3311 *pneeded = TRUE;
3312 return TRUE;
3313 }
3314
3315 if (type == (N_UNDF | N_EXT))
3316 {
3317 bfd_vma value;
3318
3319 value = GET_WORD (abfd, p->e_value);
3320 if (value != 0)
3321 {
3322 /* This symbol is common in the object from the archive
3323 file. */
3324 if (h->type == bfd_link_hash_undefined)
3325 {
3326 bfd *symbfd;
3327 unsigned int power;
3328
3329 symbfd = h->u.undef.abfd;
3330 if (symbfd == NULL)
3331 {
3332 /* This symbol was created as undefined from
3333 outside BFD. We assume that we should link
3334 in the object file. This is done for the -u
3335 option in the linker. */
3336 if (!(*info->callbacks
3337 ->add_archive_element) (info, abfd, name, subsbfd))
3338 return FALSE;
3339 *pneeded = TRUE;
3340 return TRUE;
3341 }
3342 /* Turn the current link symbol into a common
3343 symbol. It is already on the undefs list. */
3344 h->type = bfd_link_hash_common;
3345 h->u.c.p = (struct bfd_link_hash_common_entry *)
3346 bfd_hash_allocate (&info->hash->table,
3347 sizeof (struct bfd_link_hash_common_entry));
3348 if (h->u.c.p == NULL)
3349 return FALSE;
3350
3351 h->u.c.size = value;
3352
3353 /* FIXME: This isn't quite right. The maximum
3354 alignment of a common symbol should be set by the
3355 architecture of the output file, not of the input
3356 file. */
3357 power = bfd_log2 (value);
3358 if (power > bfd_get_arch_info (abfd)->section_align_power)
3359 power = bfd_get_arch_info (abfd)->section_align_power;
3360 h->u.c.p->alignment_power = power;
3361
3362 h->u.c.p->section = bfd_make_section_old_way (symbfd,
3363 "COMMON");
3364 }
3365 else
3366 {
3367 /* Adjust the size of the common symbol if
3368 necessary. */
3369 if (value > h->u.c.size)
3370 h->u.c.size = value;
3371 }
3372 }
3373 }
3374
3375 if (type == N_WEAKA
3376 || type == N_WEAKT
3377 || type == N_WEAKD
3378 || type == N_WEAKB)
3379 {
3380 /* This symbol is weak but defined. We must pull it in if
3381 the current link symbol is undefined, but we don't want
3382 it if the current link symbol is common. */
3383 if (h->type == bfd_link_hash_undefined)
3384 {
3385 if (!(*info->callbacks
3386 ->add_archive_element) (info, abfd, name, subsbfd))
3387 return FALSE;
3388 *pneeded = TRUE;
3389 return TRUE;
3390 }
3391 }
3392 }
3393
3394 /* We do not need this object file. */
3395 return TRUE;
3396 }
3397 /* Check a single archive element to see if we need to include it in
3398 the link. *PNEEDED is set according to whether this element is
3399 needed in the link or not. This is called from
3400 _bfd_generic_link_add_archive_symbols. */
3401
3402 static bfd_boolean
aout_link_check_archive_element(bfd * abfd,struct bfd_link_info * info,bfd_boolean * pneeded)3403 aout_link_check_archive_element (bfd *abfd,
3404 struct bfd_link_info *info,
3405 bfd_boolean *pneeded)
3406 {
3407 bfd *oldbfd;
3408 bfd_boolean needed;
3409
3410 if (!aout_get_external_symbols (abfd))
3411 return FALSE;
3412
3413 oldbfd = abfd;
3414 if (!aout_link_check_ar_symbols (abfd, info, pneeded, &abfd))
3415 return FALSE;
3416
3417 needed = *pneeded;
3418 if (needed)
3419 {
3420 /* Potentially, the add_archive_element hook may have set a
3421 substitute BFD for us. */
3422 if (abfd != oldbfd)
3423 {
3424 if (!info->keep_memory
3425 && !aout_link_free_symbols (oldbfd))
3426 return FALSE;
3427 if (!aout_get_external_symbols (abfd))
3428 return FALSE;
3429 }
3430 if (!aout_link_add_symbols (abfd, info))
3431 return FALSE;
3432 }
3433
3434 if (!info->keep_memory || !needed)
3435 {
3436 if (!aout_link_free_symbols (abfd))
3437 return FALSE;
3438 }
3439
3440 return TRUE;
3441 }
3442
3443 /* Given an a.out BFD, add symbols to the global hash table as
3444 appropriate. */
3445
3446 bfd_boolean
NAME(aout,link_add_symbols)3447 NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
3448 {
3449 switch (bfd_get_format (abfd))
3450 {
3451 case bfd_object:
3452 return aout_link_add_object_symbols (abfd, info);
3453 case bfd_archive:
3454 return _bfd_generic_link_add_archive_symbols
3455 (abfd, info, aout_link_check_archive_element);
3456 default:
3457 bfd_set_error (bfd_error_wrong_format);
3458 return FALSE;
3459 }
3460 }
3461
3462 /* A hash table used for header files with N_BINCL entries. */
3463
3464 struct aout_link_includes_table
3465 {
3466 struct bfd_hash_table root;
3467 };
3468
3469 /* A linked list of totals that we have found for a particular header
3470 file. */
3471
3472 struct aout_link_includes_totals
3473 {
3474 struct aout_link_includes_totals *next;
3475 bfd_vma total;
3476 };
3477
3478 /* An entry in the header file hash table. */
3479
3480 struct aout_link_includes_entry
3481 {
3482 struct bfd_hash_entry root;
3483 /* List of totals we have found for this file. */
3484 struct aout_link_includes_totals *totals;
3485 };
3486
3487 /* Look up an entry in an the header file hash table. */
3488
3489 #define aout_link_includes_lookup(table, string, create, copy) \
3490 ((struct aout_link_includes_entry *) \
3491 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3492
3493 /* During the final link step we need to pass around a bunch of
3494 information, so we do it in an instance of this structure. */
3495
3496 struct aout_final_link_info
3497 {
3498 /* General link information. */
3499 struct bfd_link_info *info;
3500 /* Output bfd. */
3501 bfd *output_bfd;
3502 /* Reloc file positions. */
3503 file_ptr treloff, dreloff;
3504 /* File position of symbols. */
3505 file_ptr symoff;
3506 /* String table. */
3507 struct bfd_strtab_hash *strtab;
3508 /* Header file hash table. */
3509 struct aout_link_includes_table includes;
3510 /* A buffer large enough to hold the contents of any section. */
3511 bfd_byte *contents;
3512 /* A buffer large enough to hold the relocs of any section. */
3513 void * relocs;
3514 /* A buffer large enough to hold the symbol map of any input BFD. */
3515 int *symbol_map;
3516 /* A buffer large enough to hold output symbols of any input BFD. */
3517 struct external_nlist *output_syms;
3518 };
3519
3520 /* The function to create a new entry in the header file hash table. */
3521
3522 static struct bfd_hash_entry *
aout_link_includes_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)3523 aout_link_includes_newfunc (struct bfd_hash_entry *entry,
3524 struct bfd_hash_table *table,
3525 const char *string)
3526 {
3527 struct aout_link_includes_entry *ret =
3528 (struct aout_link_includes_entry *) entry;
3529
3530 /* Allocate the structure if it has not already been allocated by a
3531 subclass. */
3532 if (ret == NULL)
3533 ret = (struct aout_link_includes_entry *)
3534 bfd_hash_allocate (table, sizeof (* ret));
3535 if (ret == NULL)
3536 return NULL;
3537
3538 /* Call the allocation method of the superclass. */
3539 ret = ((struct aout_link_includes_entry *)
3540 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3541 if (ret)
3542 {
3543 /* Set local fields. */
3544 ret->totals = NULL;
3545 }
3546
3547 return (struct bfd_hash_entry *) ret;
3548 }
3549
3550 /* Write out a symbol that was not associated with an a.out input
3551 object. */
3552
3553 static bfd_boolean
aout_link_write_other_symbol(struct bfd_hash_entry * bh,void * data)3554 aout_link_write_other_symbol (struct bfd_hash_entry *bh, void *data)
3555 {
3556 struct aout_link_hash_entry *h = (struct aout_link_hash_entry *) bh;
3557 struct aout_final_link_info *flaginfo = (struct aout_final_link_info *) data;
3558 bfd *output_bfd;
3559 int type;
3560 bfd_vma val;
3561 struct external_nlist outsym;
3562 bfd_size_type indx;
3563 bfd_size_type amt;
3564
3565 if (h->root.type == bfd_link_hash_warning)
3566 {
3567 h = (struct aout_link_hash_entry *) h->root.u.i.link;
3568 if (h->root.type == bfd_link_hash_new)
3569 return TRUE;
3570 }
3571
3572 output_bfd = flaginfo->output_bfd;
3573
3574 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
3575 {
3576 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
3577 (output_bfd, flaginfo->info, h)))
3578 {
3579 /* FIXME: No way to handle errors. */
3580 abort ();
3581 }
3582 }
3583
3584 if (h->written)
3585 return TRUE;
3586
3587 h->written = TRUE;
3588
3589 /* An indx of -2 means the symbol must be written. */
3590 if (h->indx != -2
3591 && (flaginfo->info->strip == strip_all
3592 || (flaginfo->info->strip == strip_some
3593 && bfd_hash_lookup (flaginfo->info->keep_hash, h->root.root.string,
3594 FALSE, FALSE) == NULL)))
3595 return TRUE;
3596
3597 switch (h->root.type)
3598 {
3599 default:
3600 case bfd_link_hash_warning:
3601 abort ();
3602 /* Avoid variable not initialized warnings. */
3603 return TRUE;
3604 case bfd_link_hash_new:
3605 /* This can happen for set symbols when sets are not being
3606 built. */
3607 return TRUE;
3608 case bfd_link_hash_undefined:
3609 type = N_UNDF | N_EXT;
3610 val = 0;
3611 break;
3612 case bfd_link_hash_defined:
3613 case bfd_link_hash_defweak:
3614 {
3615 asection *sec;
3616
3617 sec = h->root.u.def.section->output_section;
3618 BFD_ASSERT (bfd_is_abs_section (sec)
3619 || sec->owner == output_bfd);
3620 if (sec == obj_textsec (output_bfd))
3621 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
3622 else if (sec == obj_datasec (output_bfd))
3623 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
3624 else if (sec == obj_bsssec (output_bfd))
3625 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
3626 else
3627 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
3628 type |= N_EXT;
3629 val = (h->root.u.def.value
3630 + sec->vma
3631 + h->root.u.def.section->output_offset);
3632 }
3633 break;
3634 case bfd_link_hash_common:
3635 type = N_UNDF | N_EXT;
3636 val = h->root.u.c.size;
3637 break;
3638 case bfd_link_hash_undefweak:
3639 type = N_WEAKU;
3640 val = 0;
3641 break;
3642 case bfd_link_hash_indirect:
3643 /* We ignore these symbols, since the indirected symbol is
3644 already in the hash table. */
3645 return TRUE;
3646 }
3647
3648 H_PUT_8 (output_bfd, type, outsym.e_type);
3649 H_PUT_8 (output_bfd, 0, outsym.e_other);
3650 H_PUT_16 (output_bfd, 0, outsym.e_desc);
3651 indx = add_to_stringtab (output_bfd, flaginfo->strtab, h->root.root.string,
3652 FALSE);
3653 if (indx == - (bfd_size_type) 1)
3654 /* FIXME: No way to handle errors. */
3655 abort ();
3656
3657 PUT_WORD (output_bfd, indx, outsym.e_strx);
3658 PUT_WORD (output_bfd, val, outsym.e_value);
3659
3660 amt = EXTERNAL_NLIST_SIZE;
3661 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0
3662 || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
3663 /* FIXME: No way to handle errors. */
3664 abort ();
3665
3666 flaginfo->symoff += EXTERNAL_NLIST_SIZE;
3667 h->indx = obj_aout_external_sym_count (output_bfd);
3668 ++obj_aout_external_sym_count (output_bfd);
3669
3670 return TRUE;
3671 }
3672
3673 /* Handle a link order which is supposed to generate a reloc. */
3674
3675 static bfd_boolean
aout_link_reloc_link_order(struct aout_final_link_info * flaginfo,asection * o,struct bfd_link_order * p)3676 aout_link_reloc_link_order (struct aout_final_link_info *flaginfo,
3677 asection *o,
3678 struct bfd_link_order *p)
3679 {
3680 struct bfd_link_order_reloc *pr;
3681 int r_index;
3682 int r_extern;
3683 reloc_howto_type *howto;
3684 file_ptr *reloff_ptr = NULL;
3685 struct reloc_std_external srel;
3686 struct reloc_ext_external erel;
3687 void * rel_ptr;
3688 bfd_size_type amt;
3689
3690 pr = p->u.reloc.p;
3691
3692 if (p->type == bfd_section_reloc_link_order)
3693 {
3694 r_extern = 0;
3695 if (bfd_is_abs_section (pr->u.section))
3696 r_index = N_ABS | N_EXT;
3697 else
3698 {
3699 BFD_ASSERT (pr->u.section->owner == flaginfo->output_bfd);
3700 r_index = pr->u.section->target_index;
3701 }
3702 }
3703 else
3704 {
3705 struct aout_link_hash_entry *h;
3706
3707 BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3708 r_extern = 1;
3709 h = ((struct aout_link_hash_entry *)
3710 bfd_wrapped_link_hash_lookup (flaginfo->output_bfd, flaginfo->info,
3711 pr->u.name, FALSE, FALSE, TRUE));
3712 if (h != NULL
3713 && h->indx >= 0)
3714 r_index = h->indx;
3715 else if (h != NULL)
3716 {
3717 /* We decided to strip this symbol, but it turns out that we
3718 can't. Note that we lose the other and desc information
3719 here. I don't think that will ever matter for a global
3720 symbol. */
3721 h->indx = -2;
3722 h->written = FALSE;
3723 if (!aout_link_write_other_symbol (&h->root.root, flaginfo))
3724 return FALSE;
3725 r_index = h->indx;
3726 }
3727 else
3728 {
3729 if (! ((*flaginfo->info->callbacks->unattached_reloc)
3730 (flaginfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
3731 return FALSE;
3732 r_index = 0;
3733 }
3734 }
3735
3736 howto = bfd_reloc_type_lookup (flaginfo->output_bfd, pr->reloc);
3737 if (howto == 0)
3738 {
3739 bfd_set_error (bfd_error_bad_value);
3740 return FALSE;
3741 }
3742
3743 if (o == obj_textsec (flaginfo->output_bfd))
3744 reloff_ptr = &flaginfo->treloff;
3745 else if (o == obj_datasec (flaginfo->output_bfd))
3746 reloff_ptr = &flaginfo->dreloff;
3747 else
3748 abort ();
3749
3750 if (obj_reloc_entry_size (flaginfo->output_bfd) == RELOC_STD_SIZE)
3751 {
3752 #ifdef MY_put_reloc
3753 MY_put_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset, howto,
3754 &srel);
3755 #else
3756 {
3757 int r_pcrel;
3758 int r_baserel;
3759 int r_jmptable;
3760 int r_relative;
3761 int r_length;
3762
3763 r_pcrel = (int) howto->pc_relative;
3764 r_baserel = (howto->type & 8) != 0;
3765 r_jmptable = (howto->type & 16) != 0;
3766 r_relative = (howto->type & 32) != 0;
3767 r_length = howto->size;
3768
3769 PUT_WORD (flaginfo->output_bfd, p->offset, srel.r_address);
3770 if (bfd_header_big_endian (flaginfo->output_bfd))
3771 {
3772 srel.r_index[0] = r_index >> 16;
3773 srel.r_index[1] = r_index >> 8;
3774 srel.r_index[2] = r_index;
3775 srel.r_type[0] =
3776 ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
3777 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
3778 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
3779 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3780 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3781 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
3782 }
3783 else
3784 {
3785 srel.r_index[2] = r_index >> 16;
3786 srel.r_index[1] = r_index >> 8;
3787 srel.r_index[0] = r_index;
3788 srel.r_type[0] =
3789 ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
3790 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
3791 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
3792 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3793 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3794 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
3795 }
3796 }
3797 #endif
3798 rel_ptr = (void *) &srel;
3799
3800 /* We have to write the addend into the object file, since
3801 standard a.out relocs are in place. It would be more
3802 reliable if we had the current contents of the file here,
3803 rather than assuming zeroes, but we can't read the file since
3804 it was opened using bfd_openw. */
3805 if (pr->addend != 0)
3806 {
3807 bfd_size_type size;
3808 bfd_reloc_status_type r;
3809 bfd_byte *buf;
3810 bfd_boolean ok;
3811
3812 size = bfd_get_reloc_size (howto);
3813 buf = (bfd_byte *) bfd_zmalloc (size);
3814 if (buf == NULL)
3815 return FALSE;
3816 r = MY_relocate_contents (howto, flaginfo->output_bfd,
3817 (bfd_vma) pr->addend, buf);
3818 switch (r)
3819 {
3820 case bfd_reloc_ok:
3821 break;
3822 default:
3823 case bfd_reloc_outofrange:
3824 abort ();
3825 case bfd_reloc_overflow:
3826 if (! ((*flaginfo->info->callbacks->reloc_overflow)
3827 (flaginfo->info, NULL,
3828 (p->type == bfd_section_reloc_link_order
3829 ? bfd_section_name (flaginfo->output_bfd,
3830 pr->u.section)
3831 : pr->u.name),
3832 howto->name, pr->addend, NULL, NULL, (bfd_vma) 0)))
3833 {
3834 free (buf);
3835 return FALSE;
3836 }
3837 break;
3838 }
3839 ok = bfd_set_section_contents (flaginfo->output_bfd, o, (void *) buf,
3840 (file_ptr) p->offset, size);
3841 free (buf);
3842 if (! ok)
3843 return FALSE;
3844 }
3845 }
3846 else
3847 {
3848 #ifdef MY_put_ext_reloc
3849 MY_put_ext_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset,
3850 howto, &erel, pr->addend);
3851 #else
3852 PUT_WORD (flaginfo->output_bfd, p->offset, erel.r_address);
3853
3854 if (bfd_header_big_endian (flaginfo->output_bfd))
3855 {
3856 erel.r_index[0] = r_index >> 16;
3857 erel.r_index[1] = r_index >> 8;
3858 erel.r_index[2] = r_index;
3859 erel.r_type[0] =
3860 ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
3861 | (howto->type << RELOC_EXT_BITS_TYPE_SH_BIG));
3862 }
3863 else
3864 {
3865 erel.r_index[2] = r_index >> 16;
3866 erel.r_index[1] = r_index >> 8;
3867 erel.r_index[0] = r_index;
3868 erel.r_type[0] =
3869 (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
3870 | (howto->type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
3871 }
3872
3873 PUT_WORD (flaginfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
3874 #endif /* MY_put_ext_reloc */
3875
3876 rel_ptr = (void *) &erel;
3877 }
3878
3879 amt = obj_reloc_entry_size (flaginfo->output_bfd);
3880 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3881 || bfd_bwrite (rel_ptr, amt, flaginfo->output_bfd) != amt)
3882 return FALSE;
3883
3884 *reloff_ptr += obj_reloc_entry_size (flaginfo->output_bfd);
3885
3886 /* Assert that the relocs have not run into the symbols, and that n
3887 the text relocs have not run into the data relocs. */
3888 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
3889 && (reloff_ptr != &flaginfo->treloff
3890 || (*reloff_ptr
3891 <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
3892
3893 return TRUE;
3894 }
3895
3896 /* Get the section corresponding to a reloc index. */
3897
3898 static INLINE asection *
aout_reloc_index_to_section(bfd * abfd,int indx)3899 aout_reloc_index_to_section (bfd *abfd, int indx)
3900 {
3901 switch (indx & N_TYPE)
3902 {
3903 case N_TEXT: return obj_textsec (abfd);
3904 case N_DATA: return obj_datasec (abfd);
3905 case N_BSS: return obj_bsssec (abfd);
3906 case N_ABS:
3907 case N_UNDF: return bfd_abs_section_ptr;
3908 default: abort ();
3909 }
3910 return NULL;
3911 }
3912
3913 /* Relocate an a.out section using standard a.out relocs. */
3914
3915 static bfd_boolean
aout_link_input_section_std(struct aout_final_link_info * flaginfo,bfd * input_bfd,asection * input_section,struct reloc_std_external * relocs,bfd_size_type rel_size,bfd_byte * contents)3916 aout_link_input_section_std (struct aout_final_link_info *flaginfo,
3917 bfd *input_bfd,
3918 asection *input_section,
3919 struct reloc_std_external *relocs,
3920 bfd_size_type rel_size,
3921 bfd_byte *contents)
3922 {
3923 bfd_boolean (*check_dynamic_reloc)
3924 (struct bfd_link_info *, bfd *, asection *,
3925 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3926 bfd_vma *);
3927 bfd *output_bfd;
3928 bfd_boolean relocatable;
3929 struct external_nlist *syms;
3930 char *strings;
3931 struct aout_link_hash_entry **sym_hashes;
3932 int *symbol_map;
3933 bfd_size_type reloc_count;
3934 struct reloc_std_external *rel;
3935 struct reloc_std_external *rel_end;
3936
3937 output_bfd = flaginfo->output_bfd;
3938 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
3939
3940 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE);
3941 BFD_ASSERT (input_bfd->xvec->header_byteorder
3942 == output_bfd->xvec->header_byteorder);
3943
3944 relocatable = flaginfo->info->relocatable;
3945 syms = obj_aout_external_syms (input_bfd);
3946 strings = obj_aout_external_strings (input_bfd);
3947 sym_hashes = obj_aout_sym_hashes (input_bfd);
3948 symbol_map = flaginfo->symbol_map;
3949
3950 reloc_count = rel_size / RELOC_STD_SIZE;
3951 rel = relocs;
3952 rel_end = rel + reloc_count;
3953 for (; rel < rel_end; rel++)
3954 {
3955 bfd_vma r_addr;
3956 int r_index;
3957 int r_extern;
3958 int r_pcrel;
3959 int r_baserel = 0;
3960 reloc_howto_type *howto;
3961 struct aout_link_hash_entry *h = NULL;
3962 bfd_vma relocation;
3963 bfd_reloc_status_type r;
3964
3965 r_addr = GET_SWORD (input_bfd, rel->r_address);
3966
3967 #ifdef MY_reloc_howto
3968 howto = MY_reloc_howto (input_bfd, rel, r_index, r_extern, r_pcrel);
3969 #else
3970 {
3971 int r_jmptable;
3972 int r_relative;
3973 int r_length;
3974 unsigned int howto_idx;
3975
3976 if (bfd_header_big_endian (input_bfd))
3977 {
3978 r_index = (((unsigned int) rel->r_index[0] << 16)
3979 | ((unsigned int) rel->r_index[1] << 8)
3980 | rel->r_index[2]);
3981 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
3982 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
3983 r_baserel = (0 != (rel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
3984 r_jmptable= (0 != (rel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
3985 r_relative= (0 != (rel->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
3986 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
3987 >> RELOC_STD_BITS_LENGTH_SH_BIG);
3988 }
3989 else
3990 {
3991 r_index = (((unsigned int) rel->r_index[2] << 16)
3992 | ((unsigned int) rel->r_index[1] << 8)
3993 | rel->r_index[0]);
3994 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
3995 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
3996 r_baserel = (0 != (rel->r_type[0]
3997 & RELOC_STD_BITS_BASEREL_LITTLE));
3998 r_jmptable= (0 != (rel->r_type[0]
3999 & RELOC_STD_BITS_JMPTABLE_LITTLE));
4000 r_relative= (0 != (rel->r_type[0]
4001 & RELOC_STD_BITS_RELATIVE_LITTLE));
4002 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
4003 >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
4004 }
4005
4006 howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
4007 + 16 * r_jmptable + 32 * r_relative);
4008 if (howto_idx < TABLE_SIZE (howto_table_std))
4009 howto = howto_table_std + howto_idx;
4010 else
4011 howto = NULL;
4012 }
4013 #endif
4014
4015 if (howto == NULL)
4016 {
4017 (*flaginfo->info->callbacks->einfo)
4018 (_("%P: %B: unexpected relocation type\n"), input_bfd);
4019 bfd_set_error (bfd_error_bad_value);
4020 return FALSE;
4021 }
4022
4023 if (relocatable)
4024 {
4025 /* We are generating a relocatable output file, and must
4026 modify the reloc accordingly. */
4027 if (r_extern)
4028 {
4029 /* If we know the symbol this relocation is against,
4030 convert it into a relocation against a section. This
4031 is what the native linker does. */
4032 h = sym_hashes[r_index];
4033 if (h != NULL
4034 && (h->root.type == bfd_link_hash_defined
4035 || h->root.type == bfd_link_hash_defweak))
4036 {
4037 asection *output_section;
4038
4039 /* Change the r_extern value. */
4040 if (bfd_header_big_endian (output_bfd))
4041 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_BIG;
4042 else
4043 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE;
4044
4045 /* Compute a new r_index. */
4046 output_section = h->root.u.def.section->output_section;
4047 if (output_section == obj_textsec (output_bfd))
4048 r_index = N_TEXT;
4049 else if (output_section == obj_datasec (output_bfd))
4050 r_index = N_DATA;
4051 else if (output_section == obj_bsssec (output_bfd))
4052 r_index = N_BSS;
4053 else
4054 r_index = N_ABS;
4055
4056 /* Add the symbol value and the section VMA to the
4057 addend stored in the contents. */
4058 relocation = (h->root.u.def.value
4059 + output_section->vma
4060 + h->root.u.def.section->output_offset);
4061 }
4062 else
4063 {
4064 /* We must change r_index according to the symbol
4065 map. */
4066 r_index = symbol_map[r_index];
4067
4068 if (r_index == -1)
4069 {
4070 if (h != NULL)
4071 {
4072 /* We decided to strip this symbol, but it
4073 turns out that we can't. Note that we
4074 lose the other and desc information here.
4075 I don't think that will ever matter for a
4076 global symbol. */
4077 if (h->indx < 0)
4078 {
4079 h->indx = -2;
4080 h->written = FALSE;
4081 if (!aout_link_write_other_symbol (&h->root.root,
4082 flaginfo))
4083 return FALSE;
4084 }
4085 r_index = h->indx;
4086 }
4087 else
4088 {
4089 const char *name;
4090
4091 name = strings + GET_WORD (input_bfd,
4092 syms[r_index].e_strx);
4093 if (! ((*flaginfo->info->callbacks->unattached_reloc)
4094 (flaginfo->info, name, input_bfd, input_section,
4095 r_addr)))
4096 return FALSE;
4097 r_index = 0;
4098 }
4099 }
4100
4101 relocation = 0;
4102 }
4103
4104 /* Write out the new r_index value. */
4105 if (bfd_header_big_endian (output_bfd))
4106 {
4107 rel->r_index[0] = r_index >> 16;
4108 rel->r_index[1] = r_index >> 8;
4109 rel->r_index[2] = r_index;
4110 }
4111 else
4112 {
4113 rel->r_index[2] = r_index >> 16;
4114 rel->r_index[1] = r_index >> 8;
4115 rel->r_index[0] = r_index;
4116 }
4117 }
4118 else
4119 {
4120 asection *section;
4121
4122 /* This is a relocation against a section. We must
4123 adjust by the amount that the section moved. */
4124 section = aout_reloc_index_to_section (input_bfd, r_index);
4125 relocation = (section->output_section->vma
4126 + section->output_offset
4127 - section->vma);
4128 }
4129
4130 /* Change the address of the relocation. */
4131 PUT_WORD (output_bfd,
4132 r_addr + input_section->output_offset,
4133 rel->r_address);
4134
4135 /* Adjust a PC relative relocation by removing the reference
4136 to the original address in the section and including the
4137 reference to the new address. */
4138 if (r_pcrel)
4139 relocation -= (input_section->output_section->vma
4140 + input_section->output_offset
4141 - input_section->vma);
4142
4143 #ifdef MY_relocatable_reloc
4144 MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
4145 #endif
4146
4147 if (relocation == 0)
4148 r = bfd_reloc_ok;
4149 else
4150 r = MY_relocate_contents (howto,
4151 input_bfd, relocation,
4152 contents + r_addr);
4153 }
4154 else
4155 {
4156 bfd_boolean hundef;
4157
4158 /* We are generating an executable, and must do a full
4159 relocation. */
4160 hundef = FALSE;
4161
4162 if (r_extern)
4163 {
4164 h = sym_hashes[r_index];
4165
4166 if (h != NULL
4167 && (h->root.type == bfd_link_hash_defined
4168 || h->root.type == bfd_link_hash_defweak))
4169 {
4170 relocation = (h->root.u.def.value
4171 + h->root.u.def.section->output_section->vma
4172 + h->root.u.def.section->output_offset);
4173 }
4174 else if (h != NULL
4175 && h->root.type == bfd_link_hash_undefweak)
4176 relocation = 0;
4177 else
4178 {
4179 hundef = TRUE;
4180 relocation = 0;
4181 }
4182 }
4183 else
4184 {
4185 asection *section;
4186
4187 section = aout_reloc_index_to_section (input_bfd, r_index);
4188 relocation = (section->output_section->vma
4189 + section->output_offset
4190 - section->vma);
4191 if (r_pcrel)
4192 relocation += input_section->vma;
4193 }
4194
4195 if (check_dynamic_reloc != NULL)
4196 {
4197 bfd_boolean skip;
4198
4199 if (! ((*check_dynamic_reloc)
4200 (flaginfo->info, input_bfd, input_section, h,
4201 (void *) rel, contents, &skip, &relocation)))
4202 return FALSE;
4203 if (skip)
4204 continue;
4205 }
4206
4207 /* Now warn if a global symbol is undefined. We could not
4208 do this earlier, because check_dynamic_reloc might want
4209 to skip this reloc. */
4210 if (hundef && ! flaginfo->info->shared && ! r_baserel)
4211 {
4212 const char *name;
4213
4214 if (h != NULL)
4215 name = h->root.root.string;
4216 else
4217 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4218 if (! ((*flaginfo->info->callbacks->undefined_symbol)
4219 (flaginfo->info, name, input_bfd, input_section,
4220 r_addr, TRUE)))
4221 return FALSE;
4222 }
4223
4224 r = MY_final_link_relocate (howto,
4225 input_bfd, input_section,
4226 contents, r_addr, relocation,
4227 (bfd_vma) 0);
4228 }
4229
4230 if (r != bfd_reloc_ok)
4231 {
4232 switch (r)
4233 {
4234 default:
4235 case bfd_reloc_outofrange:
4236 abort ();
4237 case bfd_reloc_overflow:
4238 {
4239 const char *name;
4240
4241 if (h != NULL)
4242 name = NULL;
4243 else if (r_extern)
4244 name = strings + GET_WORD (input_bfd,
4245 syms[r_index].e_strx);
4246 else
4247 {
4248 asection *s;
4249
4250 s = aout_reloc_index_to_section (input_bfd, r_index);
4251 name = bfd_section_name (input_bfd, s);
4252 }
4253 if (! ((*flaginfo->info->callbacks->reloc_overflow)
4254 (flaginfo->info, (h ? &h->root : NULL), name,
4255 howto->name, (bfd_vma) 0, input_bfd,
4256 input_section, r_addr)))
4257 return FALSE;
4258 }
4259 break;
4260 }
4261 }
4262 }
4263
4264 return TRUE;
4265 }
4266
4267 /* Relocate an a.out section using extended a.out relocs. */
4268
4269 static bfd_boolean
aout_link_input_section_ext(struct aout_final_link_info * flaginfo,bfd * input_bfd,asection * input_section,struct reloc_ext_external * relocs,bfd_size_type rel_size,bfd_byte * contents)4270 aout_link_input_section_ext (struct aout_final_link_info *flaginfo,
4271 bfd *input_bfd,
4272 asection *input_section,
4273 struct reloc_ext_external *relocs,
4274 bfd_size_type rel_size,
4275 bfd_byte *contents)
4276 {
4277 bfd_boolean (*check_dynamic_reloc)
4278 (struct bfd_link_info *, bfd *, asection *,
4279 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
4280 bfd_vma *);
4281 bfd *output_bfd;
4282 bfd_boolean relocatable;
4283 struct external_nlist *syms;
4284 char *strings;
4285 struct aout_link_hash_entry **sym_hashes;
4286 int *symbol_map;
4287 bfd_size_type reloc_count;
4288 struct reloc_ext_external *rel;
4289 struct reloc_ext_external *rel_end;
4290
4291 output_bfd = flaginfo->output_bfd;
4292 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
4293
4294 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_EXT_SIZE);
4295 BFD_ASSERT (input_bfd->xvec->header_byteorder
4296 == output_bfd->xvec->header_byteorder);
4297
4298 relocatable = flaginfo->info->relocatable;
4299 syms = obj_aout_external_syms (input_bfd);
4300 strings = obj_aout_external_strings (input_bfd);
4301 sym_hashes = obj_aout_sym_hashes (input_bfd);
4302 symbol_map = flaginfo->symbol_map;
4303
4304 reloc_count = rel_size / RELOC_EXT_SIZE;
4305 rel = relocs;
4306 rel_end = rel + reloc_count;
4307 for (; rel < rel_end; rel++)
4308 {
4309 bfd_vma r_addr;
4310 int r_index;
4311 int r_extern;
4312 unsigned int r_type;
4313 bfd_vma r_addend;
4314 struct aout_link_hash_entry *h = NULL;
4315 asection *r_section = NULL;
4316 bfd_vma relocation;
4317
4318 r_addr = GET_SWORD (input_bfd, rel->r_address);
4319
4320 if (bfd_header_big_endian (input_bfd))
4321 {
4322 r_index = (((unsigned int) rel->r_index[0] << 16)
4323 | ((unsigned int) rel->r_index[1] << 8)
4324 | rel->r_index[2]);
4325 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
4326 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
4327 >> RELOC_EXT_BITS_TYPE_SH_BIG);
4328 }
4329 else
4330 {
4331 r_index = (((unsigned int) rel->r_index[2] << 16)
4332 | ((unsigned int) rel->r_index[1] << 8)
4333 | rel->r_index[0]);
4334 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
4335 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
4336 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
4337 }
4338
4339 r_addend = GET_SWORD (input_bfd, rel->r_addend);
4340
4341 if (r_type >= TABLE_SIZE (howto_table_ext))
4342 {
4343 (*flaginfo->info->callbacks->einfo)
4344 (_("%P: %B: unexpected relocation type\n"), input_bfd);
4345 bfd_set_error (bfd_error_bad_value);
4346 return FALSE;
4347 }
4348
4349 if (relocatable)
4350 {
4351 /* We are generating a relocatable output file, and must
4352 modify the reloc accordingly. */
4353 if (r_extern
4354 || r_type == (unsigned int) RELOC_BASE10
4355 || r_type == (unsigned int) RELOC_BASE13
4356 || r_type == (unsigned int) RELOC_BASE22)
4357 {
4358 /* If we know the symbol this relocation is against,
4359 convert it into a relocation against a section. This
4360 is what the native linker does. */
4361 if (r_type == (unsigned int) RELOC_BASE10
4362 || r_type == (unsigned int) RELOC_BASE13
4363 || r_type == (unsigned int) RELOC_BASE22)
4364 h = NULL;
4365 else
4366 h = sym_hashes[r_index];
4367 if (h != NULL
4368 && (h->root.type == bfd_link_hash_defined
4369 || h->root.type == bfd_link_hash_defweak))
4370 {
4371 asection *output_section;
4372
4373 /* Change the r_extern value. */
4374 if (bfd_header_big_endian (output_bfd))
4375 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_BIG;
4376 else
4377 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE;
4378
4379 /* Compute a new r_index. */
4380 output_section = h->root.u.def.section->output_section;
4381 if (output_section == obj_textsec (output_bfd))
4382 r_index = N_TEXT;
4383 else if (output_section == obj_datasec (output_bfd))
4384 r_index = N_DATA;
4385 else if (output_section == obj_bsssec (output_bfd))
4386 r_index = N_BSS;
4387 else
4388 r_index = N_ABS;
4389
4390 /* Add the symbol value and the section VMA to the
4391 addend. */
4392 relocation = (h->root.u.def.value
4393 + output_section->vma
4394 + h->root.u.def.section->output_offset);
4395
4396 /* Now RELOCATION is the VMA of the final
4397 destination. If this is a PC relative reloc,
4398 then ADDEND is the negative of the source VMA.
4399 We want to set ADDEND to the difference between
4400 the destination VMA and the source VMA, which
4401 means we must adjust RELOCATION by the change in
4402 the source VMA. This is done below. */
4403 }
4404 else
4405 {
4406 /* We must change r_index according to the symbol
4407 map. */
4408 r_index = symbol_map[r_index];
4409
4410 if (r_index == -1)
4411 {
4412 if (h != NULL)
4413 {
4414 /* We decided to strip this symbol, but it
4415 turns out that we can't. Note that we
4416 lose the other and desc information here.
4417 I don't think that will ever matter for a
4418 global symbol. */
4419 if (h->indx < 0)
4420 {
4421 h->indx = -2;
4422 h->written = FALSE;
4423 if (!aout_link_write_other_symbol (&h->root.root,
4424 flaginfo))
4425 return FALSE;
4426 }
4427 r_index = h->indx;
4428 }
4429 else
4430 {
4431 const char *name;
4432
4433 name = strings + GET_WORD (input_bfd,
4434 syms[r_index].e_strx);
4435 if (! ((*flaginfo->info->callbacks->unattached_reloc)
4436 (flaginfo->info, name, input_bfd, input_section,
4437 r_addr)))
4438 return FALSE;
4439 r_index = 0;
4440 }
4441 }
4442
4443 relocation = 0;
4444
4445 /* If this is a PC relative reloc, then the addend
4446 is the negative of the source VMA. We must
4447 adjust it by the change in the source VMA. This
4448 is done below. */
4449 }
4450
4451 /* Write out the new r_index value. */
4452 if (bfd_header_big_endian (output_bfd))
4453 {
4454 rel->r_index[0] = r_index >> 16;
4455 rel->r_index[1] = r_index >> 8;
4456 rel->r_index[2] = r_index;
4457 }
4458 else
4459 {
4460 rel->r_index[2] = r_index >> 16;
4461 rel->r_index[1] = r_index >> 8;
4462 rel->r_index[0] = r_index;
4463 }
4464 }
4465 else
4466 {
4467 /* This is a relocation against a section. We must
4468 adjust by the amount that the section moved. */
4469 r_section = aout_reloc_index_to_section (input_bfd, r_index);
4470 relocation = (r_section->output_section->vma
4471 + r_section->output_offset
4472 - r_section->vma);
4473
4474 /* If this is a PC relative reloc, then the addend is
4475 the difference in VMA between the destination and the
4476 source. We have just adjusted for the change in VMA
4477 of the destination, so we must also adjust by the
4478 change in VMA of the source. This is done below. */
4479 }
4480
4481 /* As described above, we must always adjust a PC relative
4482 reloc by the change in VMA of the source. However, if
4483 pcrel_offset is set, then the addend does not include the
4484 location within the section, in which case we don't need
4485 to adjust anything. */
4486 if (howto_table_ext[r_type].pc_relative
4487 && ! howto_table_ext[r_type].pcrel_offset)
4488 relocation -= (input_section->output_section->vma
4489 + input_section->output_offset
4490 - input_section->vma);
4491
4492 /* Change the addend if necessary. */
4493 if (relocation != 0)
4494 PUT_WORD (output_bfd, r_addend + relocation, rel->r_addend);
4495
4496 /* Change the address of the relocation. */
4497 PUT_WORD (output_bfd,
4498 r_addr + input_section->output_offset,
4499 rel->r_address);
4500 }
4501 else
4502 {
4503 bfd_boolean hundef;
4504 bfd_reloc_status_type r;
4505
4506 /* We are generating an executable, and must do a full
4507 relocation. */
4508 hundef = FALSE;
4509
4510 if (r_extern)
4511 {
4512 h = sym_hashes[r_index];
4513
4514 if (h != NULL
4515 && (h->root.type == bfd_link_hash_defined
4516 || h->root.type == bfd_link_hash_defweak))
4517 {
4518 relocation = (h->root.u.def.value
4519 + h->root.u.def.section->output_section->vma
4520 + h->root.u.def.section->output_offset);
4521 }
4522 else if (h != NULL
4523 && h->root.type == bfd_link_hash_undefweak)
4524 relocation = 0;
4525 else
4526 {
4527 hundef = TRUE;
4528 relocation = 0;
4529 }
4530 }
4531 else if (r_type == (unsigned int) RELOC_BASE10
4532 || r_type == (unsigned int) RELOC_BASE13
4533 || r_type == (unsigned int) RELOC_BASE22)
4534 {
4535 struct external_nlist *sym;
4536 int type;
4537
4538 /* For base relative relocs, r_index is always an index
4539 into the symbol table, even if r_extern is 0. */
4540 sym = syms + r_index;
4541 type = H_GET_8 (input_bfd, sym->e_type);
4542 if ((type & N_TYPE) == N_TEXT
4543 || type == N_WEAKT)
4544 r_section = obj_textsec (input_bfd);
4545 else if ((type & N_TYPE) == N_DATA
4546 || type == N_WEAKD)
4547 r_section = obj_datasec (input_bfd);
4548 else if ((type & N_TYPE) == N_BSS
4549 || type == N_WEAKB)
4550 r_section = obj_bsssec (input_bfd);
4551 else if ((type & N_TYPE) == N_ABS
4552 || type == N_WEAKA)
4553 r_section = bfd_abs_section_ptr;
4554 else
4555 abort ();
4556 relocation = (r_section->output_section->vma
4557 + r_section->output_offset
4558 + (GET_WORD (input_bfd, sym->e_value)
4559 - r_section->vma));
4560 }
4561 else
4562 {
4563 r_section = aout_reloc_index_to_section (input_bfd, r_index);
4564
4565 /* If this is a PC relative reloc, then R_ADDEND is the
4566 difference between the two vmas, or
4567 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4568 where
4569 old_dest_sec == section->vma
4570 and
4571 old_src_sec == input_section->vma
4572 and
4573 old_src_off == r_addr
4574
4575 _bfd_final_link_relocate expects RELOCATION +
4576 R_ADDEND to be the VMA of the destination minus
4577 r_addr (the minus r_addr is because this relocation
4578 is not pcrel_offset, which is a bit confusing and
4579 should, perhaps, be changed), or
4580 new_dest_sec
4581 where
4582 new_dest_sec == output_section->vma + output_offset
4583 We arrange for this to happen by setting RELOCATION to
4584 new_dest_sec + old_src_sec - old_dest_sec
4585
4586 If this is not a PC relative reloc, then R_ADDEND is
4587 simply the VMA of the destination, so we set
4588 RELOCATION to the change in the destination VMA, or
4589 new_dest_sec - old_dest_sec
4590 */
4591 relocation = (r_section->output_section->vma
4592 + r_section->output_offset
4593 - r_section->vma);
4594 if (howto_table_ext[r_type].pc_relative)
4595 relocation += input_section->vma;
4596 }
4597
4598 if (check_dynamic_reloc != NULL)
4599 {
4600 bfd_boolean skip;
4601
4602 if (! ((*check_dynamic_reloc)
4603 (flaginfo->info, input_bfd, input_section, h,
4604 (void *) rel, contents, &skip, &relocation)))
4605 return FALSE;
4606 if (skip)
4607 continue;
4608 }
4609
4610 /* Now warn if a global symbol is undefined. We could not
4611 do this earlier, because check_dynamic_reloc might want
4612 to skip this reloc. */
4613 if (hundef
4614 && ! flaginfo->info->shared
4615 && r_type != (unsigned int) RELOC_BASE10
4616 && r_type != (unsigned int) RELOC_BASE13
4617 && r_type != (unsigned int) RELOC_BASE22)
4618 {
4619 const char *name;
4620
4621 if (h != NULL)
4622 name = h->root.root.string;
4623 else
4624 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4625 if (! ((*flaginfo->info->callbacks->undefined_symbol)
4626 (flaginfo->info, name, input_bfd, input_section,
4627 r_addr, TRUE)))
4628 return FALSE;
4629 }
4630
4631 if (r_type != (unsigned int) RELOC_SPARC_REV32)
4632 r = MY_final_link_relocate (howto_table_ext + r_type,
4633 input_bfd, input_section,
4634 contents, r_addr, relocation,
4635 r_addend);
4636 else
4637 {
4638 bfd_vma x;
4639
4640 x = bfd_get_32 (input_bfd, contents + r_addr);
4641 x = x + relocation + r_addend;
4642 bfd_putl32 (/*input_bfd,*/ x, contents + r_addr);
4643 r = bfd_reloc_ok;
4644 }
4645
4646 if (r != bfd_reloc_ok)
4647 {
4648 switch (r)
4649 {
4650 default:
4651 case bfd_reloc_outofrange:
4652 abort ();
4653 case bfd_reloc_overflow:
4654 {
4655 const char *name;
4656
4657 if (h != NULL)
4658 name = NULL;
4659 else if (r_extern
4660 || r_type == (unsigned int) RELOC_BASE10
4661 || r_type == (unsigned int) RELOC_BASE13
4662 || r_type == (unsigned int) RELOC_BASE22)
4663 name = strings + GET_WORD (input_bfd,
4664 syms[r_index].e_strx);
4665 else
4666 {
4667 asection *s;
4668
4669 s = aout_reloc_index_to_section (input_bfd, r_index);
4670 name = bfd_section_name (input_bfd, s);
4671 }
4672 if (! ((*flaginfo->info->callbacks->reloc_overflow)
4673 (flaginfo->info, (h ? &h->root : NULL), name,
4674 howto_table_ext[r_type].name,
4675 r_addend, input_bfd, input_section, r_addr)))
4676 return FALSE;
4677 }
4678 break;
4679 }
4680 }
4681 }
4682 }
4683
4684 return TRUE;
4685 }
4686
4687 /* Link an a.out section into the output file. */
4688
4689 static bfd_boolean
aout_link_input_section(struct aout_final_link_info * flaginfo,bfd * input_bfd,asection * input_section,file_ptr * reloff_ptr,bfd_size_type rel_size)4690 aout_link_input_section (struct aout_final_link_info *flaginfo,
4691 bfd *input_bfd,
4692 asection *input_section,
4693 file_ptr *reloff_ptr,
4694 bfd_size_type rel_size)
4695 {
4696 bfd_size_type input_size;
4697 void * relocs;
4698
4699 /* Get the section contents. */
4700 input_size = input_section->size;
4701 if (! bfd_get_section_contents (input_bfd, input_section,
4702 (void *) flaginfo->contents,
4703 (file_ptr) 0, input_size))
4704 return FALSE;
4705
4706 /* Read in the relocs if we haven't already done it. */
4707 if (aout_section_data (input_section) != NULL
4708 && aout_section_data (input_section)->relocs != NULL)
4709 relocs = aout_section_data (input_section)->relocs;
4710 else
4711 {
4712 relocs = flaginfo->relocs;
4713 if (rel_size > 0)
4714 {
4715 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4716 || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
4717 return FALSE;
4718 }
4719 }
4720
4721 /* Relocate the section contents. */
4722 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
4723 {
4724 if (! aout_link_input_section_std (flaginfo, input_bfd, input_section,
4725 (struct reloc_std_external *) relocs,
4726 rel_size, flaginfo->contents))
4727 return FALSE;
4728 }
4729 else
4730 {
4731 if (! aout_link_input_section_ext (flaginfo, input_bfd, input_section,
4732 (struct reloc_ext_external *) relocs,
4733 rel_size, flaginfo->contents))
4734 return FALSE;
4735 }
4736
4737 /* Write out the section contents. */
4738 if (! bfd_set_section_contents (flaginfo->output_bfd,
4739 input_section->output_section,
4740 (void *) flaginfo->contents,
4741 (file_ptr) input_section->output_offset,
4742 input_size))
4743 return FALSE;
4744
4745 /* If we are producing relocatable output, the relocs were
4746 modified, and we now write them out. */
4747 if (flaginfo->info->relocatable && rel_size > 0)
4748 {
4749 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
4750 return FALSE;
4751 if (bfd_bwrite (relocs, rel_size, flaginfo->output_bfd) != rel_size)
4752 return FALSE;
4753 *reloff_ptr += rel_size;
4754
4755 /* Assert that the relocs have not run into the symbols, and
4756 that if these are the text relocs they have not run into the
4757 data relocs. */
4758 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
4759 && (reloff_ptr != &flaginfo->treloff
4760 || (*reloff_ptr
4761 <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
4762 }
4763
4764 return TRUE;
4765 }
4766
4767 /* Adjust and write out the symbols for an a.out file. Set the new
4768 symbol indices into a symbol_map. */
4769
4770 static bfd_boolean
aout_link_write_symbols(struct aout_final_link_info * flaginfo,bfd * input_bfd)4771 aout_link_write_symbols (struct aout_final_link_info *flaginfo, bfd *input_bfd)
4772 {
4773 bfd *output_bfd;
4774 bfd_size_type sym_count;
4775 char *strings;
4776 enum bfd_link_strip strip;
4777 enum bfd_link_discard discard;
4778 struct external_nlist *outsym;
4779 bfd_size_type strtab_index;
4780 struct external_nlist *sym;
4781 struct external_nlist *sym_end;
4782 struct aout_link_hash_entry **sym_hash;
4783 int *symbol_map;
4784 bfd_boolean pass;
4785 bfd_boolean skip_next;
4786
4787 output_bfd = flaginfo->output_bfd;
4788 sym_count = obj_aout_external_sym_count (input_bfd);
4789 strings = obj_aout_external_strings (input_bfd);
4790 strip = flaginfo->info->strip;
4791 discard = flaginfo->info->discard;
4792 outsym = flaginfo->output_syms;
4793
4794 /* First write out a symbol for this object file, unless we are
4795 discarding such symbols. */
4796 if (strip != strip_all
4797 && (strip != strip_some
4798 || bfd_hash_lookup (flaginfo->info->keep_hash, input_bfd->filename,
4799 FALSE, FALSE) != NULL)
4800 && discard != discard_all)
4801 {
4802 H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4803 H_PUT_8 (output_bfd, 0, outsym->e_other);
4804 H_PUT_16 (output_bfd, 0, outsym->e_desc);
4805 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
4806 input_bfd->filename, FALSE);
4807 if (strtab_index == (bfd_size_type) -1)
4808 return FALSE;
4809 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4810 PUT_WORD (output_bfd,
4811 (bfd_get_section_vma (output_bfd,
4812 obj_textsec (input_bfd)->output_section)
4813 + obj_textsec (input_bfd)->output_offset),
4814 outsym->e_value);
4815 ++obj_aout_external_sym_count (output_bfd);
4816 ++outsym;
4817 }
4818
4819 pass = FALSE;
4820 skip_next = FALSE;
4821 sym = obj_aout_external_syms (input_bfd);
4822 sym_end = sym + sym_count;
4823 sym_hash = obj_aout_sym_hashes (input_bfd);
4824 symbol_map = flaginfo->symbol_map;
4825 memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4826 for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4827 {
4828 const char *name;
4829 int type;
4830 struct aout_link_hash_entry *h;
4831 bfd_boolean skip;
4832 asection *symsec;
4833 bfd_vma val = 0;
4834 bfd_boolean copy;
4835
4836 /* We set *symbol_map to 0 above for all symbols. If it has
4837 already been set to -1 for this symbol, it means that we are
4838 discarding it because it appears in a duplicate header file.
4839 See the N_BINCL code below. */
4840 if (*symbol_map == -1)
4841 continue;
4842
4843 /* Initialize *symbol_map to -1, which means that the symbol was
4844 not copied into the output file. We will change it later if
4845 we do copy the symbol over. */
4846 *symbol_map = -1;
4847
4848 type = H_GET_8 (input_bfd, sym->e_type);
4849 name = strings + GET_WORD (input_bfd, sym->e_strx);
4850
4851 h = NULL;
4852
4853 if (pass)
4854 {
4855 /* Pass this symbol through. It is the target of an
4856 indirect or warning symbol. */
4857 val = GET_WORD (input_bfd, sym->e_value);
4858 pass = FALSE;
4859 }
4860 else if (skip_next)
4861 {
4862 /* Skip this symbol, which is the target of an indirect
4863 symbol that we have changed to no longer be an indirect
4864 symbol. */
4865 skip_next = FALSE;
4866 continue;
4867 }
4868 else
4869 {
4870 struct aout_link_hash_entry *hresolve;
4871
4872 /* We have saved the hash table entry for this symbol, if
4873 there is one. Note that we could just look it up again
4874 in the hash table, provided we first check that it is an
4875 external symbol. */
4876 h = *sym_hash;
4877
4878 /* Use the name from the hash table, in case the symbol was
4879 wrapped. */
4880 if (h != NULL
4881 && h->root.type != bfd_link_hash_warning)
4882 name = h->root.root.string;
4883
4884 /* If this is an indirect or warning symbol, then change
4885 hresolve to the base symbol. We also change *sym_hash so
4886 that the relocation routines relocate against the real
4887 symbol. */
4888 hresolve = h;
4889 if (h != (struct aout_link_hash_entry *) NULL
4890 && (h->root.type == bfd_link_hash_indirect
4891 || h->root.type == bfd_link_hash_warning))
4892 {
4893 hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4894 while (hresolve->root.type == bfd_link_hash_indirect
4895 || hresolve->root.type == bfd_link_hash_warning)
4896 hresolve = ((struct aout_link_hash_entry *)
4897 hresolve->root.u.i.link);
4898 *sym_hash = hresolve;
4899 }
4900
4901 /* If the symbol has already been written out, skip it. */
4902 if (h != NULL
4903 && h->written)
4904 {
4905 if ((type & N_TYPE) == N_INDR
4906 || type == N_WARNING)
4907 skip_next = TRUE;
4908 *symbol_map = h->indx;
4909 continue;
4910 }
4911
4912 /* See if we are stripping this symbol. */
4913 skip = FALSE;
4914 switch (strip)
4915 {
4916 case strip_none:
4917 break;
4918 case strip_debugger:
4919 if ((type & N_STAB) != 0)
4920 skip = TRUE;
4921 break;
4922 case strip_some:
4923 if (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, FALSE)
4924 == NULL)
4925 skip = TRUE;
4926 break;
4927 case strip_all:
4928 skip = TRUE;
4929 break;
4930 }
4931 if (skip)
4932 {
4933 if (h != NULL)
4934 h->written = TRUE;
4935 continue;
4936 }
4937
4938 /* Get the value of the symbol. */
4939 if ((type & N_TYPE) == N_TEXT
4940 || type == N_WEAKT)
4941 symsec = obj_textsec (input_bfd);
4942 else if ((type & N_TYPE) == N_DATA
4943 || type == N_WEAKD)
4944 symsec = obj_datasec (input_bfd);
4945 else if ((type & N_TYPE) == N_BSS
4946 || type == N_WEAKB)
4947 symsec = obj_bsssec (input_bfd);
4948 else if ((type & N_TYPE) == N_ABS
4949 || type == N_WEAKA)
4950 symsec = bfd_abs_section_ptr;
4951 else if (((type & N_TYPE) == N_INDR
4952 && (hresolve == NULL
4953 || (hresolve->root.type != bfd_link_hash_defined
4954 && hresolve->root.type != bfd_link_hash_defweak
4955 && hresolve->root.type != bfd_link_hash_common)))
4956 || type == N_WARNING)
4957 {
4958 /* Pass the next symbol through unchanged. The
4959 condition above for indirect symbols is so that if
4960 the indirect symbol was defined, we output it with
4961 the correct definition so the debugger will
4962 understand it. */
4963 pass = TRUE;
4964 val = GET_WORD (input_bfd, sym->e_value);
4965 symsec = NULL;
4966 }
4967 else if ((type & N_STAB) != 0)
4968 {
4969 val = GET_WORD (input_bfd, sym->e_value);
4970 symsec = NULL;
4971 }
4972 else
4973 {
4974 /* If we get here with an indirect symbol, it means that
4975 we are outputting it with a real definition. In such
4976 a case we do not want to output the next symbol,
4977 which is the target of the indirection. */
4978 if ((type & N_TYPE) == N_INDR)
4979 skip_next = TRUE;
4980
4981 symsec = NULL;
4982
4983 /* We need to get the value from the hash table. We use
4984 hresolve so that if we have defined an indirect
4985 symbol we output the final definition. */
4986 if (h == NULL)
4987 {
4988 switch (type & N_TYPE)
4989 {
4990 case N_SETT:
4991 symsec = obj_textsec (input_bfd);
4992 break;
4993 case N_SETD:
4994 symsec = obj_datasec (input_bfd);
4995 break;
4996 case N_SETB:
4997 symsec = obj_bsssec (input_bfd);
4998 break;
4999 case N_SETA:
5000 symsec = bfd_abs_section_ptr;
5001 break;
5002 default:
5003 val = 0;
5004 break;
5005 }
5006 }
5007 else if (hresolve->root.type == bfd_link_hash_defined
5008 || hresolve->root.type == bfd_link_hash_defweak)
5009 {
5010 asection *input_section;
5011 asection *output_section;
5012
5013 /* This case usually means a common symbol which was
5014 turned into a defined symbol. */
5015 input_section = hresolve->root.u.def.section;
5016 output_section = input_section->output_section;
5017 BFD_ASSERT (bfd_is_abs_section (output_section)
5018 || output_section->owner == output_bfd);
5019 val = (hresolve->root.u.def.value
5020 + bfd_get_section_vma (output_bfd, output_section)
5021 + input_section->output_offset);
5022
5023 /* Get the correct type based on the section. If
5024 this is a constructed set, force it to be
5025 globally visible. */
5026 if (type == N_SETT
5027 || type == N_SETD
5028 || type == N_SETB
5029 || type == N_SETA)
5030 type |= N_EXT;
5031
5032 type &=~ N_TYPE;
5033
5034 if (output_section == obj_textsec (output_bfd))
5035 type |= (hresolve->root.type == bfd_link_hash_defined
5036 ? N_TEXT
5037 : N_WEAKT);
5038 else if (output_section == obj_datasec (output_bfd))
5039 type |= (hresolve->root.type == bfd_link_hash_defined
5040 ? N_DATA
5041 : N_WEAKD);
5042 else if (output_section == obj_bsssec (output_bfd))
5043 type |= (hresolve->root.type == bfd_link_hash_defined
5044 ? N_BSS
5045 : N_WEAKB);
5046 else
5047 type |= (hresolve->root.type == bfd_link_hash_defined
5048 ? N_ABS
5049 : N_WEAKA);
5050 }
5051 else if (hresolve->root.type == bfd_link_hash_common)
5052 val = hresolve->root.u.c.size;
5053 else if (hresolve->root.type == bfd_link_hash_undefweak)
5054 {
5055 val = 0;
5056 type = N_WEAKU;
5057 }
5058 else
5059 val = 0;
5060 }
5061 if (symsec != NULL)
5062 val = (symsec->output_section->vma
5063 + symsec->output_offset
5064 + (GET_WORD (input_bfd, sym->e_value)
5065 - symsec->vma));
5066
5067 /* If this is a global symbol set the written flag, and if
5068 it is a local symbol see if we should discard it. */
5069 if (h != NULL)
5070 {
5071 h->written = TRUE;
5072 h->indx = obj_aout_external_sym_count (output_bfd);
5073 }
5074 else if ((type & N_TYPE) != N_SETT
5075 && (type & N_TYPE) != N_SETD
5076 && (type & N_TYPE) != N_SETB
5077 && (type & N_TYPE) != N_SETA)
5078 {
5079 switch (discard)
5080 {
5081 case discard_none:
5082 case discard_sec_merge:
5083 break;
5084 case discard_l:
5085 if ((type & N_STAB) == 0
5086 && bfd_is_local_label_name (input_bfd, name))
5087 skip = TRUE;
5088 break;
5089 case discard_all:
5090 skip = TRUE;
5091 break;
5092 }
5093 if (skip)
5094 {
5095 pass = FALSE;
5096 continue;
5097 }
5098 }
5099
5100 /* An N_BINCL symbol indicates the start of the stabs
5101 entries for a header file. We need to scan ahead to the
5102 next N_EINCL symbol, ignoring nesting, adding up all the
5103 characters in the symbol names, not including the file
5104 numbers in types (the first number after an open
5105 parenthesis). */
5106 if (type == (int) N_BINCL)
5107 {
5108 struct external_nlist *incl_sym;
5109 int nest;
5110 struct aout_link_includes_entry *incl_entry;
5111 struct aout_link_includes_totals *t;
5112
5113 val = 0;
5114 nest = 0;
5115 for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
5116 {
5117 int incl_type;
5118
5119 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5120 if (incl_type == (int) N_EINCL)
5121 {
5122 if (nest == 0)
5123 break;
5124 --nest;
5125 }
5126 else if (incl_type == (int) N_BINCL)
5127 ++nest;
5128 else if (nest == 0)
5129 {
5130 const char *s;
5131
5132 s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
5133 for (; *s != '\0'; s++)
5134 {
5135 val += *s;
5136 if (*s == '(')
5137 {
5138 /* Skip the file number. */
5139 ++s;
5140 while (ISDIGIT (*s))
5141 ++s;
5142 --s;
5143 }
5144 }
5145 }
5146 }
5147
5148 /* If we have already included a header file with the
5149 same value, then replace this one with an N_EXCL
5150 symbol. */
5151 copy = (bfd_boolean) (! flaginfo->info->keep_memory);
5152 incl_entry = aout_link_includes_lookup (&flaginfo->includes,
5153 name, TRUE, copy);
5154 if (incl_entry == NULL)
5155 return FALSE;
5156 for (t = incl_entry->totals; t != NULL; t = t->next)
5157 if (t->total == val)
5158 break;
5159 if (t == NULL)
5160 {
5161 /* This is the first time we have seen this header
5162 file with this set of stabs strings. */
5163 t = (struct aout_link_includes_totals *)
5164 bfd_hash_allocate (&flaginfo->includes.root,
5165 sizeof *t);
5166 if (t == NULL)
5167 return FALSE;
5168 t->total = val;
5169 t->next = incl_entry->totals;
5170 incl_entry->totals = t;
5171 }
5172 else
5173 {
5174 int *incl_map;
5175
5176 /* This is a duplicate header file. We must change
5177 it to be an N_EXCL entry, and mark all the
5178 included symbols to prevent outputting them. */
5179 type = (int) N_EXCL;
5180
5181 nest = 0;
5182 for (incl_sym = sym + 1, incl_map = symbol_map + 1;
5183 incl_sym < sym_end;
5184 incl_sym++, incl_map++)
5185 {
5186 int incl_type;
5187
5188 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5189 if (incl_type == (int) N_EINCL)
5190 {
5191 if (nest == 0)
5192 {
5193 *incl_map = -1;
5194 break;
5195 }
5196 --nest;
5197 }
5198 else if (incl_type == (int) N_BINCL)
5199 ++nest;
5200 else if (nest == 0)
5201 *incl_map = -1;
5202 }
5203 }
5204 }
5205 }
5206
5207 /* Copy this symbol into the list of symbols we are going to
5208 write out. */
5209 H_PUT_8 (output_bfd, type, outsym->e_type);
5210 H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_other), outsym->e_other);
5211 H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
5212 copy = FALSE;
5213 if (! flaginfo->info->keep_memory)
5214 {
5215 /* name points into a string table which we are going to
5216 free. If there is a hash table entry, use that string.
5217 Otherwise, copy name into memory. */
5218 if (h != NULL)
5219 name = h->root.root.string;
5220 else
5221 copy = TRUE;
5222 }
5223 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
5224 name, copy);
5225 if (strtab_index == (bfd_size_type) -1)
5226 return FALSE;
5227 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
5228 PUT_WORD (output_bfd, val, outsym->e_value);
5229 *symbol_map = obj_aout_external_sym_count (output_bfd);
5230 ++obj_aout_external_sym_count (output_bfd);
5231 ++outsym;
5232 }
5233
5234 /* Write out the output symbols we have just constructed. */
5235 if (outsym > flaginfo->output_syms)
5236 {
5237 bfd_size_type outsym_size;
5238
5239 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0)
5240 return FALSE;
5241 outsym_size = outsym - flaginfo->output_syms;
5242 outsym_size *= EXTERNAL_NLIST_SIZE;
5243 if (bfd_bwrite ((void *) flaginfo->output_syms, outsym_size, output_bfd)
5244 != outsym_size)
5245 return FALSE;
5246 flaginfo->symoff += outsym_size;
5247 }
5248
5249 return TRUE;
5250 }
5251
5252 /* Link an a.out input BFD into the output file. */
5253
5254 static bfd_boolean
aout_link_input_bfd(struct aout_final_link_info * flaginfo,bfd * input_bfd)5255 aout_link_input_bfd (struct aout_final_link_info *flaginfo, bfd *input_bfd)
5256 {
5257 BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
5258
5259 /* If this is a dynamic object, it may need special handling. */
5260 if ((input_bfd->flags & DYNAMIC) != 0
5261 && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
5262 return ((*aout_backend_info (input_bfd)->link_dynamic_object)
5263 (flaginfo->info, input_bfd));
5264
5265 /* Get the symbols. We probably have them already, unless
5266 flaginfo->info->keep_memory is FALSE. */
5267 if (! aout_get_external_symbols (input_bfd))
5268 return FALSE;
5269
5270 /* Write out the symbols and get a map of the new indices. The map
5271 is placed into flaginfo->symbol_map. */
5272 if (! aout_link_write_symbols (flaginfo, input_bfd))
5273 return FALSE;
5274
5275 /* Relocate and write out the sections. These functions use the
5276 symbol map created by aout_link_write_symbols. The linker_mark
5277 field will be set if these sections are to be included in the
5278 link, which will normally be the case. */
5279 if (obj_textsec (input_bfd)->linker_mark)
5280 {
5281 if (! aout_link_input_section (flaginfo, input_bfd,
5282 obj_textsec (input_bfd),
5283 &flaginfo->treloff,
5284 exec_hdr (input_bfd)->a_trsize))
5285 return FALSE;
5286 }
5287 if (obj_datasec (input_bfd)->linker_mark)
5288 {
5289 if (! aout_link_input_section (flaginfo, input_bfd,
5290 obj_datasec (input_bfd),
5291 &flaginfo->dreloff,
5292 exec_hdr (input_bfd)->a_drsize))
5293 return FALSE;
5294 }
5295
5296 /* If we are not keeping memory, we don't need the symbols any
5297 longer. We still need them if we are keeping memory, because the
5298 strings in the hash table point into them. */
5299 if (! flaginfo->info->keep_memory)
5300 {
5301 if (! aout_link_free_symbols (input_bfd))
5302 return FALSE;
5303 }
5304
5305 return TRUE;
5306 }
5307
5308 /* Do the final link step. This is called on the output BFD. The
5309 INFO structure should point to a list of BFDs linked through the
5310 link_next field which can be used to find each BFD which takes part
5311 in the output. Also, each section in ABFD should point to a list
5312 of bfd_link_order structures which list all the input sections for
5313 the output section. */
5314
5315 bfd_boolean
NAME(aout,final_link)5316 NAME (aout, final_link) (bfd *abfd,
5317 struct bfd_link_info *info,
5318 void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
5319 {
5320 struct aout_final_link_info aout_info;
5321 bfd_boolean includes_hash_initialized = FALSE;
5322 bfd *sub;
5323 bfd_size_type trsize, drsize;
5324 bfd_size_type max_contents_size;
5325 bfd_size_type max_relocs_size;
5326 bfd_size_type max_sym_count;
5327 bfd_size_type text_size;
5328 file_ptr text_end;
5329 struct bfd_link_order *p;
5330 asection *o;
5331 bfd_boolean have_link_order_relocs;
5332
5333 if (info->shared)
5334 abfd->flags |= DYNAMIC;
5335
5336 aout_info.info = info;
5337 aout_info.output_bfd = abfd;
5338 aout_info.contents = NULL;
5339 aout_info.relocs = NULL;
5340 aout_info.symbol_map = NULL;
5341 aout_info.output_syms = NULL;
5342
5343 if (!bfd_hash_table_init_n (&aout_info.includes.root,
5344 aout_link_includes_newfunc,
5345 sizeof (struct aout_link_includes_entry),
5346 251))
5347 goto error_return;
5348 includes_hash_initialized = TRUE;
5349
5350 /* Figure out the largest section size. Also, if generating
5351 relocatable output, count the relocs. */
5352 trsize = 0;
5353 drsize = 0;
5354 max_contents_size = 0;
5355 max_relocs_size = 0;
5356 max_sym_count = 0;
5357 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5358 {
5359 bfd_size_type sz;
5360
5361 if (info->relocatable)
5362 {
5363 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
5364 {
5365 trsize += exec_hdr (sub)->a_trsize;
5366 drsize += exec_hdr (sub)->a_drsize;
5367 }
5368 else
5369 {
5370 /* FIXME: We need to identify the .text and .data sections
5371 and call get_reloc_upper_bound and canonicalize_reloc to
5372 work out the number of relocs needed, and then multiply
5373 by the reloc size. */
5374 (*_bfd_error_handler)
5375 (_("%s: relocatable link from %s to %s not supported"),
5376 bfd_get_filename (abfd),
5377 sub->xvec->name, abfd->xvec->name);
5378 bfd_set_error (bfd_error_invalid_operation);
5379 goto error_return;
5380 }
5381 }
5382
5383 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
5384 {
5385 sz = obj_textsec (sub)->size;
5386 if (sz > max_contents_size)
5387 max_contents_size = sz;
5388 sz = obj_datasec (sub)->size;
5389 if (sz > max_contents_size)
5390 max_contents_size = sz;
5391
5392 sz = exec_hdr (sub)->a_trsize;
5393 if (sz > max_relocs_size)
5394 max_relocs_size = sz;
5395 sz = exec_hdr (sub)->a_drsize;
5396 if (sz > max_relocs_size)
5397 max_relocs_size = sz;
5398
5399 sz = obj_aout_external_sym_count (sub);
5400 if (sz > max_sym_count)
5401 max_sym_count = sz;
5402 }
5403 }
5404
5405 if (info->relocatable)
5406 {
5407 if (obj_textsec (abfd) != NULL)
5408 trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
5409 ->map_head.link_order)
5410 * obj_reloc_entry_size (abfd));
5411 if (obj_datasec (abfd) != NULL)
5412 drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
5413 ->map_head.link_order)
5414 * obj_reloc_entry_size (abfd));
5415 }
5416
5417 exec_hdr (abfd)->a_trsize = trsize;
5418 exec_hdr (abfd)->a_drsize = drsize;
5419
5420 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
5421
5422 /* Adjust the section sizes and vmas according to the magic number.
5423 This sets a_text, a_data and a_bss in the exec_hdr and sets the
5424 filepos for each section. */
5425 if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
5426 goto error_return;
5427
5428 /* The relocation and symbol file positions differ among a.out
5429 targets. We are passed a callback routine from the backend
5430 specific code to handle this.
5431 FIXME: At this point we do not know how much space the symbol
5432 table will require. This will not work for any (nonstandard)
5433 a.out target that needs to know the symbol table size before it
5434 can compute the relocation file positions. This may or may not
5435 be the case for the hp300hpux target, for example. */
5436 (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
5437 &aout_info.symoff);
5438 obj_textsec (abfd)->rel_filepos = aout_info.treloff;
5439 obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
5440 obj_sym_filepos (abfd) = aout_info.symoff;
5441
5442 /* We keep a count of the symbols as we output them. */
5443 obj_aout_external_sym_count (abfd) = 0;
5444
5445 /* We accumulate the string table as we write out the symbols. */
5446 aout_info.strtab = _bfd_stringtab_init ();
5447 if (aout_info.strtab == NULL)
5448 goto error_return;
5449
5450 /* Allocate buffers to hold section contents and relocs. */
5451 aout_info.contents = (bfd_byte *) bfd_malloc (max_contents_size);
5452 aout_info.relocs = bfd_malloc (max_relocs_size);
5453 aout_info.symbol_map = (int *) bfd_malloc (max_sym_count * sizeof (int));
5454 aout_info.output_syms = (struct external_nlist *)
5455 bfd_malloc ((max_sym_count + 1) * sizeof (struct external_nlist));
5456 if ((aout_info.contents == NULL && max_contents_size != 0)
5457 || (aout_info.relocs == NULL && max_relocs_size != 0)
5458 || (aout_info.symbol_map == NULL && max_sym_count != 0)
5459 || aout_info.output_syms == NULL)
5460 goto error_return;
5461
5462 /* If we have a symbol named __DYNAMIC, force it out now. This is
5463 required by SunOS. Doing this here rather than in sunos.c is a
5464 hack, but it's easier than exporting everything which would be
5465 needed. */
5466 {
5467 struct aout_link_hash_entry *h;
5468
5469 h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
5470 FALSE, FALSE, FALSE);
5471 if (h != NULL)
5472 aout_link_write_other_symbol (&h->root.root, &aout_info);
5473 }
5474
5475 /* The most time efficient way to do the link would be to read all
5476 the input object files into memory and then sort out the
5477 information into the output file. Unfortunately, that will
5478 probably use too much memory. Another method would be to step
5479 through everything that composes the text section and write it
5480 out, and then everything that composes the data section and write
5481 it out, and then write out the relocs, and then write out the
5482 symbols. Unfortunately, that requires reading stuff from each
5483 input file several times, and we will not be able to keep all the
5484 input files open simultaneously, and reopening them will be slow.
5485
5486 What we do is basically process one input file at a time. We do
5487 everything we need to do with an input file once--copy over the
5488 section contents, handle the relocation information, and write
5489 out the symbols--and then we throw away the information we read
5490 from it. This approach requires a lot of lseeks of the output
5491 file, which is unfortunate but still faster than reopening a lot
5492 of files.
5493
5494 We use the output_has_begun field of the input BFDs to see
5495 whether we have already handled it. */
5496 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5497 sub->output_has_begun = FALSE;
5498
5499 /* Mark all sections which are to be included in the link. This
5500 will normally be every section. We need to do this so that we
5501 can identify any sections which the linker has decided to not
5502 include. */
5503 for (o = abfd->sections; o != NULL; o = o->next)
5504 {
5505 for (p = o->map_head.link_order; p != NULL; p = p->next)
5506 if (p->type == bfd_indirect_link_order)
5507 p->u.indirect.section->linker_mark = TRUE;
5508 }
5509
5510 have_link_order_relocs = FALSE;
5511 for (o = abfd->sections; o != NULL; o = o->next)
5512 {
5513 for (p = o->map_head.link_order;
5514 p != NULL;
5515 p = p->next)
5516 {
5517 if (p->type == bfd_indirect_link_order
5518 && (bfd_get_flavour (p->u.indirect.section->owner)
5519 == bfd_target_aout_flavour))
5520 {
5521 bfd *input_bfd;
5522
5523 input_bfd = p->u.indirect.section->owner;
5524 if (! input_bfd->output_has_begun)
5525 {
5526 if (! aout_link_input_bfd (&aout_info, input_bfd))
5527 goto error_return;
5528 input_bfd->output_has_begun = TRUE;
5529 }
5530 }
5531 else if (p->type == bfd_section_reloc_link_order
5532 || p->type == bfd_symbol_reloc_link_order)
5533 {
5534 /* These are handled below. */
5535 have_link_order_relocs = TRUE;
5536 }
5537 else
5538 {
5539 if (! _bfd_default_link_order (abfd, info, o, p))
5540 goto error_return;
5541 }
5542 }
5543 }
5544
5545 /* Write out any symbols that we have not already written out. */
5546 bfd_hash_traverse (&info->hash->table,
5547 aout_link_write_other_symbol,
5548 &aout_info);
5549
5550 /* Now handle any relocs we were asked to create by the linker.
5551 These did not come from any input file. We must do these after
5552 we have written out all the symbols, so that we know the symbol
5553 indices to use. */
5554 if (have_link_order_relocs)
5555 {
5556 for (o = abfd->sections; o != NULL; o = o->next)
5557 {
5558 for (p = o->map_head.link_order;
5559 p != NULL;
5560 p = p->next)
5561 {
5562 if (p->type == bfd_section_reloc_link_order
5563 || p->type == bfd_symbol_reloc_link_order)
5564 {
5565 if (! aout_link_reloc_link_order (&aout_info, o, p))
5566 goto error_return;
5567 }
5568 }
5569 }
5570 }
5571
5572 if (aout_info.contents != NULL)
5573 {
5574 free (aout_info.contents);
5575 aout_info.contents = NULL;
5576 }
5577 if (aout_info.relocs != NULL)
5578 {
5579 free (aout_info.relocs);
5580 aout_info.relocs = NULL;
5581 }
5582 if (aout_info.symbol_map != NULL)
5583 {
5584 free (aout_info.symbol_map);
5585 aout_info.symbol_map = NULL;
5586 }
5587 if (aout_info.output_syms != NULL)
5588 {
5589 free (aout_info.output_syms);
5590 aout_info.output_syms = NULL;
5591 }
5592 if (includes_hash_initialized)
5593 {
5594 bfd_hash_table_free (&aout_info.includes.root);
5595 includes_hash_initialized = FALSE;
5596 }
5597
5598 /* Finish up any dynamic linking we may be doing. */
5599 if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
5600 {
5601 if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
5602 goto error_return;
5603 }
5604
5605 /* Update the header information. */
5606 abfd->symcount = obj_aout_external_sym_count (abfd);
5607 exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
5608 obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
5609 obj_textsec (abfd)->reloc_count =
5610 exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
5611 obj_datasec (abfd)->reloc_count =
5612 exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
5613
5614 /* Write out the string table, unless there are no symbols. */
5615 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0)
5616 goto error_return;
5617 if (abfd->symcount > 0)
5618 {
5619 if (!emit_stringtab (abfd, aout_info.strtab))
5620 goto error_return;
5621 }
5622 else
5623 {
5624 bfd_byte b[BYTES_IN_WORD];
5625
5626 memset (b, 0, BYTES_IN_WORD);
5627 if (bfd_bwrite (b, (bfd_size_type) BYTES_IN_WORD, abfd) != BYTES_IN_WORD)
5628 goto error_return;
5629 }
5630
5631 return TRUE;
5632
5633 error_return:
5634 if (aout_info.contents != NULL)
5635 free (aout_info.contents);
5636 if (aout_info.relocs != NULL)
5637 free (aout_info.relocs);
5638 if (aout_info.symbol_map != NULL)
5639 free (aout_info.symbol_map);
5640 if (aout_info.output_syms != NULL)
5641 free (aout_info.output_syms);
5642 if (includes_hash_initialized)
5643 bfd_hash_table_free (&aout_info.includes.root);
5644 return FALSE;
5645 }
5646