1 /* ldwrite.c -- write out the linked file 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2002, 2003 3 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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_vma; 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_vma; 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 /* Create a new link_order in the output section with this 222 attached */ 223 if (!statement->input_section.ifile->just_syms_flag) 224 { 225 asection *i = statement->input_section.section; 226 asection *output_section = i->output_section; 227 228 ASSERT (output_section->owner == output_bfd); 229 230 if ((output_section->flags & SEC_HAS_CONTENTS) != 0 231 || ((output_section->flags & SEC_LOAD) != 0 232 && (output_section->flags & SEC_THREAD_LOCAL))) 233 { 234 struct bfd_link_order *link_order; 235 236 link_order = bfd_new_link_order (output_bfd, output_section); 237 238 if (i->flags & SEC_NEVER_LOAD) 239 { 240 /* We've got a never load section inside one which 241 is going to be output, we'll change it into a 242 fill. */ 243 link_order->type = bfd_data_link_order; 244 link_order->u.data.contents = ""; 245 link_order->u.data.size = 1; 246 } 247 else 248 { 249 link_order->type = bfd_indirect_link_order; 250 link_order->u.indirect.section = i; 251 ASSERT (i->output_section == output_section); 252 } 253 if (i->_cooked_size) 254 link_order->size = i->_cooked_size; 255 else 256 link_order->size = bfd_get_section_size_before_reloc (i); 257 link_order->offset = i->output_offset; 258 } 259 } 260 break; 261 262 case lang_padding_statement_enum: 263 /* Make a new link_order with the right filler */ 264 { 265 asection *output_section; 266 struct bfd_link_order *link_order; 267 268 output_section = statement->padding_statement.output_section; 269 ASSERT (statement->padding_statement.output_section->owner 270 == output_bfd); 271 if ((output_section->flags & SEC_HAS_CONTENTS) != 0) 272 { 273 link_order = bfd_new_link_order (output_bfd, output_section); 274 link_order->type = bfd_data_link_order; 275 link_order->size = statement->padding_statement.size; 276 link_order->offset = statement->padding_statement.output_offset; 277 link_order->u.data.contents = statement->padding_statement.fill->data; 278 link_order->u.data.size = statement->padding_statement.fill->size; 279 } 280 } 281 break; 282 283 default: 284 /* All the other ones fall through */ 285 break; 286 } 287 } 288 289 /* Return true if NAME is the name of an unsplittable section. These 290 are the stabs strings, dwarf strings. */ 291 292 static bfd_boolean 293 unsplittable_name (const char *name) 294 { 295 if (strncmp (name, ".stab", 5) == 0) 296 { 297 /* There are several stab like string sections. We pattern match on 298 ".stab...str" */ 299 unsigned len = strlen (name); 300 if (strcmp (&name[len-3], "str") == 0) 301 return TRUE; 302 } 303 else if (strcmp (name, "$GDB_STRINGS$") == 0) 304 return TRUE; 305 return FALSE; 306 } 307 308 /* Wander around the input sections, make sure that 309 we'll never try and create an output section with more relocs 310 than will fit.. Do this by always assuming the worst case, and 311 creating new output sections with all the right bits. */ 312 #define TESTIT 1 313 static asection * 314 clone_section (bfd *abfd, asection *s, const char *name, int *count) 315 { 316 char *tname; 317 char *sname; 318 unsigned int len; 319 asection *n; 320 struct bfd_link_hash_entry *h; 321 322 /* Invent a section name from the section name and a dotted numeric 323 suffix. */ 324 len = strlen (name); 325 tname = xmalloc (len + 1); 326 memcpy (tname, name, len + 1); 327 /* Remove a dotted number suffix, from a previous split link. */ 328 while (len && ISDIGIT (tname[len-1])) 329 len--; 330 if (len > 1 && tname[len-1] == '.') 331 /* It was a dotted number. */ 332 tname[len-1] = 0; 333 334 /* We want to use the whole of the original section name for the 335 split name, but coff can be restricted to 8 character names. */ 336 if (bfd_family_coff (abfd) && strlen (tname) > 5) 337 { 338 /* Some section names cannot be truncated, as the name is 339 used to locate some other section. */ 340 if (strncmp (name, ".stab", 5) == 0 341 || strcmp (name, "$GDB_SYMBOLS$") == 0) 342 { 343 einfo (_ ("%F%P: cannot create split section name for %s\n"), name); 344 /* Silence gcc warnings. einfo exits, so we never reach here. */ 345 return NULL; 346 } 347 tname[5] = 0; 348 } 349 350 if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL 351 || (n = bfd_make_section_anyway (abfd, sname)) == NULL 352 || (h = bfd_link_hash_lookup (link_info.hash, 353 sname, TRUE, TRUE, FALSE)) == NULL) 354 { 355 einfo (_("%F%P: clone section failed: %E\n")); 356 /* Silence gcc warnings. einfo exits, so we never reach here. */ 357 return NULL; 358 } 359 free (tname); 360 361 /* Set up section symbol. */ 362 h->type = bfd_link_hash_defined; 363 h->u.def.value = 0; 364 h->u.def.section = n; 365 366 n->flags = s->flags; 367 n->vma = s->vma; 368 n->user_set_vma = s->user_set_vma; 369 n->lma = s->lma; 370 n->_cooked_size = 0; 371 n->_raw_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->link_order_head; 385 printf ("vma %x size %x\n", s->vma, s->_raw_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->link_order_head; 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->link_order_head; 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 if (sec->_cooked_size != 0) 472 thissize = sec->_cooked_size; 473 else 474 thissize = sec->_raw_size; 475 476 } 477 else if (info->relocatable 478 && (p->type == bfd_section_reloc_link_order 479 || p->type == bfd_symbol_reloc_link_order)) 480 thisrelocs++; 481 482 if (l != NULL 483 && (thisrelocs + relocs >= config.split_by_reloc 484 || thislines + lines >= config.split_by_reloc 485 || (thissize + sec_size >= config.split_by_file)) 486 && !unsplittable_name (cursor->name)) 487 { 488 /* Create a new section and put this link order and the 489 following link orders into it. */ 490 bfd_vma shift_offset; 491 asection *n; 492 493 n = clone_section (abfd, cursor, original_sec->name, &count); 494 495 /* Attach the link orders to the new section and snip 496 them off from the old section. */ 497 n->link_order_head = p; 498 n->link_order_tail = cursor->link_order_tail; 499 cursor->link_order_tail = l; 500 l->next = NULL; 501 l = p; 502 503 /* Change the size of the original section and 504 update the vma of the new one. */ 505 506 dump ("before snip", cursor, n); 507 508 shift_offset = p->offset; 509 if (cursor->_cooked_size != 0) 510 { 511 n->_cooked_size = cursor->_cooked_size - shift_offset; 512 cursor->_cooked_size = shift_offset; 513 } 514 n->_raw_size = cursor->_raw_size - shift_offset; 515 cursor->_raw_size = shift_offset; 516 517 vma += shift_offset; 518 n->lma = n->vma = vma; 519 520 /* Run down the chain and change the output section to 521 the right one, update the offsets too. */ 522 do 523 { 524 p->offset -= shift_offset; 525 if (p->type == bfd_indirect_link_order) 526 { 527 p->u.indirect.section->output_section = n; 528 p->u.indirect.section->output_offset = p->offset; 529 } 530 p = p->next; 531 } 532 while (p); 533 534 dump ("after snip", cursor, n); 535 cursor = n; 536 relocs = thisrelocs; 537 lines = thislines; 538 sec_size = thissize; 539 } 540 else 541 { 542 l = p; 543 relocs += thisrelocs; 544 lines += thislines; 545 sec_size += thissize; 546 } 547 } 548 } 549 sanity_check (abfd); 550 } 551 552 /* Call BFD to write out the linked file. */ 553 554 void 555 ldwrite (void) 556 { 557 /* Reset error indicator, which can typically something like invalid 558 format from opening up the .o files. */ 559 bfd_set_error (bfd_error_no_error); 560 lang_for_each_statement (build_link_order); 561 562 if (config.split_by_reloc != (unsigned) -1 563 || config.split_by_file != (bfd_size_type) -1) 564 split_sections (output_bfd, &link_info); 565 if (!bfd_final_link (output_bfd, &link_info)) 566 { 567 /* If there was an error recorded, print it out. Otherwise assume 568 an appropriate error message like unknown symbol was printed 569 out. */ 570 571 if (bfd_get_error () != bfd_error_no_error) 572 einfo (_("%F%P: final link failed: %E\n")); 573 else 574 xexit (1); 575 } 576 } 577