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