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 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 } 187 break; 188 189 case lang_reloc_statement_enum: 190 { 191 lang_reloc_statement_type *rs; 192 asection *output_section; 193 struct bfd_link_order *link_order; 194 195 rs = &statement->reloc_statement; 196 197 output_section = rs->output_section; 198 ASSERT (output_section->owner == link_info.output_bfd); 199 200 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0 201 || ((output_section->flags & SEC_LOAD) != 0 202 && (output_section->flags & SEC_THREAD_LOCAL)))) 203 break; 204 205 link_order = bfd_new_link_order (link_info.output_bfd, output_section); 206 if (link_order == NULL) 207 einfo (_("%P%F: bfd_new_link_order failed\n")); 208 209 link_order->offset = rs->output_offset; 210 link_order->size = bfd_get_reloc_size (rs->howto); 211 212 link_order->u.reloc.p = (struct bfd_link_order_reloc *) 213 xmalloc (sizeof (struct bfd_link_order_reloc)); 214 215 link_order->u.reloc.p->reloc = rs->reloc; 216 link_order->u.reloc.p->addend = rs->addend_value; 217 218 if (rs->name == NULL) 219 { 220 link_order->type = bfd_section_reloc_link_order; 221 if (rs->section->owner == link_info.output_bfd) 222 link_order->u.reloc.p->u.section = rs->section; 223 else 224 { 225 link_order->u.reloc.p->u.section = rs->section->output_section; 226 link_order->u.reloc.p->addend += rs->section->output_offset; 227 } 228 } 229 else 230 { 231 link_order->type = bfd_symbol_reloc_link_order; 232 link_order->u.reloc.p->u.name = rs->name; 233 } 234 } 235 break; 236 237 case lang_input_section_enum: 238 { 239 /* Create a new link_order in the output section with this 240 attached */ 241 asection *i = statement->input_section.section; 242 243 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag 244 && (i->flags & SEC_EXCLUDE) == 0) 245 { 246 asection *output_section = i->output_section; 247 struct bfd_link_order *link_order; 248 249 ASSERT (output_section->owner == link_info.output_bfd); 250 251 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0 252 || ((output_section->flags & SEC_LOAD) != 0 253 && (output_section->flags & SEC_THREAD_LOCAL)))) 254 break; 255 256 link_order = bfd_new_link_order (link_info.output_bfd, 257 output_section); 258 259 if ((i->flags & SEC_NEVER_LOAD) != 0 260 && (i->flags & SEC_DEBUGGING) == 0) 261 { 262 /* We've got a never load section inside one which is 263 going to be output, we'll change it into a fill. */ 264 link_order->type = bfd_data_link_order; 265 link_order->u.data.contents = (unsigned char *) ""; 266 link_order->u.data.size = 1; 267 } 268 else 269 { 270 link_order->type = bfd_indirect_link_order; 271 link_order->u.indirect.section = i; 272 ASSERT (i->output_section == output_section); 273 } 274 link_order->size = i->size; 275 link_order->offset = i->output_offset; 276 } 277 } 278 break; 279 280 case lang_padding_statement_enum: 281 /* Make a new link_order with the right filler */ 282 { 283 asection *output_section; 284 struct bfd_link_order *link_order; 285 286 output_section = statement->padding_statement.output_section; 287 ASSERT (statement->padding_statement.output_section->owner 288 == link_info.output_bfd); 289 290 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0 291 || ((output_section->flags & SEC_LOAD) != 0 292 && (output_section->flags & SEC_THREAD_LOCAL)))) 293 break; 294 295 link_order = bfd_new_link_order (link_info.output_bfd, 296 output_section); 297 link_order->type = bfd_data_link_order; 298 link_order->size = statement->padding_statement.size; 299 link_order->offset = statement->padding_statement.output_offset; 300 link_order->u.data.contents = statement->padding_statement.fill->data; 301 link_order->u.data.size = statement->padding_statement.fill->size; 302 } 303 break; 304 305 default: 306 /* All the other ones fall through */ 307 break; 308 } 309 } 310 311 /* Return true if NAME is the name of an unsplittable section. These 312 are the stabs strings, dwarf strings. */ 313 314 static bfd_boolean 315 unsplittable_name (const char *name) 316 { 317 if (CONST_STRNEQ (name, ".stab")) 318 { 319 /* There are several stab like string sections. We pattern match on 320 ".stab...str" */ 321 unsigned len = strlen (name); 322 if (strcmp (&name[len-3], "str") == 0) 323 return TRUE; 324 } 325 else if (strcmp (name, "$GDB_STRINGS$") == 0) 326 return TRUE; 327 return FALSE; 328 } 329 330 /* Wander around the input sections, make sure that 331 we'll never try and create an output section with more relocs 332 than will fit.. Do this by always assuming the worst case, and 333 creating new output sections with all the right bits. */ 334 #define TESTIT 1 335 static asection * 336 clone_section (bfd *abfd, asection *s, const char *name, int *count) 337 { 338 char *tname; 339 char *sname; 340 unsigned int len; 341 asection *n; 342 struct bfd_link_hash_entry *h; 343 344 /* Invent a section name from the section name and a dotted numeric 345 suffix. */ 346 len = strlen (name); 347 tname = (char *) xmalloc (len + 1); 348 memcpy (tname, name, len + 1); 349 /* Remove a dotted number suffix, from a previous split link. */ 350 while (len && ISDIGIT (tname[len-1])) 351 len--; 352 if (len > 1 && tname[len-1] == '.') 353 /* It was a dotted number. */ 354 tname[len-1] = 0; 355 356 /* We want to use the whole of the original section name for the 357 split name, but coff can be restricted to 8 character names. */ 358 if (bfd_family_coff (abfd) && strlen (tname) > 5) 359 { 360 /* Some section names cannot be truncated, as the name is 361 used to locate some other section. */ 362 if (CONST_STRNEQ (name, ".stab") 363 || strcmp (name, "$GDB_SYMBOLS$") == 0) 364 { 365 einfo (_ ("%F%P: cannot create split section name for %s\n"), name); 366 /* Silence gcc warnings. einfo exits, so we never reach here. */ 367 return NULL; 368 } 369 tname[5] = 0; 370 } 371 372 if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL 373 || (n = bfd_make_section_anyway (abfd, sname)) == NULL 374 || (h = bfd_link_hash_lookup (link_info.hash, 375 sname, TRUE, TRUE, FALSE)) == NULL) 376 { 377 einfo (_("%F%P: clone section failed: %E\n")); 378 /* Silence gcc warnings. einfo exits, so we never reach here. */ 379 return NULL; 380 } 381 free (tname); 382 383 /* Set up section symbol. */ 384 h->type = bfd_link_hash_defined; 385 h->u.def.value = 0; 386 h->u.def.section = n; 387 388 n->flags = s->flags; 389 n->vma = s->vma; 390 n->user_set_vma = s->user_set_vma; 391 n->lma = s->lma; 392 n->size = 0; 393 n->output_offset = s->output_offset; 394 n->output_section = n; 395 n->orelocation = 0; 396 n->reloc_count = 0; 397 n->alignment_power = s->alignment_power; 398 399 bfd_copy_private_section_data (abfd, s, abfd, n); 400 401 return n; 402 } 403 404 #if TESTING 405 static void 406 ds (asection *s) 407 { 408 struct bfd_link_order *l = s->map_head.link_order; 409 printf ("vma %x size %x\n", s->vma, s->size); 410 while (l) 411 { 412 if (l->type == bfd_indirect_link_order) 413 { 414 printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename); 415 } 416 else 417 { 418 printf (_("%8x something else\n"), l->offset); 419 } 420 l = l->next; 421 } 422 printf ("\n"); 423 } 424 425 dump (char *s, asection *a1, asection *a2) 426 { 427 printf ("%s\n", s); 428 ds (a1); 429 ds (a2); 430 } 431 432 static void 433 sanity_check (bfd *abfd) 434 { 435 asection *s; 436 for (s = abfd->sections; s; s = s->next) 437 { 438 struct bfd_link_order *p; 439 bfd_vma prev = 0; 440 for (p = s->map_head.link_order; p; p = p->next) 441 { 442 if (p->offset > 100000) 443 abort (); 444 if (p->offset < prev) 445 abort (); 446 prev = p->offset; 447 } 448 } 449 } 450 #else 451 #define sanity_check(a) 452 #define dump(a, b, c) 453 #endif 454 455 static void 456 split_sections (bfd *abfd, struct bfd_link_info *info) 457 { 458 asection *original_sec; 459 int nsecs = abfd->section_count; 460 sanity_check (abfd); 461 /* Look through all the original sections. */ 462 for (original_sec = abfd->sections; 463 original_sec && nsecs; 464 original_sec = original_sec->next, nsecs--) 465 { 466 int count = 0; 467 unsigned int lines = 0; 468 unsigned int relocs = 0; 469 bfd_size_type sec_size = 0; 470 struct bfd_link_order *l; 471 struct bfd_link_order *p; 472 bfd_vma vma = original_sec->vma; 473 asection *cursor = original_sec; 474 475 /* Count up the relocations and line entries to see if anything 476 would be too big to fit. Accumulate section size too. */ 477 for (l = NULL, p = cursor->map_head.link_order; p != NULL; p = l->next) 478 { 479 unsigned int thislines = 0; 480 unsigned int thisrelocs = 0; 481 bfd_size_type thissize = 0; 482 if (p->type == bfd_indirect_link_order) 483 { 484 asection *sec; 485 486 sec = p->u.indirect.section; 487 488 if (info->strip == strip_none 489 || info->strip == strip_some) 490 thislines = sec->lineno_count; 491 492 if (info->relocatable) 493 thisrelocs = sec->reloc_count; 494 495 thissize = sec->size; 496 497 } 498 else if (info->relocatable 499 && (p->type == bfd_section_reloc_link_order 500 || p->type == bfd_symbol_reloc_link_order)) 501 thisrelocs++; 502 503 if (l != NULL 504 && (thisrelocs + relocs >= config.split_by_reloc 505 || thislines + lines >= config.split_by_reloc 506 || (thissize + sec_size >= config.split_by_file)) 507 && !unsplittable_name (cursor->name)) 508 { 509 /* Create a new section and put this link order and the 510 following link orders into it. */ 511 bfd_vma shift_offset; 512 asection *n; 513 514 n = clone_section (abfd, cursor, original_sec->name, &count); 515 516 /* Attach the link orders to the new section and snip 517 them off from the old section. */ 518 n->map_head.link_order = p; 519 n->map_tail.link_order = cursor->map_tail.link_order; 520 cursor->map_tail.link_order = l; 521 l->next = NULL; 522 l = p; 523 524 /* Change the size of the original section and 525 update the vma of the new one. */ 526 527 dump ("before snip", cursor, n); 528 529 shift_offset = p->offset; 530 n->size = cursor->size - shift_offset; 531 cursor->size = shift_offset; 532 533 vma += shift_offset; 534 n->lma = n->vma = vma; 535 536 /* Run down the chain and change the output section to 537 the right one, update the offsets too. */ 538 do 539 { 540 p->offset -= shift_offset; 541 if (p->type == bfd_indirect_link_order) 542 { 543 p->u.indirect.section->output_section = n; 544 p->u.indirect.section->output_offset = p->offset; 545 } 546 p = p->next; 547 } 548 while (p); 549 550 dump ("after snip", cursor, n); 551 cursor = n; 552 relocs = thisrelocs; 553 lines = thislines; 554 sec_size = thissize; 555 } 556 else 557 { 558 l = p; 559 relocs += thisrelocs; 560 lines += thislines; 561 sec_size += thissize; 562 } 563 } 564 } 565 sanity_check (abfd); 566 } 567 568 /* Call BFD to write out the linked file. */ 569 570 void 571 ldwrite (void) 572 { 573 /* Reset error indicator, which can typically something like invalid 574 format from opening up the .o files. */ 575 bfd_set_error (bfd_error_no_error); 576 lang_for_each_statement (build_link_order); 577 578 if (config.split_by_reloc != (unsigned) -1 579 || config.split_by_file != (bfd_size_type) -1) 580 split_sections (link_info.output_bfd, &link_info); 581 if (!bfd_final_link (link_info.output_bfd, &link_info)) 582 { 583 /* If there was an error recorded, print it out. Otherwise assume 584 an appropriate error message like unknown symbol was printed 585 out. */ 586 587 if (bfd_get_error () != bfd_error_no_error) 588 einfo (_("%F%P: final link failed: %E\n")); 589 else 590 xexit (1); 591 } 592 } 593