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