ld/ldwrite.c

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