1 /* Copyright (C) 1991 Free Software Foundation, Inc.
3 This file is part of GLD, the Gnu Linker.
5 GLD is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 1, or (at your option)
10 GLD is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GLD; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 * Revision 1.1 1991/03/21 21:29:04 gumby
26 * Revision 1.2 1991/03/15 18:45:55 rich
29 * Revision 1.1 1991/03/13 00:48:37 chrisb
32 * Revision 1.7 1991/03/10 19:15:03 sac
33 * Took out the abort() which had been put in the wrong place
34 * Updated the version #.
36 * Revision 1.6 1991/03/10 09:31:41 rich
38 * Makefile config.h ld-emul.c ld-emul.h ld-gld.c ld-gld960.c
39 * ld-lnk960.c ld.h lddigest.c ldexp.c ldexp.h ldfile.c ldfile.h
40 * ldgram.y ldinfo.h ldlang.c ldlang.h ldlex.h ldlex.l ldmain.c
41 * ldmain.h ldmisc.c ldmisc.h ldsym.c ldsym.h ldversion.c
42 * ldversion.h ldwarn.h ldwrite.c ldwrite.h y.tab.h
44 * As of this round of changes, ld now builds on all hosts of (Intel960)
45 * interest and copy passes my copy test on big endian hosts again.
47 * Revision 1.5 1991/03/09 03:25:08 sac
48 * Added support for LONG, SHORT and BYTE keywords in scripts
50 * Revision 1.4 1991/03/06 21:59:34 sac
51 * Completed G++ support
53 * Revision 1.3 1991/03/06 02:29:52 sac
54 * Added support for partial linking.
56 * Revision 1.2 1991/02/22 17:15:11 sac
57 * Added RCS keywords and copyrights
62 This module writes out the final image by reading sections from the
63 input files, relocating them and writing them out
65 There are two main paths through this module, one for normal
66 operation and one for partial linking.
68 During normal operation, raw section data is read along with the
69 associated relocation information, the relocation info applied and
70 the section data written out on a section by section basis.
72 When partially linking, all the relocation records are read to work
73 out how big the output relocation vector will be. Then raw data is
74 read, relocated and written section by section.
76 Written by Steve Chamberlain steve@cygnus.com
89 #include "ldgram.tab.h"
94 /* Static vars for do_warnings and subroutines of it */
95 int list_unresolved_refs; /* List unresolved refs */
96 int list_warning_symbols; /* List warning syms */
97 int list_multiple_defs; /* List multiple definitions */
99 extern char *sys_errlist[];
101 extern unsigned int undefined_global_sym_count;
103 extern bfd *output_bfd;
105 extern struct lang_output_section_statement_struct * create_object_symbols;
110 void lang_for_each_statement(void (*func)());
112 void lang_for_each_statement();
113 #endif /* __STDC__ */
115 extern size_t largest_section;
116 ld_config_type config;
118 extern unsigned int global_symbol_count;
122 static void perform_relocation(input_bfd,
127 asection *input_section;
131 static asymbol *error_symbol = (asymbol *)NULL;
132 static unsigned int error_count = 0;
133 #define MAX_ERRORS_IN_A_ROW 5
134 size_t reloc_size = get_reloc_upper_bound(input_bfd, input_section);
136 arelent **reloc_vector = (arelent **)ldmalloc(reloc_size);
138 bfd *ob = output_bfd;
139 asection *os = input_section->output_section;
140 if (config.relocateable_output == false) ob = (bfd *)NULL;
142 if (bfd_canonicalize_reloc(input_bfd,
147 for (parent = reloc_vector; *parent; parent++)
150 bfd_reloc_status_enum_type r=
151 bfd_perform_relocation(input_bfd,
157 if (r == bfd_reloc_ok) {
158 if (ob != (bfd *)NULL) {
159 /* A parital link, so keep the relocs */
160 os->orelocation[os->reloc_count] = *parent;
167 arelent *p = *parent;
169 if (ob != (bfd *)NULL) {
170 /* A parital link, so keep the relocs */
171 os->orelocation[os->reloc_count] = *parent;
175 if (p->sym_ptr_ptr != (asymbol **)NULL) {
176 s = *(p->sym_ptr_ptr);
183 case bfd_reloc_undefined:
184 /* We remember the symbol, and never print more than
185 a reasonable number of them in a row */
186 if (s == error_symbol) {
193 if (error_count < MAX_ERRORS_IN_A_ROW) {
194 info("%C: undefined reference to `%T'\n",
200 config.make_executable = false;
202 else if (error_count == MAX_ERRORS_IN_A_ROW) {
203 info("%C: more undefined references to `%T' follow\n",
211 /* Don't print any more */
214 case bfd_reloc_dangerous:
215 info("%B: relocation may be wrong `%T'\n",
219 case bfd_reloc_outofrange:
220 info("%B:%s relocation address out of range %T (%x)\n",
226 case bfd_reloc_overflow:
227 info("%B:%s relocation overflow in %T reloc type %d\n",
234 info("%F%B: relocation error, symbol `%T'\n",
242 free((char *)reloc_vector);
253 copy_and_relocate(statement)
254 lang_statement_union_type *statement;
256 switch (statement->header.type) {
257 case lang_fill_statement_enum:
260 bfd_byte play_area[SHORT_SIZE];
262 bfd_putshort(output_bfd, statement->fill_statement.fill, play_area);
263 /* Write out all entire shorts */
265 i < statement->fill_statement.size - SHORT_SIZE + 1;
268 bfd_set_section_contents(output_bfd,
269 statement->fill_statement.output_section,
271 statement->data_statement.output_offset +i,
276 /* Now write any remaining byte */
277 if (i < statement->fill_statement.size)
279 bfd_set_section_contents(output_bfd,
280 statement->fill_statement.output_section,
282 statement->data_statement.output_offset +i,
289 case lang_data_statement_enum:
291 bfd_vma value = statement->data_statement.value;
292 bfd_byte play_area[LONG_SIZE];
294 switch (statement->data_statement.type) {
296 bfd_putlong(output_bfd, value, play_area);
300 bfd_putshort(output_bfd, value, play_area);
304 bfd_putchar(output_bfd, value, play_area);
309 bfd_set_section_contents(output_bfd,
310 statement->data_statement.output_section,
312 statement->data_statement.output_vma,
320 case lang_input_section_enum:
323 asection *i = statement->input_section.section;
324 asection *output_section = i->output_section;
325 lang_input_statement_type *ifile = statement->input_section.ifile;
326 bfd *inbfd = ifile->the_bfd;
327 if (output_section->flags & SEC_LOAD && i->size != 0)
329 if(bfd_get_section_contents(inbfd,
335 info("%F%B error reading section contents %E\n",
338 perform_relocation (inbfd, i, data_area, ifile->asymbols);
341 if(bfd_set_section_contents(output_bfd,
344 (file_ptr)i->output_offset,
347 info("%F%B error writing section contents of %E\n",
356 /* All the other ones fall through */
365 /* Output the text and data segments, relocating as we go. */
366 lang_for_each_statement(copy_and_relocate);
370 static void read_relocs(abfd, section, symbols)
375 /* Work out the output section ascociated with this input section */
376 asection *output_section = section->output_section;
378 size_t reloc_size = get_reloc_upper_bound(abfd, section);
379 arelent **reloc_vector = (arelent **)ldmalloc(reloc_size);
381 if (bfd_canonicalize_reloc(abfd,
385 output_section->reloc_count += section->reloc_count;
394 Run through each section of each file and work work out the total
395 number of relocation records which will finally be in each output
399 LANG_FOR_EACH_INPUT_SECTION
400 (statement, abfd, section,
401 (read_relocs(abfd, section, statement->asymbols)));
406 Now run though all the output sections and allocate the space for
409 LANG_FOR_EACH_OUTPUT_SECTION
411 (section->orelocation =
412 (arelent **)ldmalloc((size_t)(sizeof(arelent **)*
413 section->reloc_count)),
414 section->reloc_count = 0,
415 section->flags |= SEC_HAS_CONTENTS));
419 Copy the data, relocating as we go
421 lang_for_each_statement(copy_and_relocate);
427 data_area = (void*) ldmalloc(largest_section);
428 if (config.relocateable_output == true)
437 /* Output the symbol table (both globals and locals). */