toolchain/binutils/ld/ldwrite.c

   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 }