ld/ldwrite.c

   1 /* ldwrite.c -- write out the linked file
   2    Copyright (C) 1991-2018 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 (_("%F%P: 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 (_("%F%P: 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             if (link_order == NULL)
 258               einfo (_("%F%P: bfd_new_link_order failed\n"));
 259
 260             if ((i->flags & SEC_NEVER_LOAD) != 0
 261                 && (i->flags & SEC_DEBUGGING) == 0)
 262               {
 263                 /* We've got a never load section inside one which is
 264                    going to be output, we'll change it into a fill.  */
 265                 link_order->type = bfd_data_link_order;
 266                 link_order->u.data.contents = (unsigned char *) "";
 267                 link_order->u.data.size = 1;
 268               }
 269             else
 270               {
 271                 link_order->type = bfd_indirect_link_order;
 272                 link_order->u.indirect.section = i;
 273                 ASSERT (i->output_section == output_section);
 274               }
 275             link_order->size = i->size;
 276             link_order->offset = i->output_offset;
 277           }
 278       }
 279       break;
 280
 281     case lang_padding_statement_enum:
 282       /* Make a new link_order with the right filler */
 283       {
 284         asection *output_section;
 285         struct bfd_link_order *link_order;
 286
 287         output_section = statement->padding_statement.output_section;
 288         ASSERT (statement->padding_statement.output_section->owner
 289                 == link_info.output_bfd);
 290
 291         if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
 292               || ((output_section->flags & SEC_LOAD) != 0
 293                   && (output_section->flags & SEC_THREAD_LOCAL))))
 294           break;
 295
 296         link_order = bfd_new_link_order (link_info.output_bfd,
 297                                          output_section);
 298         if (link_order == NULL)
 299           einfo (_("%F%P: bfd_new_link_order failed\n"));
 300         link_order->type = bfd_data_link_order;
 301         link_order->size = statement->padding_statement.size;
 302         link_order->offset = statement->padding_statement.output_offset;
 303         link_order->u.data.contents = statement->padding_statement.fill->data;
 304         link_order->u.data.size = statement->padding_statement.fill->size;
 305       }
 306       break;
 307
 308     default:
 309       /* All the other ones fall through */
 310       break;
 311     }
 312 }
 313
 314 /* Return true if NAME is the name of an unsplittable section. These
 315    are the stabs strings, dwarf strings.  */
 316
 317 static bfd_boolean
 318 unsplittable_name (const char *name)
 319 {
 320   if (CONST_STRNEQ (name, ".stab"))
 321     {
 322       /* There are several stab like string sections. We pattern match on
 323          ".stab...str"  */
 324       unsigned len = strlen (name);
 325       if (strcmp (&name[len-3], "str") == 0)
 326         return TRUE;
 327     }
 328   else if (strcmp (name, "$GDB_STRINGS$") == 0)
 329     return TRUE;
 330   return FALSE;
 331 }
 332
 333 /* Wander around the input sections, make sure that
 334    we'll never try and create an output section with more relocs
 335    than will fit.. Do this by always assuming the worst case, and
 336    creating new output sections with all the right bits.  */
 337 #define TESTIT 1
 338 static asection *
 339 clone_section (bfd *abfd, asection *s, const char *name, int *count)
 340 {
 341   char *tname;
 342   char *sname;
 343   unsigned int len;
 344   asection *n;
 345   struct bfd_link_hash_entry *h;
 346
 347   /* Invent a section name from the section name and a dotted numeric
 348      suffix.   */
 349   len = strlen (name);
 350   tname = (char *) xmalloc (len + 1);
 351   memcpy (tname, name, len + 1);
 352   /* Remove a dotted number suffix, from a previous split link. */
 353   while (len && ISDIGIT (tname[len-1]))
 354     len--;
 355   if (len > 1 && tname[len-1] == '.')
 356     /* It was a dotted number. */
 357     tname[len-1] = 0;
 358
 359   /* We want to use the whole of the original section name for the
 360      split name, but coff can be restricted to 8 character names.  */
 361   if (bfd_family_coff (abfd) && strlen (tname) > 5)
 362     {
 363       /* Some section names cannot be truncated, as the name is
 364          used to locate some other section.  */
 365       if (CONST_STRNEQ (name, ".stab")
 366           || strcmp (name, "$GDB_SYMBOLS$") == 0)
 367         {
 368           einfo (_ ("%F%P: cannot create split section name for %s\n"), name);
 369           /* Silence gcc warnings.  einfo exits, so we never reach here.  */
 370           return NULL;
 371         }
 372       tname[5] = 0;
 373     }
 374
 375   if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL
 376       || (n = bfd_make_section_anyway (abfd, sname)) == NULL
 377       || (h = bfd_link_hash_lookup (link_info.hash,
 378                                     sname, TRUE, TRUE, FALSE)) == NULL)
 379     {
 380       einfo (_("%F%P: clone section failed: %E\n"));
 381       /* Silence gcc warnings.  einfo exits, so we never reach here.  */
 382       return NULL;
 383     }
 384   free (tname);
 385
 386   /* Set up section symbol.  */
 387   h->type = bfd_link_hash_defined;
 388   h->u.def.value = 0;
 389   h->u.def.section = n;
 390
 391   n->flags = s->flags;
 392   n->vma = s->vma;
 393   n->user_set_vma = s->user_set_vma;
 394   n->lma = s->lma;
 395   n->size = 0;
 396   n->output_offset = s->output_offset;
 397   n->output_section = n;
 398   n->orelocation = 0;
 399   n->reloc_count = 0;
 400   n->alignment_power = s->alignment_power;
 401
 402   bfd_copy_private_section_data (abfd, s, abfd, n);
 403
 404   return n;
 405 }
 406
 407 #if TESTING
 408 static void
 409 ds (asection *s)
 410 {
 411   struct bfd_link_order *l = s->map_head.link_order;
 412   printf ("vma %x size %x\n", s->vma, s->size);
 413   while (l)
 414     {
 415       if (l->type == bfd_indirect_link_order)
 416         printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
 417       else
 418         printf (_("%8x something else\n"), l->offset);
 419       l = l->next;
 420     }
 421   printf ("\n");
 422 }
 423
 424 dump (char *s, asection *a1, asection *a2)
 425 {
 426   printf ("%s\n", s);
 427   ds (a1);
 428   ds (a2);
 429 }
 430
 431 static void
 432 sanity_check (bfd *abfd)
 433 {
 434   asection *s;
 435   for (s = abfd->sections; s; s = s->next)
 436     {
 437       struct bfd_link_order *p;
 438       bfd_vma prev = 0;
 439       for (p = s->map_head.link_order; p; p = p->next)
 440         {
 441           if (p->offset > 100000)
 442             abort ();
 443           if (p->offset < prev)
 444             abort ();
 445           prev = p->offset;
 446         }
 447     }
 448 }
 449 #else
 450 #define sanity_check(a)
 451 #define dump(a, b, c)
 452 #endif
 453
 454 static void
 455 split_sections (bfd *abfd, struct bfd_link_info *info)
 456 {
 457   asection *original_sec;
 458   int nsecs = abfd->section_count;
 459   sanity_check (abfd);
 460   /* Look through all the original sections.  */
 461   for (original_sec = abfd->sections;
 462        original_sec && nsecs;
 463        original_sec = original_sec->next, nsecs--)
 464     {
 465       int count = 0;
 466       unsigned int lines = 0;
 467       unsigned int relocs = 0;
 468       bfd_size_type sec_size = 0;
 469       struct bfd_link_order *l;
 470       struct bfd_link_order *p;
 471       bfd_vma vma = original_sec->vma;
 472       asection *cursor = original_sec;
 473
 474       /* Count up the relocations and line entries to see if anything
 475          would be too big to fit.  Accumulate section size too.  */
 476       for (l = NULL, p = cursor->map_head.link_order; p != NULL; p = l->next)
 477         {
 478           unsigned int thislines = 0;
 479           unsigned int thisrelocs = 0;
 480           bfd_size_type thissize = 0;
 481           if (p->type == bfd_indirect_link_order)
 482             {
 483               asection *sec;
 484
 485               sec = p->u.indirect.section;
 486
 487               if (info->strip == strip_none
 488                   || info->strip == strip_some)
 489                 thislines = sec->lineno_count;
 490
 491               if (bfd_link_relocatable (info))
 492                 thisrelocs = sec->reloc_count;
 493
 494               thissize = sec->size;
 495
 496             }
 497           else if (bfd_link_relocatable (info)
 498                    && (p->type == bfd_section_reloc_link_order
 499                        || p->type == bfd_symbol_reloc_link_order))
 500             thisrelocs++;
 501
 502           if (l != NULL
 503               && (thisrelocs + relocs >= config.split_by_reloc
 504                   || thislines + lines >= config.split_by_reloc
 505                   || (thissize + sec_size >= config.split_by_file))
 506               && !unsplittable_name (cursor->name))
 507             {
 508               /* Create a new section and put this link order and the
 509                  following link orders into it.  */
 510               bfd_vma shift_offset;
 511               asection *n;
 512
 513               n = clone_section (abfd, cursor, original_sec->name, &count);
 514
 515               /* Attach the link orders to the new section and snip
 516                  them off from the old section.  */
 517               n->map_head.link_order = p;
 518               n->map_tail.link_order = cursor->map_tail.link_order;
 519               cursor->map_tail.link_order = l;
 520               l->next = NULL;
 521               l = p;
 522
 523               /* Change the size of the original section and
 524                  update the vma of the new one.  */
 525
 526               dump ("before snip", cursor, n);
 527
 528               shift_offset = p->offset;
 529               n->size = cursor->size - shift_offset;
 530               cursor->size = shift_offset;
 531
 532               vma += shift_offset;
 533               n->lma = n->vma = vma;
 534
 535               /* Run down the chain and change the output section to
 536                  the right one, update the offsets too.  */
 537               do
 538                 {
 539                   p->offset -= shift_offset;
 540                   if (p->type == bfd_indirect_link_order)
 541                     {
 542                       p->u.indirect.section->output_section = n;
 543                       p->u.indirect.section->output_offset = p->offset;
 544                     }
 545                   p = p->next;
 546                 }
 547               while (p);
 548
 549               dump ("after snip", cursor, n);
 550               cursor = n;
 551               relocs = thisrelocs;
 552               lines = thislines;
 553               sec_size = thissize;
 554             }
 555           else
 556             {
 557               l = p;
 558               relocs += thisrelocs;
 559               lines += thislines;
 560               sec_size += thissize;
 561             }
 562         }
 563     }
 564   sanity_check (abfd);
 565 }
 566
 567 /* Call BFD to write out the linked file.  */
 568
 569 void
 570 ldwrite (void)
 571 {
 572   /* Reset error indicator, which can typically something like invalid
 573      format from opening up the .o files.  */
 574   bfd_set_error (bfd_error_no_error);
 575   lang_clear_os_map ();
 576   lang_for_each_statement (build_link_order);
 577
 578   if (config.split_by_reloc != (unsigned) -1
 579       || config.split_by_file != (bfd_size_type) -1)
 580     split_sections (link_info.output_bfd, &link_info);
 581   if (!bfd_final_link (link_info.output_bfd, &link_info))
 582     {
 583       /* If there was an error recorded, print it out.  Otherwise assume
 584          an appropriate error message like unknown symbol was printed
 585          out.  */
 586
 587       if (bfd_get_error () != bfd_error_no_error)
 588         einfo (_("%F%P: final link failed: %E\n"));
 589       else
 590         xexit (1);
 591     }
 592 }