1 /* ldwrite.c -- write out the linked file 2 Copyright (C) 1991-2018 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 (_("%F%P: 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 (_("%F%P: 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 if (link_order == NULL) 258 einfo (_("%F%P: bfd_new_link_order failed\n")); 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 if (link_order == NULL) 299 einfo (_("%F%P: bfd_new_link_order failed\n")); 300 link_order->type = bfd_data_link_order; 301 link_order->size = statement->padding_statement.size; 302 link_order->offset = statement->padding_statement.output_offset; 303 link_order->u.data.contents = statement->padding_statement.fill->data; 304 link_order->u.data.size = statement->padding_statement.fill->size; 305 } 306 break; 307 308 default: 309 /* All the other ones fall through */ 310 break; 311 } 312 } 313 314 /* Return true if NAME is the name of an unsplittable section. These 315 are the stabs strings, dwarf strings. */ 316 317 static bfd_boolean 318 unsplittable_name (const char *name) 319 { 320 if (CONST_STRNEQ (name, ".stab")) 321 { 322 /* There are several stab like string sections. We pattern match on 323 ".stab...str" */ 324 unsigned len = strlen (name); 325 if (strcmp (&name[len-3], "str") == 0) 326 return TRUE; 327 } 328 else if (strcmp (name, "$GDB_STRINGS$") == 0) 329 return TRUE; 330 return FALSE; 331 } 332 333 /* Wander around the input sections, make sure that 334 we'll never try and create an output section with more relocs 335 than will fit.. Do this by always assuming the worst case, and 336 creating new output sections with all the right bits. */ 337 #define TESTIT 1 338 static asection * 339 clone_section (bfd *abfd, asection *s, const char *name, int *count) 340 { 341 char *tname; 342 char *sname; 343 unsigned int len; 344 asection *n; 345 struct bfd_link_hash_entry *h; 346 347 /* Invent a section name from the section name and a dotted numeric 348 suffix. */ 349 len = strlen (name); 350 tname = (char *) xmalloc (len + 1); 351 memcpy (tname, name, len + 1); 352 /* Remove a dotted number suffix, from a previous split link. */ 353 while (len && ISDIGIT (tname[len-1])) 354 len--; 355 if (len > 1 && tname[len-1] == '.') 356 /* It was a dotted number. */ 357 tname[len-1] = 0; 358 359 /* We want to use the whole of the original section name for the 360 split name, but coff can be restricted to 8 character names. */ 361 if (bfd_family_coff (abfd) && strlen (tname) > 5) 362 { 363 /* Some section names cannot be truncated, as the name is 364 used to locate some other section. */ 365 if (CONST_STRNEQ (name, ".stab") 366 || strcmp (name, "$GDB_SYMBOLS$") == 0) 367 { 368 einfo (_ ("%F%P: cannot create split section name for %s\n"), name); 369 /* Silence gcc warnings. einfo exits, so we never reach here. */ 370 return NULL; 371 } 372 tname[5] = 0; 373 } 374 375 if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL 376 || (n = bfd_make_section_anyway (abfd, sname)) == NULL 377 || (h = bfd_link_hash_lookup (link_info.hash, 378 sname, TRUE, TRUE, FALSE)) == NULL) 379 { 380 einfo (_("%F%P: clone section failed: %E\n")); 381 /* Silence gcc warnings. einfo exits, so we never reach here. */ 382 return NULL; 383 } 384 free (tname); 385 386 /* Set up section symbol. */ 387 h->type = bfd_link_hash_defined; 388 h->u.def.value = 0; 389 h->u.def.section = n; 390 391 n->flags = s->flags; 392 n->vma = s->vma; 393 n->user_set_vma = s->user_set_vma; 394 n->lma = s->lma; 395 n->size = 0; 396 n->output_offset = s->output_offset; 397 n->output_section = n; 398 n->orelocation = 0; 399 n->reloc_count = 0; 400 n->alignment_power = s->alignment_power; 401 402 bfd_copy_private_section_data (abfd, s, abfd, n); 403 404 return n; 405 } 406 407 #if TESTING 408 static void 409 ds (asection *s) 410 { 411 struct bfd_link_order *l = s->map_head.link_order; 412 printf ("vma %x size %x\n", s->vma, s->size); 413 while (l) 414 { 415 if (l->type == bfd_indirect_link_order) 416 printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename); 417 else 418 printf (_("%8x something else\n"), l->offset); 419 l = l->next; 420 } 421 printf ("\n"); 422 } 423 424 dump (char *s, asection *a1, asection *a2) 425 { 426 printf ("%s\n", s); 427 ds (a1); 428 ds (a2); 429 } 430 431 static void 432 sanity_check (bfd *abfd) 433 { 434 asection *s; 435 for (s = abfd->sections; s; s = s->next) 436 { 437 struct bfd_link_order *p; 438 bfd_vma prev = 0; 439 for (p = s->map_head.link_order; p; p = p->next) 440 { 441 if (p->offset > 100000) 442 abort (); 443 if (p->offset < prev) 444 abort (); 445 prev = p->offset; 446 } 447 } 448 } 449 #else 450 #define sanity_check(a) 451 #define dump(a, b, c) 452 #endif 453 454 static void 455 split_sections (bfd *abfd, struct bfd_link_info *info) 456 { 457 asection *original_sec; 458 int nsecs = abfd->section_count; 459 sanity_check (abfd); 460 /* Look through all the original sections. */ 461 for (original_sec = abfd->sections; 462 original_sec && nsecs; 463 original_sec = original_sec->next, nsecs--) 464 { 465 int count = 0; 466 unsigned int lines = 0; 467 unsigned int relocs = 0; 468 bfd_size_type sec_size = 0; 469 struct bfd_link_order *l; 470 struct bfd_link_order *p; 471 bfd_vma vma = original_sec->vma; 472 asection *cursor = original_sec; 473 474 /* Count up the relocations and line entries to see if anything 475 would be too big to fit. Accumulate section size too. */ 476 for (l = NULL, p = cursor->map_head.link_order; p != NULL; p = l->next) 477 { 478 unsigned int thislines = 0; 479 unsigned int thisrelocs = 0; 480 bfd_size_type thissize = 0; 481 if (p->type == bfd_indirect_link_order) 482 { 483 asection *sec; 484 485 sec = p->u.indirect.section; 486 487 if (info->strip == strip_none 488 || info->strip == strip_some) 489 thislines = sec->lineno_count; 490 491 if (bfd_link_relocatable (info)) 492 thisrelocs = sec->reloc_count; 493 494 thissize = sec->size; 495 496 } 497 else if (bfd_link_relocatable (info) 498 && (p->type == bfd_section_reloc_link_order 499 || p->type == bfd_symbol_reloc_link_order)) 500 thisrelocs++; 501 502 if (l != NULL 503 && (thisrelocs + relocs >= config.split_by_reloc 504 || thislines + lines >= config.split_by_reloc 505 || (thissize + sec_size >= config.split_by_file)) 506 && !unsplittable_name (cursor->name)) 507 { 508 /* Create a new section and put this link order and the 509 following link orders into it. */ 510 bfd_vma shift_offset; 511 asection *n; 512 513 n = clone_section (abfd, cursor, original_sec->name, &count); 514 515 /* Attach the link orders to the new section and snip 516 them off from the old section. */ 517 n->map_head.link_order = p; 518 n->map_tail.link_order = cursor->map_tail.link_order; 519 cursor->map_tail.link_order = l; 520 l->next = NULL; 521 l = p; 522 523 /* Change the size of the original section and 524 update the vma of the new one. */ 525 526 dump ("before snip", cursor, n); 527 528 shift_offset = p->offset; 529 n->size = cursor->size - shift_offset; 530 cursor->size = shift_offset; 531 532 vma += shift_offset; 533 n->lma = n->vma = vma; 534 535 /* Run down the chain and change the output section to 536 the right one, update the offsets too. */ 537 do 538 { 539 p->offset -= shift_offset; 540 if (p->type == bfd_indirect_link_order) 541 { 542 p->u.indirect.section->output_section = n; 543 p->u.indirect.section->output_offset = p->offset; 544 } 545 p = p->next; 546 } 547 while (p); 548 549 dump ("after snip", cursor, n); 550 cursor = n; 551 relocs = thisrelocs; 552 lines = thislines; 553 sec_size = thissize; 554 } 555 else 556 { 557 l = p; 558 relocs += thisrelocs; 559 lines += thislines; 560 sec_size += thissize; 561 } 562 } 563 } 564 sanity_check (abfd); 565 } 566 567 /* Call BFD to write out the linked file. */ 568 569 void 570 ldwrite (void) 571 { 572 /* Reset error indicator, which can typically something like invalid 573 format from opening up the .o files. */ 574 bfd_set_error (bfd_error_no_error); 575 lang_clear_os_map (); 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