* symtab.h (enum address_class): Remove LOC_BASEREG and
[deliverable/binutils-gdb.git] / ld / ldwrite.c
1 /* ldwrite.c -- write out the linked file
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4 Written by Steve Chamberlain sac@cygnus.com
5
6 This file is part of the GNU Binutils.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libiberty.h"
27 #include "safe-ctype.h"
28
29 #include "ld.h"
30 #include "ldexp.h"
31 #include "ldlang.h"
32 #include "ldwrite.h"
33 #include "ldmisc.h"
34 #include <ldgram.h>
35 #include "ldmain.h"
36
37 /* Build link_order structures for the BFD linker. */
38
39 static void
40 build_link_order (lang_statement_union_type *statement)
41 {
42 switch (statement->header.type)
43 {
44 case lang_data_statement_enum:
45 {
46 asection *output_section;
47 struct bfd_link_order *link_order;
48 bfd_vma value;
49 bfd_boolean big_endian = FALSE;
50
51 output_section = statement->data_statement.output_section;
52 ASSERT (output_section->owner == link_info.output_bfd);
53
54 link_order = bfd_new_link_order (link_info.output_bfd, output_section);
55 if (link_order == NULL)
56 einfo (_("%P%F: bfd_new_link_order failed\n"));
57
58 link_order->type = bfd_data_link_order;
59 link_order->offset = statement->data_statement.output_offset;
60 link_order->u.data.contents = xmalloc (QUAD_SIZE);
61
62 value = statement->data_statement.value;
63
64 /* If the endianness of the output BFD is not known, then we
65 base the endianness of the data on the first input file.
66 By convention, the bfd_put routines for an unknown
67 endianness are big endian, so we must swap here if the
68 input file is little endian. */
69 if (bfd_big_endian (link_info.output_bfd))
70 big_endian = TRUE;
71 else if (bfd_little_endian (link_info.output_bfd))
72 big_endian = FALSE;
73 else
74 {
75 bfd_boolean swap;
76
77 swap = FALSE;
78 if (command_line.endian == ENDIAN_BIG)
79 big_endian = TRUE;
80 else if (command_line.endian == ENDIAN_LITTLE)
81 {
82 big_endian = FALSE;
83 swap = TRUE;
84 }
85 else if (command_line.endian == ENDIAN_UNSET)
86 {
87 big_endian = TRUE;
88 {
89 LANG_FOR_EACH_INPUT_STATEMENT (s)
90 {
91 if (s->the_bfd != NULL)
92 {
93 if (bfd_little_endian (s->the_bfd))
94 {
95 big_endian = FALSE;
96 swap = TRUE;
97 }
98 break;
99 }
100 }
101 }
102 }
103
104 if (swap)
105 {
106 bfd_byte buffer[8];
107
108 switch (statement->data_statement.type)
109 {
110 case QUAD:
111 case SQUAD:
112 if (sizeof (bfd_vma) >= QUAD_SIZE)
113 {
114 bfd_putl64 (value, buffer);
115 value = bfd_getb64 (buffer);
116 break;
117 }
118 /* Fall through. */
119 case LONG:
120 bfd_putl32 (value, buffer);
121 value = bfd_getb32 (buffer);
122 break;
123 case SHORT:
124 bfd_putl16 (value, buffer);
125 value = bfd_getb16 (buffer);
126 break;
127 case BYTE:
128 break;
129 default:
130 abort ();
131 }
132 }
133 }
134
135 ASSERT (output_section->owner == link_info.output_bfd);
136 switch (statement->data_statement.type)
137 {
138 case QUAD:
139 case SQUAD:
140 if (sizeof (bfd_vma) >= QUAD_SIZE)
141 bfd_put_64 (link_info.output_bfd, value,
142 link_order->u.data.contents);
143 else
144 {
145 bfd_vma high;
146
147 if (statement->data_statement.type == QUAD)
148 high = 0;
149 else if ((value & 0x80000000) == 0)
150 high = 0;
151 else
152 high = (bfd_vma) -1;
153 bfd_put_32 (link_info.output_bfd, high,
154 (link_order->u.data.contents
155 + (big_endian ? 0 : 4)));
156 bfd_put_32 (link_info.output_bfd, value,
157 (link_order->u.data.contents
158 + (big_endian ? 4 : 0)));
159 }
160 link_order->size = QUAD_SIZE;
161 break;
162 case LONG:
163 bfd_put_32 (link_info.output_bfd, value,
164 link_order->u.data.contents);
165 link_order->size = LONG_SIZE;
166 break;
167 case SHORT:
168 bfd_put_16 (link_info.output_bfd, value,
169 link_order->u.data.contents);
170 link_order->size = SHORT_SIZE;
171 break;
172 case BYTE:
173 bfd_put_8 (link_info.output_bfd, value,
174 link_order->u.data.contents);
175 link_order->size = BYTE_SIZE;
176 break;
177 default:
178 abort ();
179 }
180 }
181 break;
182
183 case lang_reloc_statement_enum:
184 {
185 lang_reloc_statement_type *rs;
186 asection *output_section;
187 struct bfd_link_order *link_order;
188
189 rs = &statement->reloc_statement;
190
191 output_section = rs->output_section;
192 ASSERT (output_section->owner == link_info.output_bfd);
193
194 link_order = bfd_new_link_order (link_info.output_bfd, output_section);
195 if (link_order == NULL)
196 einfo (_("%P%F: bfd_new_link_order failed\n"));
197
198 link_order->offset = rs->output_offset;
199 link_order->size = bfd_get_reloc_size (rs->howto);
200
201 link_order->u.reloc.p = xmalloc (sizeof (struct bfd_link_order_reloc));
202
203 link_order->u.reloc.p->reloc = rs->reloc;
204 link_order->u.reloc.p->addend = rs->addend_value;
205
206 if (rs->name == NULL)
207 {
208 link_order->type = bfd_section_reloc_link_order;
209 if (rs->section->owner == link_info.output_bfd)
210 link_order->u.reloc.p->u.section = rs->section;
211 else
212 {
213 link_order->u.reloc.p->u.section = rs->section->output_section;
214 link_order->u.reloc.p->addend += rs->section->output_offset;
215 }
216 }
217 else
218 {
219 link_order->type = bfd_symbol_reloc_link_order;
220 link_order->u.reloc.p->u.name = rs->name;
221 }
222 }
223 break;
224
225 case lang_input_section_enum:
226 {
227 /* Create a new link_order in the output section with this
228 attached */
229 asection *i = statement->input_section.section;
230
231 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
232 && (i->flags & SEC_EXCLUDE) == 0)
233 {
234 asection *output_section = i->output_section;
235
236 ASSERT (output_section->owner == link_info.output_bfd);
237
238 if ((output_section->flags & SEC_HAS_CONTENTS) != 0
239 || ((output_section->flags & SEC_LOAD) != 0
240 && (output_section->flags & SEC_THREAD_LOCAL)))
241 {
242 struct bfd_link_order *link_order;
243
244 link_order = bfd_new_link_order (link_info.output_bfd,
245 output_section);
246
247 if (i->flags & SEC_NEVER_LOAD)
248 {
249 /* We've got a never load section inside one which
250 is going to be output, we'll change it into a
251 fill. */
252 link_order->type = bfd_data_link_order;
253 link_order->u.data.contents = (unsigned char *) "";
254 link_order->u.data.size = 1;
255 }
256 else
257 {
258 link_order->type = bfd_indirect_link_order;
259 link_order->u.indirect.section = i;
260 ASSERT (i->output_section == output_section);
261 }
262 link_order->size = i->size;
263 link_order->offset = i->output_offset;
264 }
265 }
266 }
267 break;
268
269 case lang_padding_statement_enum:
270 /* Make a new link_order with the right filler */
271 {
272 asection *output_section;
273 struct bfd_link_order *link_order;
274
275 output_section = statement->padding_statement.output_section;
276 ASSERT (statement->padding_statement.output_section->owner
277 == link_info.output_bfd);
278 if (((output_section->flags & SEC_HAS_CONTENTS) != 0
279 || ((output_section->flags & SEC_LOAD) != 0
280 && (output_section->flags & SEC_THREAD_LOCAL)))
281 && (output_section->flags & SEC_NEVER_LOAD) == 0)
282 {
283 link_order = bfd_new_link_order (link_info.output_bfd,
284 output_section);
285 link_order->type = bfd_data_link_order;
286 link_order->size = statement->padding_statement.size;
287 link_order->offset = statement->padding_statement.output_offset;
288 link_order->u.data.contents = statement->padding_statement.fill->data;
289 link_order->u.data.size = statement->padding_statement.fill->size;
290 }
291 }
292 break;
293
294 default:
295 /* All the other ones fall through */
296 break;
297 }
298 }
299
300 /* Return true if NAME is the name of an unsplittable section. These
301 are the stabs strings, dwarf strings. */
302
303 static bfd_boolean
304 unsplittable_name (const char *name)
305 {
306 if (CONST_STRNEQ (name, ".stab"))
307 {
308 /* There are several stab like string sections. We pattern match on
309 ".stab...str" */
310 unsigned len = strlen (name);
311 if (strcmp (&name[len-3], "str") == 0)
312 return TRUE;
313 }
314 else if (strcmp (name, "$GDB_STRINGS$") == 0)
315 return TRUE;
316 return FALSE;
317 }
318
319 /* Wander around the input sections, make sure that
320 we'll never try and create an output section with more relocs
321 than will fit.. Do this by always assuming the worst case, and
322 creating new output sections with all the right bits. */
323 #define TESTIT 1
324 static asection *
325 clone_section (bfd *abfd, asection *s, const char *name, int *count)
326 {
327 char *tname;
328 char *sname;
329 unsigned int len;
330 asection *n;
331 struct bfd_link_hash_entry *h;
332
333 /* Invent a section name from the section name and a dotted numeric
334 suffix. */
335 len = strlen (name);
336 tname = xmalloc (len + 1);
337 memcpy (tname, name, len + 1);
338 /* Remove a dotted number suffix, from a previous split link. */
339 while (len && ISDIGIT (tname[len-1]))
340 len--;
341 if (len > 1 && tname[len-1] == '.')
342 /* It was a dotted number. */
343 tname[len-1] = 0;
344
345 /* We want to use the whole of the original section name for the
346 split name, but coff can be restricted to 8 character names. */
347 if (bfd_family_coff (abfd) && strlen (tname) > 5)
348 {
349 /* Some section names cannot be truncated, as the name is
350 used to locate some other section. */
351 if (CONST_STRNEQ (name, ".stab")
352 || strcmp (name, "$GDB_SYMBOLS$") == 0)
353 {
354 einfo (_ ("%F%P: cannot create split section name for %s\n"), name);
355 /* Silence gcc warnings. einfo exits, so we never reach here. */
356 return NULL;
357 }
358 tname[5] = 0;
359 }
360
361 if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL
362 || (n = bfd_make_section_anyway (abfd, sname)) == NULL
363 || (h = bfd_link_hash_lookup (link_info.hash,
364 sname, TRUE, TRUE, FALSE)) == NULL)
365 {
366 einfo (_("%F%P: clone section failed: %E\n"));
367 /* Silence gcc warnings. einfo exits, so we never reach here. */
368 return NULL;
369 }
370 free (tname);
371
372 /* Set up section symbol. */
373 h->type = bfd_link_hash_defined;
374 h->u.def.value = 0;
375 h->u.def.section = n;
376
377 n->flags = s->flags;
378 n->vma = s->vma;
379 n->user_set_vma = s->user_set_vma;
380 n->lma = s->lma;
381 n->size = 0;
382 n->output_offset = s->output_offset;
383 n->output_section = n;
384 n->orelocation = 0;
385 n->reloc_count = 0;
386 n->alignment_power = s->alignment_power;
387 return n;
388 }
389
390 #if TESTING
391 static void
392 ds (asection *s)
393 {
394 struct bfd_link_order *l = s->map_head.link_order;
395 printf ("vma %x size %x\n", s->vma, s->size);
396 while (l)
397 {
398 if (l->type == bfd_indirect_link_order)
399 {
400 printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
401 }
402 else
403 {
404 printf (_("%8x something else\n"), l->offset);
405 }
406 l = l->next;
407 }
408 printf ("\n");
409 }
410
411 dump (char *s, asection *a1, asection *a2)
412 {
413 printf ("%s\n", s);
414 ds (a1);
415 ds (a2);
416 }
417
418 static void
419 sanity_check (bfd *abfd)
420 {
421 asection *s;
422 for (s = abfd->sections; s; s = s->next)
423 {
424 struct bfd_link_order *p;
425 bfd_vma prev = 0;
426 for (p = s->map_head.link_order; p; p = p->next)
427 {
428 if (p->offset > 100000)
429 abort ();
430 if (p->offset < prev)
431 abort ();
432 prev = p->offset;
433 }
434 }
435 }
436 #else
437 #define sanity_check(a)
438 #define dump(a, b, c)
439 #endif
440
441 static void
442 split_sections (bfd *abfd, struct bfd_link_info *info)
443 {
444 asection *original_sec;
445 int nsecs = abfd->section_count;
446 sanity_check (abfd);
447 /* Look through all the original sections. */
448 for (original_sec = abfd->sections;
449 original_sec && nsecs;
450 original_sec = original_sec->next, nsecs--)
451 {
452 int count = 0;
453 unsigned int lines = 0;
454 unsigned int relocs = 0;
455 bfd_size_type sec_size = 0;
456 struct bfd_link_order *l;
457 struct bfd_link_order *p;
458 bfd_vma vma = original_sec->vma;
459 asection *cursor = original_sec;
460
461 /* Count up the relocations and line entries to see if anything
462 would be too big to fit. Accumulate section size too. */
463 for (l = NULL, p = cursor->map_head.link_order; p != NULL; p = l->next)
464 {
465 unsigned int thislines = 0;
466 unsigned int thisrelocs = 0;
467 bfd_size_type thissize = 0;
468 if (p->type == bfd_indirect_link_order)
469 {
470 asection *sec;
471
472 sec = p->u.indirect.section;
473
474 if (info->strip == strip_none
475 || info->strip == strip_some)
476 thislines = sec->lineno_count;
477
478 if (info->relocatable)
479 thisrelocs = sec->reloc_count;
480
481 thissize = sec->size;
482
483 }
484 else if (info->relocatable
485 && (p->type == bfd_section_reloc_link_order
486 || p->type == bfd_symbol_reloc_link_order))
487 thisrelocs++;
488
489 if (l != NULL
490 && (thisrelocs + relocs >= config.split_by_reloc
491 || thislines + lines >= config.split_by_reloc
492 || (thissize + sec_size >= config.split_by_file))
493 && !unsplittable_name (cursor->name))
494 {
495 /* Create a new section and put this link order and the
496 following link orders into it. */
497 bfd_vma shift_offset;
498 asection *n;
499
500 n = clone_section (abfd, cursor, original_sec->name, &count);
501
502 /* Attach the link orders to the new section and snip
503 them off from the old section. */
504 n->map_head.link_order = p;
505 n->map_tail.link_order = cursor->map_tail.link_order;
506 cursor->map_tail.link_order = l;
507 l->next = NULL;
508 l = p;
509
510 /* Change the size of the original section and
511 update the vma of the new one. */
512
513 dump ("before snip", cursor, n);
514
515 shift_offset = p->offset;
516 n->size = cursor->size - shift_offset;
517 cursor->size = shift_offset;
518
519 vma += shift_offset;
520 n->lma = n->vma = vma;
521
522 /* Run down the chain and change the output section to
523 the right one, update the offsets too. */
524 do
525 {
526 p->offset -= shift_offset;
527 if (p->type == bfd_indirect_link_order)
528 {
529 p->u.indirect.section->output_section = n;
530 p->u.indirect.section->output_offset = p->offset;
531 }
532 p = p->next;
533 }
534 while (p);
535
536 dump ("after snip", cursor, n);
537 cursor = n;
538 relocs = thisrelocs;
539 lines = thislines;
540 sec_size = thissize;
541 }
542 else
543 {
544 l = p;
545 relocs += thisrelocs;
546 lines += thislines;
547 sec_size += thissize;
548 }
549 }
550 }
551 sanity_check (abfd);
552 }
553
554 /* Call BFD to write out the linked file. */
555
556 void
557 ldwrite (void)
558 {
559 /* Reset error indicator, which can typically something like invalid
560 format from opening up the .o files. */
561 bfd_set_error (bfd_error_no_error);
562 lang_for_each_statement (build_link_order);
563
564 if (config.split_by_reloc != (unsigned) -1
565 || config.split_by_file != (bfd_size_type) -1)
566 split_sections (link_info.output_bfd, &link_info);
567 if (!bfd_final_link (link_info.output_bfd, &link_info))
568 {
569 /* If there was an error recorded, print it out. Otherwise assume
570 an appropriate error message like unknown symbol was printed
571 out. */
572
573 if (bfd_get_error () != bfd_error_no_error)
574 einfo (_("%F%P: final link failed: %E\n"));
575 else
576 xexit (1);
577 }
578 }
This page took 0.046638 seconds and 4 git commands to generate.