ld/ldwrite.c

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