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