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