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 <ldgram.h> 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 } 594