ld/ldlang.c

   1 /* Linker command language support.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GLD, the Gnu Linker.
   7
   8    GLD 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, or (at your option)
  11    any later version.
  12
  13    GLD 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 GLD; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libiberty.h"
  26 #include "safe-ctype.h"
  27 #include "obstack.h"
  28 #include "bfdlink.h"
  29
  30 #include "ld.h"
  31 #include "ldmain.h"
  32 #include "ldexp.h"
  33 #include "ldlang.h"
  34 #include <ldgram.h>
  35 #include "ldlex.h"
  36 #include "ldmisc.h"
  37 #include "ldctor.h"
  38 #include "ldfile.h"
  39 #include "ldemul.h"
  40 #include "fnmatch.h"
  41 #include "demangle.h"
  42 #include "hashtab.h"
  43
  44 #ifndef offsetof
  45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
  46 #endif
  47
  48 /* Locals variables.  */
  49 static struct obstack stat_obstack;
  50 static struct obstack map_obstack;
  51
  52 #define obstack_chunk_alloc xmalloc
  53 #define obstack_chunk_free free
  54 static const char *startup_file;
  55 static lang_statement_list_type input_file_chain;
  56 static bfd_boolean placed_commons = FALSE;
  57 static bfd_boolean stripped_excluded_sections = FALSE;
  58 static lang_output_section_statement_type *default_common_section;
  59 static bfd_boolean map_option_f;
  60 static bfd_vma print_dot;
  61 static lang_input_statement_type *first_file;
  62 static const char *current_target;
  63 static const char *output_target;
  64 static lang_statement_list_type statement_list;
  65 static struct lang_phdr *lang_phdr_list;
  66 static struct bfd_hash_table lang_definedness_table;
  67
  68 /* Forward declarations.  */
  69 static void exp_init_os (etree_type *);
  70 static void init_map_userdata (bfd *, asection *, void *);
  71 static lang_input_statement_type *lookup_name (const char *);
  72 static bfd_boolean load_symbols (lang_input_statement_type *,
  73                                  lang_statement_list_type *);
  74 static struct bfd_hash_entry *lang_definedness_newfunc
  75  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
  76 static void insert_undefined (const char *);
  77 static void print_all_symbols (asection *);
  78 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
  79 static void print_statement (lang_statement_union_type *,
  80                              lang_output_section_statement_type *);
  81 static void print_statement_list (lang_statement_union_type *,
  82                                   lang_output_section_statement_type *);
  83 static void print_statements (void);
  84 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
  85 static void lang_record_phdrs (void);
  86 static void lang_do_version_exports_section (void);
  87
  88 /* Exported variables.  */
  89 lang_output_section_statement_type *abs_output_section;
  90 lang_statement_list_type lang_output_section_statement;
  91 lang_statement_list_type *stat_ptr = &statement_list;
  92 lang_statement_list_type file_chain = { NULL, NULL };
  93 struct bfd_sym_chain entry_symbol = { NULL, NULL };
  94 static const char *entry_symbol_default = "start";
  95 const char *entry_section = ".text";
  96 bfd_boolean entry_from_cmdline;
  97 bfd_boolean lang_has_input_file = FALSE;
  98 bfd_boolean had_output_filename = FALSE;
  99 bfd_boolean lang_float_flag = FALSE;
 100 bfd_boolean delete_output_file_on_failure = FALSE;
 101 struct lang_nocrossrefs *nocrossref_list;
 102 static struct unique_sections *unique_section_list;
 103 static bfd_boolean ldlang_sysrooted_script = FALSE;
 104
 105  /* Functions that traverse the linker script and might evaluate
 106     DEFINED() need to increment this.  */
 107 int lang_statement_iteration = 0;
 108
 109 etree_type *base; /* Relocation base - or null */
 110
 111 /* Return TRUE if the PATTERN argument is a wildcard pattern.
 112    Although backslashes are treated specially if a pattern contains
 113    wildcards, we do not consider the mere presence of a backslash to
 114    be enough to cause the pattern to be treated as a wildcard.
 115    That lets us handle DOS filenames more naturally.  */
 116 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
 117
 118 #define new_stat(x, y) \
 119   (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
 120
 121 #define outside_section_address(q) \
 122   ((q)->output_offset + (q)->output_section->vma)
 123
 124 #define outside_symbol_address(q) \
 125   ((q)->value + outside_section_address (q->section))
 126
 127 #define SECTION_NAME_MAP_LENGTH (16)
 128
 129 void *
 130 stat_alloc (size_t size)
 131 {
 132   return obstack_alloc (&stat_obstack, size);
 133 }
 134
 135 bfd_boolean
 136 unique_section_p (const asection *sec)
 137 {
 138   struct unique_sections *unam;
 139   const char *secnam;
 140
 141   if (link_info.relocatable
 142       && sec->owner != NULL
 143       && bfd_is_group_section (sec->owner, sec))
 144     return TRUE;
 145
 146   secnam = sec->name;
 147   for (unam = unique_section_list; unam; unam = unam->next)
 148     if (wildcardp (unam->name)
 149         ? fnmatch (unam->name, secnam, 0) == 0
 150         : strcmp (unam->name, secnam) == 0)
 151       {
 152         return TRUE;
 153       }
 154
 155   return FALSE;
 156 }
 157
 158 /* Generic traversal routines for finding matching sections.  */
 159
 160 /* Try processing a section against a wildcard.  This just calls
 161    the callback unless the filename exclusion list is present
 162    and excludes the file.  It's hardly ever present so this
 163    function is very fast.  */
 164
 165 static void
 166 walk_wild_consider_section (lang_wild_statement_type *ptr,
 167                             lang_input_statement_type *file,
 168                             asection *s,
 169                             struct wildcard_list *sec,
 170                             callback_t callback,
 171                             void *data)
 172 {
 173   bfd_boolean skip = FALSE;
 174   struct name_list *list_tmp;
 175
 176   /* Don't process sections from files which were
 177      excluded.  */
 178   for (list_tmp = sec->spec.exclude_name_list;
 179        list_tmp;
 180        list_tmp = list_tmp->next)
 181     {
 182       bfd_boolean is_wildcard = wildcardp (list_tmp->name);
 183       if (is_wildcard)
 184         skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
 185       else
 186         skip = strcmp (list_tmp->name, file->filename) == 0;
 187
 188       /* If this file is part of an archive, and the archive is
 189          excluded, exclude this file.  */
 190       if (! skip && file->the_bfd != NULL
 191           && file->the_bfd->my_archive != NULL
 192           && file->the_bfd->my_archive->filename != NULL)
 193         {
 194           if (is_wildcard)
 195             skip = fnmatch (list_tmp->name,
 196                             file->the_bfd->my_archive->filename,
 197                             0) == 0;
 198           else
 199             skip = strcmp (list_tmp->name,
 200                            file->the_bfd->my_archive->filename) == 0;
 201         }
 202
 203       if (skip)
 204         break;
 205     }
 206
 207   if (!skip)
 208     (*callback) (ptr, sec, s, file, data);
 209 }
 210
 211 /* Lowest common denominator routine that can handle everything correctly,
 212    but slowly.  */
 213
 214 static void
 215 walk_wild_section_general (lang_wild_statement_type *ptr,
 216                            lang_input_statement_type *file,
 217                            callback_t callback,
 218                            void *data)
 219 {
 220   asection *s;
 221   struct wildcard_list *sec;
 222
 223   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 224     {
 225       sec = ptr->section_list;
 226       if (sec == NULL)
 227         (*callback) (ptr, sec, s, file, data);
 228
 229       while (sec != NULL)
 230         {
 231           bfd_boolean skip = FALSE;
 232
 233           if (sec->spec.name != NULL)
 234             {
 235               const char *sname = bfd_get_section_name (file->the_bfd, s);
 236
 237               if (wildcardp (sec->spec.name))
 238                 skip = fnmatch (sec->spec.name, sname, 0) != 0;
 239               else
 240                 skip = strcmp (sec->spec.name, sname) != 0;
 241             }
 242
 243           if (!skip)
 244             walk_wild_consider_section (ptr, file, s, sec, callback, data);
 245
 246           sec = sec->next;
 247         }
 248     }
 249 }
 250
 251 /* Routines to find a single section given its name.  If there's more
 252    than one section with that name, we report that.  */
 253
 254 typedef struct
 255 {
 256   asection *found_section;
 257   bfd_boolean multiple_sections_found;
 258 } section_iterator_callback_data;
 259
 260 static bfd_boolean
 261 section_iterator_callback (bfd *bfd ATTRIBUTE_UNUSED, asection *s, void *data)
 262 {
 263   section_iterator_callback_data *d = data;
 264
 265   if (d->found_section != NULL)
 266     {
 267       d->multiple_sections_found = TRUE;
 268       return TRUE;
 269     }
 270
 271   d->found_section = s;
 272   return FALSE;
 273 }
 274
 275 static asection *
 276 find_section (lang_input_statement_type *file,
 277               struct wildcard_list *sec,
 278               bfd_boolean *multiple_sections_found)
 279 {
 280   section_iterator_callback_data cb_data = { NULL, FALSE };
 281
 282   bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
 283                               section_iterator_callback, &cb_data);
 284   *multiple_sections_found = cb_data.multiple_sections_found;
 285   return cb_data.found_section;
 286 }
 287
 288 /* Code for handling simple wildcards without going through fnmatch,
 289    which can be expensive because of charset translations etc.  */
 290
 291 /* A simple wild is a literal string followed by a single '*',
 292    where the literal part is at least 4 characters long.  */
 293
 294 static bfd_boolean
 295 is_simple_wild (const char *name)
 296 {
 297   size_t len = strcspn (name, "*?[");
 298   return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
 299 }
 300
 301 static bfd_boolean
 302 match_simple_wild (const char *pattern, const char *name)
 303 {
 304   /* The first four characters of the pattern are guaranteed valid
 305      non-wildcard characters.  So we can go faster.  */
 306   if (pattern[0] != name[0] || pattern[1] != name[1]
 307       || pattern[2] != name[2] || pattern[3] != name[3])
 308     return FALSE;
 309
 310   pattern += 4;
 311   name += 4;
 312   while (*pattern != '*')
 313     if (*name++ != *pattern++)
 314       return FALSE;
 315
 316   return TRUE;
 317 }
 318
 319 /* Specialized, optimized routines for handling different kinds of
 320    wildcards */
 321
 322 static void
 323 walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
 324                                 lang_input_statement_type *file,
 325                                 callback_t callback,
 326                                 void *data)
 327 {
 328   /* We can just do a hash lookup for the section with the right name.
 329      But if that lookup discovers more than one section with the name
 330      (should be rare), we fall back to the general algorithm because
 331      we would otherwise have to sort the sections to make sure they
 332      get processed in the bfd's order.  */
 333   bfd_boolean multiple_sections_found;
 334   struct wildcard_list *sec0 = ptr->handler_data[0];
 335   asection *s0 = find_section (file, sec0, &multiple_sections_found);
 336
 337   if (multiple_sections_found)
 338     walk_wild_section_general (ptr, file, callback, data);
 339   else if (s0)
 340     walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
 341 }
 342
 343 static void
 344 walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
 345                                 lang_input_statement_type *file,
 346                                 callback_t callback,
 347                                 void *data)
 348 {
 349   asection *s;
 350   struct wildcard_list *wildsec0 = ptr->handler_data[0];
 351
 352   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 353     {
 354       const char *sname = bfd_get_section_name (file->the_bfd, s);
 355       bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
 356
 357       if (!skip)
 358         walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
 359     }
 360 }
 361
 362 static void
 363 walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
 364                                 lang_input_statement_type *file,
 365                                 callback_t callback,
 366                                 void *data)
 367 {
 368   asection *s;
 369   struct wildcard_list *sec0 = ptr->handler_data[0];
 370   struct wildcard_list *wildsec1 = ptr->handler_data[1];
 371   bfd_boolean multiple_sections_found;
 372   asection *s0 = find_section (file, sec0, &multiple_sections_found);
 373
 374   if (multiple_sections_found)
 375     {
 376       walk_wild_section_general (ptr, file, callback, data);
 377       return;
 378     }
 379
 380   /* Note that if the section was not found, s0 is NULL and
 381      we'll simply never succeed the s == s0 test below.  */
 382   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 383     {
 384       /* Recall that in this code path, a section cannot satisfy more
 385          than one spec, so if s == s0 then it cannot match
 386          wildspec1.  */
 387       if (s == s0)
 388         walk_wild_consider_section (ptr, file, s, sec0, callback, data);
 389       else
 390         {
 391           const char *sname = bfd_get_section_name (file->the_bfd, s);
 392           bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
 393
 394           if (!skip)
 395             walk_wild_consider_section (ptr, file, s, wildsec1, callback,
 396                                         data);
 397         }
 398     }
 399 }
 400
 401 static void
 402 walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
 403                                 lang_input_statement_type *file,
 404                                 callback_t callback,
 405                                 void *data)
 406 {
 407   asection *s;
 408   struct wildcard_list *sec0 = ptr->handler_data[0];
 409   struct wildcard_list *wildsec1 = ptr->handler_data[1];
 410   struct wildcard_list *wildsec2 = ptr->handler_data[2];
 411   bfd_boolean multiple_sections_found;
 412   asection *s0 = find_section (file, sec0, &multiple_sections_found);
 413
 414   if (multiple_sections_found)
 415     {
 416       walk_wild_section_general (ptr, file, callback, data);
 417       return;
 418     }
 419
 420   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 421     {
 422       if (s == s0)
 423         walk_wild_consider_section (ptr, file, s, sec0, callback, data);
 424       else
 425         {
 426           const char *sname = bfd_get_section_name (file->the_bfd, s);
 427           bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
 428
 429           if (!skip)
 430             walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
 431           else
 432             {
 433               skip = !match_simple_wild (wildsec2->spec.name, sname);
 434               if (!skip)
 435                 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
 436                                             data);
 437             }
 438         }
 439     }
 440 }
 441
 442 static void
 443 walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
 444                                 lang_input_statement_type *file,
 445                                 callback_t callback,
 446                                 void *data)
 447 {
 448   asection *s;
 449   struct wildcard_list *sec0 = ptr->handler_data[0];
 450   struct wildcard_list *sec1 = ptr->handler_data[1];
 451   struct wildcard_list *wildsec2 = ptr->handler_data[2];
 452   struct wildcard_list *wildsec3 = ptr->handler_data[3];
 453   bfd_boolean multiple_sections_found;
 454   asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
 455
 456   if (multiple_sections_found)
 457     {
 458       walk_wild_section_general (ptr, file, callback, data);
 459       return;
 460     }
 461
 462   s1 = find_section (file, sec1, &multiple_sections_found);
 463   if (multiple_sections_found)
 464     {
 465       walk_wild_section_general (ptr, file, callback, data);
 466       return;
 467     }
 468
 469   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 470     {
 471       if (s == s0)
 472         walk_wild_consider_section (ptr, file, s, sec0, callback, data);
 473       else
 474         if (s == s1)
 475           walk_wild_consider_section (ptr, file, s, sec1, callback, data);
 476         else
 477           {
 478             const char *sname = bfd_get_section_name (file->the_bfd, s);
 479             bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
 480                                                    sname);
 481
 482             if (!skip)
 483               walk_wild_consider_section (ptr, file, s, wildsec2, callback,
 484                                           data);
 485             else
 486               {
 487                 skip = !match_simple_wild (wildsec3->spec.name, sname);
 488                 if (!skip)
 489                   walk_wild_consider_section (ptr, file, s, wildsec3,
 490                                               callback, data);
 491               }
 492           }
 493     }
 494 }
 495
 496 static void
 497 walk_wild_section (lang_wild_statement_type *ptr,
 498                    lang_input_statement_type *file,
 499                    callback_t callback,
 500                    void *data)
 501 {
 502   if (file->just_syms_flag)
 503     return;
 504
 505   (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
 506 }
 507
 508 /* Returns TRUE when name1 is a wildcard spec that might match
 509    something name2 can match.  We're conservative: we return FALSE
 510    only if the prefixes of name1 and name2 are different up to the
 511    first wildcard character.  */
 512
 513 static bfd_boolean
 514 wild_spec_can_overlap (const char *name1, const char *name2)
 515 {
 516   size_t prefix1_len = strcspn (name1, "?*[");
 517   size_t prefix2_len = strcspn (name2, "?*[");
 518   size_t min_prefix_len;
 519
 520   /* Note that if there is no wildcard character, then we treat the
 521      terminating 0 as part of the prefix.  Thus ".text" won't match
 522      ".text." or ".text.*", for example.  */
 523   if (name1[prefix1_len] == '\0')
 524     prefix1_len++;
 525   if (name2[prefix2_len] == '\0')
 526     prefix2_len++;
 527
 528   min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
 529
 530   return memcmp (name1, name2, min_prefix_len) == 0;
 531 }
 532
 533 /* Select specialized code to handle various kinds of wildcard
 534    statements.  */
 535
 536 static void
 537 analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
 538 {
 539   int sec_count = 0;
 540   int wild_name_count = 0;
 541   struct wildcard_list *sec;
 542   int signature;
 543   int data_counter;
 544
 545   ptr->walk_wild_section_handler = walk_wild_section_general;
 546
 547   /* Count how many wildcard_specs there are, and how many of those
 548      actually use wildcards in the name.  Also, bail out if any of the
 549      wildcard names are NULL. (Can this actually happen?
 550      walk_wild_section used to test for it.)  And bail out if any
 551      of the wildcards are more complex than a simple string
 552      ending in a single '*'.  */
 553   for (sec = ptr->section_list; sec != NULL; sec = sec->next)
 554     {
 555       ++sec_count;
 556       if (sec->spec.name == NULL)
 557         return;
 558       if (wildcardp (sec->spec.name))
 559         {
 560           ++wild_name_count;
 561           if (!is_simple_wild (sec->spec.name))
 562             return;
 563         }
 564     }
 565
 566   /* The zero-spec case would be easy to optimize but it doesn't
 567      happen in practice.  Likewise, more than 4 specs doesn't
 568      happen in practice.  */
 569   if (sec_count == 0 || sec_count > 4)
 570     return;
 571
 572   /* Check that no two specs can match the same section.  */
 573   for (sec = ptr->section_list; sec != NULL; sec = sec->next)
 574     {
 575       struct wildcard_list *sec2;
 576       for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
 577         {
 578           if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
 579             return;
 580         }
 581     }
 582
 583   signature = (sec_count << 8) + wild_name_count;
 584   switch (signature)
 585     {
 586     case 0x0100:
 587       ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
 588       break;
 589     case 0x0101:
 590       ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
 591       break;
 592     case 0x0201:
 593       ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
 594       break;
 595     case 0x0302:
 596       ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
 597       break;
 598     case 0x0402:
 599       ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
 600       break;
 601     default:
 602       return;
 603     }
 604
 605   /* Now fill the data array with pointers to the specs, first the
 606      specs with non-wildcard names, then the specs with wildcard
 607      names.  It's OK to process the specs in different order from the
 608      given order, because we've already determined that no section
 609      will match more than one spec.  */
 610   data_counter = 0;
 611   for (sec = ptr->section_list; sec != NULL; sec = sec->next)
 612     if (!wildcardp (sec->spec.name))
 613       ptr->handler_data[data_counter++] = sec;
 614   for (sec = ptr->section_list; sec != NULL; sec = sec->next)
 615     if (wildcardp (sec->spec.name))
 616       ptr->handler_data[data_counter++] = sec;
 617 }
 618
 619 /* Handle a wild statement for a single file F.  */
 620
 621 static void
 622 walk_wild_file (lang_wild_statement_type *s,
 623                 lang_input_statement_type *f,
 624                 callback_t callback,
 625                 void *data)
 626 {
 627   if (f->the_bfd == NULL
 628       || ! bfd_check_format (f->the_bfd, bfd_archive))
 629     walk_wild_section (s, f, callback, data);
 630   else
 631     {
 632       bfd *member;
 633
 634       /* This is an archive file.  We must map each member of the
 635          archive separately.  */
 636       member = bfd_openr_next_archived_file (f->the_bfd, NULL);
 637       while (member != NULL)
 638         {
 639           /* When lookup_name is called, it will call the add_symbols
 640              entry point for the archive.  For each element of the
 641              archive which is included, BFD will call ldlang_add_file,
 642              which will set the usrdata field of the member to the
 643              lang_input_statement.  */
 644           if (member->usrdata != NULL)
 645             {
 646               walk_wild_section (s, member->usrdata, callback, data);
 647             }
 648
 649           member = bfd_openr_next_archived_file (f->the_bfd, member);
 650         }
 651     }
 652 }
 653
 654 static void
 655 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
 656 {
 657   const char *file_spec = s->filename;
 658
 659   if (file_spec == NULL)
 660     {
 661       /* Perform the iteration over all files in the list.  */
 662       LANG_FOR_EACH_INPUT_STATEMENT (f)
 663         {
 664           walk_wild_file (s, f, callback, data);
 665         }
 666     }
 667   else if (wildcardp (file_spec))
 668     {
 669       LANG_FOR_EACH_INPUT_STATEMENT (f)
 670         {
 671           if (fnmatch (file_spec, f->filename, FNM_FILE_NAME) == 0)
 672             walk_wild_file (s, f, callback, data);
 673         }
 674     }
 675   else
 676     {
 677       lang_input_statement_type *f;
 678
 679       /* Perform the iteration over a single file.  */
 680       f = lookup_name (file_spec);
 681       if (f)
 682         walk_wild_file (s, f, callback, data);
 683     }
 684 }
 685
 686 /* lang_for_each_statement walks the parse tree and calls the provided
 687    function for each node.  */
 688
 689 static void
 690 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
 691                                 lang_statement_union_type *s)
 692 {
 693   for (; s != NULL; s = s->header.next)
 694     {
 695       func (s);
 696
 697       switch (s->header.type)
 698         {
 699         case lang_constructors_statement_enum:
 700           lang_for_each_statement_worker (func, constructor_list.head);
 701           break;
 702         case lang_output_section_statement_enum:
 703           lang_for_each_statement_worker
 704             (func, s->output_section_statement.children.head);
 705           break;
 706         case lang_wild_statement_enum:
 707           lang_for_each_statement_worker (func,
 708                                           s->wild_statement.children.head);
 709           break;
 710         case lang_group_statement_enum:
 711           lang_for_each_statement_worker (func,
 712                                           s->group_statement.children.head);
 713           break;
 714         case lang_data_statement_enum:
 715         case lang_reloc_statement_enum:
 716         case lang_object_symbols_statement_enum:
 717         case lang_output_statement_enum:
 718         case lang_target_statement_enum:
 719         case lang_input_section_enum:
 720         case lang_input_statement_enum:
 721         case lang_assignment_statement_enum:
 722         case lang_padding_statement_enum:
 723         case lang_address_statement_enum:
 724         case lang_fill_statement_enum:
 725           break;
 726         default:
 727           FAIL ();
 728           break;
 729         }
 730     }
 731 }
 732
 733 void
 734 lang_for_each_statement (void (*func) (lang_statement_union_type *))
 735 {
 736   lang_for_each_statement_worker (func, statement_list.head);
 737 }
 738
 739 /*----------------------------------------------------------------------*/
 740
 741 void
 742 lang_list_init (lang_statement_list_type *list)
 743 {
 744   list->head = NULL;
 745   list->tail = &list->head;
 746 }
 747
 748 /* Build a new statement node for the parse tree.  */
 749
 750 static lang_statement_union_type *
 751 new_statement (enum statement_enum type,
 752                size_t size,
 753                lang_statement_list_type *list)
 754 {
 755   lang_statement_union_type *new;
 756
 757   new = stat_alloc (size);
 758   new->header.type = type;
 759   new->header.next = NULL;
 760   lang_statement_append (list, new, &new->header.next);
 761   return new;
 762 }
 763
 764 /* Build a new input file node for the language.  There are several
 765    ways in which we treat an input file, eg, we only look at symbols,
 766    or prefix it with a -l etc.
 767
 768    We can be supplied with requests for input files more than once;
 769    they may, for example be split over several lines like foo.o(.text)
 770    foo.o(.data) etc, so when asked for a file we check that we haven't
 771    got it already so we don't duplicate the bfd.  */
 772
 773 static lang_input_statement_type *
 774 new_afile (const char *name,
 775            lang_input_file_enum_type file_type,
 776            const char *target,
 777            bfd_boolean add_to_list)
 778 {
 779   lang_input_statement_type *p;
 780
 781   if (add_to_list)
 782     p = new_stat (lang_input_statement, stat_ptr);
 783   else
 784     {
 785       p = stat_alloc (sizeof (lang_input_statement_type));
 786       p->header.next = NULL;
 787     }
 788
 789   lang_has_input_file = TRUE;
 790   p->target = target;
 791   p->sysrooted = FALSE;
 792   switch (file_type)
 793     {
 794     case lang_input_file_is_symbols_only_enum:
 795       p->filename = name;
 796       p->is_archive = FALSE;
 797       p->real = TRUE;
 798       p->local_sym_name = name;
 799       p->just_syms_flag = TRUE;
 800       p->search_dirs_flag = FALSE;
 801       break;
 802     case lang_input_file_is_fake_enum:
 803       p->filename = name;
 804       p->is_archive = FALSE;
 805       p->real = FALSE;
 806       p->local_sym_name = name;
 807       p->just_syms_flag = FALSE;
 808       p->search_dirs_flag = FALSE;
 809       break;
 810     case lang_input_file_is_l_enum:
 811       p->is_archive = TRUE;
 812       p->filename = name;
 813       p->real = TRUE;
 814       p->local_sym_name = concat ("-l", name, NULL);
 815       p->just_syms_flag = FALSE;
 816       p->search_dirs_flag = TRUE;
 817       break;
 818     case lang_input_file_is_marker_enum:
 819       p->filename = name;
 820       p->is_archive = FALSE;
 821       p->real = FALSE;
 822       p->local_sym_name = name;
 823       p->just_syms_flag = FALSE;
 824       p->search_dirs_flag = TRUE;
 825       break;
 826     case lang_input_file_is_search_file_enum:
 827       p->sysrooted = ldlang_sysrooted_script;
 828       p->filename = name;
 829       p->is_archive = FALSE;
 830       p->real = TRUE;
 831       p->local_sym_name = name;
 832       p->just_syms_flag = FALSE;
 833       p->search_dirs_flag = TRUE;
 834       break;
 835     case lang_input_file_is_file_enum:
 836       p->filename = name;
 837       p->is_archive = FALSE;
 838       p->real = TRUE;
 839       p->local_sym_name = name;
 840       p->just_syms_flag = FALSE;
 841       p->search_dirs_flag = FALSE;
 842       break;
 843     default:
 844       FAIL ();
 845     }
 846   p->the_bfd = NULL;
 847   p->asymbols = NULL;
 848   p->next_real_file = NULL;
 849   p->next = NULL;
 850   p->symbol_count = 0;
 851   p->dynamic = config.dynamic_link;
 852   p->add_needed = add_needed;
 853   p->as_needed = as_needed;
 854   p->whole_archive = whole_archive;
 855   p->loaded = FALSE;
 856   lang_statement_append (&input_file_chain,
 857                          (lang_statement_union_type *) p,
 858                          &p->next_real_file);
 859   return p;
 860 }
 861
 862 lang_input_statement_type *
 863 lang_add_input_file (const char *name,
 864                      lang_input_file_enum_type file_type,
 865                      const char *target)
 866 {
 867   lang_has_input_file = TRUE;
 868   return new_afile (name, file_type, target, TRUE);
 869 }
 870
 871 /* Build enough state so that the parser can build its tree.  */
 872
 873 void
 874 lang_init (void)
 875 {
 876   obstack_begin (&stat_obstack, 1000);
 877
 878   stat_ptr = &statement_list;
 879
 880   lang_list_init (stat_ptr);
 881
 882   lang_list_init (&input_file_chain);
 883   lang_list_init (&lang_output_section_statement);
 884   lang_list_init (&file_chain);
 885   first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
 886                                     NULL);
 887   abs_output_section =
 888     lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
 889
 890   abs_output_section->bfd_section = bfd_abs_section_ptr;
 891
 892   /* The value "3" is ad-hoc, somewhat related to the expected number of
 893      DEFINED expressions in a linker script.  For most default linker
 894      scripts, there are none.  Why a hash table then?  Well, it's somewhat
 895      simpler to re-use working machinery than using a linked list in terms
 896      of code-complexity here in ld, besides the initialization which just
 897      looks like other code here.  */
 898   if (!bfd_hash_table_init_n (&lang_definedness_table,
 899                               lang_definedness_newfunc, 3))
 900     einfo (_("%P%F: out of memory during initialization"));
 901 }
 902
 903 /*----------------------------------------------------------------------
 904   A region is an area of memory declared with the
 905   MEMORY {  name:org=exp, len=exp ... }
 906   syntax.
 907
 908   We maintain a list of all the regions here.
 909
 910   If no regions are specified in the script, then the default is used
 911   which is created when looked up to be the entire data space.
 912
 913   If create is true we are creating a region inside a MEMORY block.
 914   In this case it is probably an error to create a region that has
 915   already been created.  If we are not inside a MEMORY block it is
 916   dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
 917   and so we issue a warning.  */
 918
 919 static lang_memory_region_type *lang_memory_region_list;
 920 static lang_memory_region_type **lang_memory_region_list_tail
 921   = &lang_memory_region_list;
 922
 923 lang_memory_region_type *
 924 lang_memory_region_lookup (const char *const name, bfd_boolean create)
 925 {
 926   lang_memory_region_type *p;
 927   lang_memory_region_type *new;
 928
 929   /* NAME is NULL for LMA memspecs if no region was specified.  */
 930   if (name == NULL)
 931     return NULL;
 932
 933   for (p = lang_memory_region_list; p != NULL; p = p->next)
 934     if (strcmp (p->name, name) == 0)
 935       {
 936         if (create)
 937           einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
 938                  name);
 939         return p;
 940       }
 941
 942   if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
 943     einfo (_("%P:%S: warning: memory region %s not declared\n"), name);
 944
 945   new = stat_alloc (sizeof (lang_memory_region_type));
 946
 947   new->name = xstrdup (name);
 948   new->next = NULL;
 949
 950   *lang_memory_region_list_tail = new;
 951   lang_memory_region_list_tail = &new->next;
 952   new->origin = 0;
 953   new->flags = 0;
 954   new->not_flags = 0;
 955   new->length = ~(bfd_size_type) 0;
 956   new->current = 0;
 957   new->had_full_message = FALSE;
 958
 959   return new;
 960 }
 961
 962 static lang_memory_region_type *
 963 lang_memory_default (asection *section)
 964 {
 965   lang_memory_region_type *p;
 966
 967   flagword sec_flags = section->flags;
 968
 969   /* Override SEC_DATA to mean a writable section.  */
 970   if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
 971     sec_flags |= SEC_DATA;
 972
 973   for (p = lang_memory_region_list; p != NULL; p = p->next)
 974     {
 975       if ((p->flags & sec_flags) != 0
 976           && (p->not_flags & sec_flags) == 0)
 977         {
 978           return p;
 979         }
 980     }
 981   return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
 982 }
 983
 984 static lang_output_section_statement_type *
 985 lang_output_section_find_1 (const char *const name, int constraint)
 986 {
 987   lang_output_section_statement_type *lookup;
 988
 989   for (lookup = &lang_output_section_statement.head->output_section_statement;
 990        lookup != NULL;
 991        lookup = lookup->next)
 992     {
 993       if (strcmp (name, lookup->name) == 0
 994           && lookup->constraint != -1
 995           && (constraint == 0
 996               || (constraint == lookup->constraint
 997                   && constraint != SPECIAL)))
 998         return lookup;
 999     }
1000   return NULL;
1001 }
1002
1003 lang_output_section_statement_type *
1004 lang_output_section_find (const char *const name)
1005 {
1006   return lang_output_section_find_1 (name, 0);
1007 }
1008
1009 static lang_output_section_statement_type *
1010 lang_output_section_statement_lookup_1 (const char *const name, int constraint)
1011 {
1012   lang_output_section_statement_type *lookup;
1013
1014   lookup = lang_output_section_find_1 (name, constraint);
1015   if (lookup == NULL)
1016     {
1017       lookup = new_stat (lang_output_section_statement, stat_ptr);
1018       lookup->region = NULL;
1019       lookup->lma_region = NULL;
1020       lookup->fill = 0;
1021       lookup->block_value = 1;
1022       lookup->name = name;
1023
1024       lookup->next = NULL;
1025       lookup->bfd_section = NULL;
1026       lookup->processed = 0;
1027       lookup->constraint = constraint;
1028       lookup->ignored = FALSE;
1029       lookup->sectype = normal_section;
1030       lookup->addr_tree = NULL;
1031       lang_list_init (&lookup->children);
1032
1033       lookup->memspec = NULL;
1034       lookup->flags = 0;
1035       lookup->subsection_alignment = -1;
1036       lookup->section_alignment = -1;
1037       lookup->load_base = NULL;
1038       lookup->update_dot_tree = NULL;
1039       lookup->phdrs = NULL;
1040
1041       lang_statement_append (&lang_output_section_statement,
1042                              (lang_statement_union_type *) lookup,
1043                              (lang_statement_union_type **) &lookup->next);
1044     }
1045   return lookup;
1046 }
1047
1048 lang_output_section_statement_type *
1049 lang_output_section_statement_lookup (const char *const name)
1050 {
1051   return lang_output_section_statement_lookup_1 (name, 0);
1052 }
1053
1054 /* A variant of lang_output_section_find used by place_orphan.
1055    Returns the output statement that should precede a new output
1056    statement for SEC.  If an exact match is found on certain flags,
1057    sets *EXACT too.  */
1058
1059 lang_output_section_statement_type *
1060 lang_output_section_find_by_flags (const asection *sec,
1061                                    lang_output_section_statement_type **exact)
1062 {
1063   lang_output_section_statement_type *first, *look, *found;
1064   flagword flags;
1065
1066   /* We know the first statement on this list is *ABS*.  May as well
1067      skip it.  */
1068   first = &lang_output_section_statement.head->output_section_statement;
1069   first = first->next;
1070
1071   /* First try for an exact match.  */
1072   found = NULL;
1073   for (look = first; look; look = look->next)
1074     {
1075       flags = look->flags;
1076       if (look->bfd_section != NULL)
1077         flags = look->bfd_section->flags;
1078       flags ^= sec->flags;
1079       if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1080                      | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1081         found = look;
1082     }
1083   if (found != NULL)
1084     {
1085       *exact = found;
1086       return found;
1087     }
1088
1089   if (sec->flags & SEC_CODE)
1090     {
1091       /* Try for a rw code section.  */
1092       for (look = first; look; look = look->next)
1093         {
1094           flags = look->flags;
1095           if (look->bfd_section != NULL)
1096             flags = look->bfd_section->flags;
1097           flags ^= sec->flags;
1098           if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1099                          | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1100             found = look;
1101         }
1102       return found;
1103     }
1104
1105   if (sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL))
1106     {
1107       /* .rodata can go after .text, .sdata2 after .rodata.  */
1108       for (look = first; look; look = look->next)
1109         {
1110           flags = look->flags;
1111           if (look->bfd_section != NULL)
1112             flags = look->bfd_section->flags;
1113           flags ^= sec->flags;
1114           if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1115                          | SEC_READONLY))
1116               && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1117             found = look;
1118         }
1119       return found;
1120     }
1121
1122   if (sec->flags & SEC_SMALL_DATA)
1123     {
1124       /* .sdata goes after .data, .sbss after .sdata.  */
1125       for (look = first; look; look = look->next)
1126         {
1127           flags = look->flags;
1128           if (look->bfd_section != NULL)
1129             flags = look->bfd_section->flags;
1130           flags ^= sec->flags;
1131           if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1132                          | SEC_THREAD_LOCAL))
1133               || ((look->flags & SEC_SMALL_DATA)
1134                   && !(sec->flags & SEC_HAS_CONTENTS)))
1135             found = look;
1136         }
1137       return found;
1138     }
1139
1140   if (sec->flags & SEC_HAS_CONTENTS)
1141     {
1142       /* .data goes after .rodata.  */
1143       for (look = first; look; look = look->next)
1144         {
1145           flags = look->flags;
1146           if (look->bfd_section != NULL)
1147             flags = look->bfd_section->flags;
1148           flags ^= sec->flags;
1149           if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1150                          | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1151             found = look;
1152         }
1153       return found;
1154     }
1155
1156   /* .bss goes last.  */
1157   for (look = first; look; look = look->next)
1158     {
1159       flags = look->flags;
1160       if (look->bfd_section != NULL)
1161         flags = look->bfd_section->flags;
1162       flags ^= sec->flags;
1163       if (!(flags & SEC_ALLOC))
1164         found = look;
1165     }
1166
1167   return found;
1168 }
1169
1170 /* Find the last output section before given output statement.
1171    Used by place_orphan.  */
1172
1173 static asection *
1174 output_prev_sec_find (lang_output_section_statement_type *os)
1175 {
1176   asection *s = (asection *) NULL;
1177   lang_output_section_statement_type *lookup;
1178
1179   for (lookup = &lang_output_section_statement.head->output_section_statement;
1180        lookup != NULL;
1181        lookup = lookup->next)
1182     {
1183       if (lookup->constraint == -1)
1184         continue;
1185       if (lookup == os)
1186         return s;
1187
1188       if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1189         s = lookup->bfd_section;
1190     }
1191
1192   return NULL;
1193 }
1194
1195 lang_output_section_statement_type *
1196 lang_insert_orphan (lang_input_statement_type *file,
1197                     asection *s,
1198                     const char *secname,
1199                     lang_output_section_statement_type *after,
1200                     struct orphan_save *place,
1201                     etree_type *address,
1202                     lang_statement_list_type *add_child)
1203 {
1204   lang_statement_list_type *old;
1205   lang_statement_list_type add;
1206   const char *ps;
1207   etree_type *load_base;
1208   lang_output_section_statement_type *os;
1209   lang_output_section_statement_type **os_tail;
1210
1211   /* Start building a list of statements for this section.
1212      First save the current statement pointer.  */
1213   old = stat_ptr;
1214
1215   /* If we have found an appropriate place for the output section
1216      statements for this orphan, add them to our own private list,
1217      inserting them later into the global statement list.  */
1218   if (after != NULL)
1219     {
1220       stat_ptr = &add;
1221       lang_list_init (stat_ptr);
1222     }
1223
1224   ps = NULL;
1225   if (config.build_constructors)
1226     {
1227       /* If the name of the section is representable in C, then create
1228          symbols to mark the start and the end of the section.  */
1229       for (ps = secname; *ps != '\0'; ps++)
1230         if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1231           break;
1232       if (*ps == '\0')
1233         {
1234           char *symname;
1235           etree_type *e_align;
1236
1237           symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1238           symname[0] = bfd_get_symbol_leading_char (output_bfd);
1239           sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1240           e_align = exp_unop (ALIGN_K,
1241                               exp_intop ((bfd_vma) 1 << s->alignment_power));
1242           lang_add_assignment (exp_assop ('=', ".", e_align));
1243           lang_add_assignment (exp_assop ('=', symname,
1244                                           exp_nameop (NAME, ".")));
1245         }
1246     }
1247
1248   if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1249     address = exp_intop (0);
1250
1251   load_base = NULL;
1252   if (after != NULL && after->load_base != NULL)
1253     {
1254       etree_type *lma_from_vma;
1255       lma_from_vma = exp_binop ('-', after->load_base,
1256                                 exp_nameop (ADDR, after->name));
1257       load_base = exp_binop ('+', lma_from_vma,
1258                              exp_nameop (ADDR, secname));
1259     }
1260
1261   os_tail = ((lang_output_section_statement_type **)
1262              lang_output_section_statement.tail);
1263   os = lang_enter_output_section_statement (secname, address, 0, NULL, NULL,
1264                                             load_base, 0);
1265
1266   if (add_child == NULL)
1267     add_child = &os->children;
1268   lang_add_section (add_child, s, os, file);
1269
1270   lang_leave_output_section_statement (0, "*default*", NULL, NULL);
1271
1272   if (config.build_constructors && *ps == '\0')
1273     {
1274       char *symname;
1275
1276       /* lang_leave_ouput_section_statement resets stat_ptr.
1277          Put stat_ptr back where we want it.  */
1278       if (after != NULL)
1279         stat_ptr = &add;
1280
1281       symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1282       symname[0] = bfd_get_symbol_leading_char (output_bfd);
1283       sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1284       lang_add_assignment (exp_assop ('=', symname,
1285                                       exp_nameop (NAME, ".")));
1286     }
1287
1288   /* Restore the global list pointer.  */
1289   if (after != NULL)
1290     stat_ptr = old;
1291
1292   if (after != NULL && os->bfd_section != NULL)
1293     {
1294       asection *snew, *as;
1295
1296       snew = os->bfd_section;
1297
1298       /* Shuffle the bfd section list to make the output file look
1299          neater.  This is really only cosmetic.  */
1300       if (place->section == NULL
1301           && after != (&lang_output_section_statement.head
1302                        ->output_section_statement))
1303         {
1304           asection *bfd_section = after->bfd_section;
1305
1306           /* If the output statement hasn't been used to place any input
1307              sections (and thus doesn't have an output bfd_section),
1308              look for the closest prior output statement having an
1309              output section.  */
1310           if (bfd_section == NULL)
1311             bfd_section = output_prev_sec_find (after);
1312
1313           if (bfd_section != NULL && bfd_section != snew)
1314             place->section = &bfd_section->next;
1315         }
1316
1317       if (place->section == NULL)
1318         place->section = &output_bfd->sections;
1319
1320       as = *place->section;
1321       if (as != snew && as->prev != snew)
1322         {
1323           /* Unlink the section.  */
1324           bfd_section_list_remove (output_bfd, snew);
1325
1326           /* Now tack it back on in the right place.  */
1327           bfd_section_list_insert_before (output_bfd, as, snew);
1328         }
1329
1330       /* Save the end of this list.  Further ophans of this type will
1331          follow the one we've just added.  */
1332       place->section = &snew->next;
1333
1334       /* The following is non-cosmetic.  We try to put the output
1335          statements in some sort of reasonable order here, because they
1336          determine the final load addresses of the orphan sections.
1337          In addition, placing output statements in the wrong order may
1338          require extra segments.  For instance, given a typical
1339          situation of all read-only sections placed in one segment and
1340          following that a segment containing all the read-write
1341          sections, we wouldn't want to place an orphan read/write
1342          section before or amongst the read-only ones.  */
1343       if (add.head != NULL)
1344         {
1345           lang_output_section_statement_type *newly_added_os;
1346
1347           if (place->stmt == NULL)
1348             {
1349               lang_statement_union_type **where;
1350               lang_statement_union_type **assign = NULL;
1351
1352               /* Look for a suitable place for the new statement list.
1353                  The idea is to skip over anything that might be inside
1354                  a SECTIONS {} statement in a script, before we find
1355                  another output_section_statement.  Assignments to "dot"
1356                  before an output section statement are assumed to
1357                  belong to it.  */
1358               for (where = &after->header.next;
1359                    *where != NULL;
1360                    where = &(*where)->header.next)
1361                 {
1362                   switch ((*where)->header.type)
1363                     {
1364                     case lang_assignment_statement_enum:
1365                       if (assign == NULL)
1366                         {
1367                           lang_assignment_statement_type *ass;
1368                           ass = &(*where)->assignment_statement;
1369                           if (ass->exp->type.node_class != etree_assert
1370                               && ass->exp->assign.dst[0] == '.'
1371                               && ass->exp->assign.dst[1] == 0)
1372                             assign = where;
1373                         }
1374                       continue;
1375                     case lang_wild_statement_enum:
1376                     case lang_input_section_enum:
1377                     case lang_object_symbols_statement_enum:
1378                     case lang_fill_statement_enum:
1379                     case lang_data_statement_enum:
1380                     case lang_reloc_statement_enum:
1381                     case lang_padding_statement_enum:
1382                     case lang_constructors_statement_enum:
1383                       assign = NULL;
1384                       continue;
1385                     case lang_output_section_statement_enum:
1386                       if (assign != NULL)
1387                         where = assign;
1388                     case lang_input_statement_enum:
1389                     case lang_address_statement_enum:
1390                     case lang_target_statement_enum:
1391                     case lang_output_statement_enum:
1392                     case lang_group_statement_enum:
1393                     case lang_afile_asection_pair_statement_enum:
1394                       break;
1395                     }
1396                   break;
1397                 }
1398
1399               *add.tail = *where;
1400               *where = add.head;
1401
1402               place->os_tail = &after->next;
1403             }
1404           else
1405             {
1406               /* Put it after the last orphan statement we added.  */
1407               *add.tail = *place->stmt;
1408               *place->stmt = add.head;
1409             }
1410
1411           /* Fix the global list pointer if we happened to tack our
1412              new list at the tail.  */
1413           if (*old->tail == add.head)
1414             old->tail = add.tail;
1415
1416           /* Save the end of this list.  */
1417           place->stmt = add.tail;
1418
1419           /* Do the same for the list of output section statements.  */
1420           newly_added_os = *os_tail;
1421           *os_tail = NULL;
1422           newly_added_os->next = *place->os_tail;
1423           *place->os_tail = newly_added_os;
1424           place->os_tail = &newly_added_os->next;
1425
1426           /* Fixing the global list pointer here is a little different.
1427              We added to the list in lang_enter_output_section_statement,
1428              trimmed off the new output_section_statment above when
1429              assigning *os_tail = NULL, but possibly added it back in
1430              the same place when assigning *place->os_tail.  */
1431           if (*os_tail == NULL)
1432             lang_output_section_statement.tail
1433               = (lang_statement_union_type **) os_tail;
1434         }
1435     }
1436   return os;
1437 }
1438
1439 static void
1440 lang_map_flags (flagword flag)
1441 {
1442   if (flag & SEC_ALLOC)
1443     minfo ("a");
1444
1445   if (flag & SEC_CODE)
1446     minfo ("x");
1447
1448   if (flag & SEC_READONLY)
1449     minfo ("r");
1450
1451   if (flag & SEC_DATA)
1452     minfo ("w");
1453
1454   if (flag & SEC_LOAD)
1455     minfo ("l");
1456 }
1457
1458 void
1459 lang_map (void)
1460 {
1461   lang_memory_region_type *m;
1462   bfd *p;
1463
1464   minfo (_("\nMemory Configuration\n\n"));
1465   fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1466            _("Name"), _("Origin"), _("Length"), _("Attributes"));
1467
1468   for (m = lang_memory_region_list; m != NULL; m = m->next)
1469     {
1470       char buf[100];
1471       int len;
1472
1473       fprintf (config.map_file, "%-16s ", m->name);
1474
1475       sprintf_vma (buf, m->origin);
1476       minfo ("0x%s ", buf);
1477       len = strlen (buf);
1478       while (len < 16)
1479         {
1480           print_space ();
1481           ++len;
1482         }
1483
1484       minfo ("0x%V", m->length);
1485       if (m->flags || m->not_flags)
1486         {
1487 #ifndef BFD64
1488           minfo ("        ");
1489 #endif
1490           if (m->flags)
1491             {
1492               print_space ();
1493               lang_map_flags (m->flags);
1494             }
1495
1496           if (m->not_flags)
1497             {
1498               minfo (" !");
1499               lang_map_flags (m->not_flags);
1500             }
1501         }
1502
1503       print_nl ();
1504     }
1505
1506   fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
1507
1508   if (! command_line.reduce_memory_overheads)
1509     {
1510       obstack_begin (&map_obstack, 1000);
1511       for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
1512         bfd_map_over_sections (p, init_map_userdata, 0);
1513       bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
1514     }
1515   print_statements ();
1516 }
1517
1518 static void
1519 init_map_userdata (abfd, sec, data)
1520      bfd *abfd ATTRIBUTE_UNUSED;
1521      asection *sec;
1522      void *data ATTRIBUTE_UNUSED;
1523 {
1524   fat_section_userdata_type *new_data
1525     = ((fat_section_userdata_type *) (stat_alloc
1526                                       (sizeof (fat_section_userdata_type))));
1527
1528   ASSERT (get_userdata (sec) == NULL);
1529   get_userdata (sec) = new_data;
1530   new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
1531 }
1532
1533 static bfd_boolean
1534 sort_def_symbol (hash_entry, info)
1535      struct bfd_link_hash_entry *hash_entry;
1536      void *info ATTRIBUTE_UNUSED;
1537 {
1538   if (hash_entry->type == bfd_link_hash_defined
1539       || hash_entry->type == bfd_link_hash_defweak)
1540     {
1541       struct fat_user_section_struct *ud;
1542       struct map_symbol_def *def;
1543
1544       ud = get_userdata (hash_entry->u.def.section);
1545       if  (! ud)
1546         {
1547           /* ??? What do we have to do to initialize this beforehand?  */
1548           /* The first time we get here is bfd_abs_section...  */
1549           init_map_userdata (0, hash_entry->u.def.section, 0);
1550           ud = get_userdata (hash_entry->u.def.section);
1551         }
1552       else if  (!ud->map_symbol_def_tail)
1553         ud->map_symbol_def_tail = &ud->map_symbol_def_head;
1554
1555       def = obstack_alloc (&map_obstack, sizeof *def);
1556       def->entry = hash_entry;
1557       *(ud->map_symbol_def_tail) = def;
1558       ud->map_symbol_def_tail = &def->next;
1559     }
1560   return TRUE;
1561 }
1562
1563 /* Initialize an output section.  */
1564
1565 static void
1566 init_os (lang_output_section_statement_type *s)
1567 {
1568   if (s->bfd_section != NULL)
1569     return;
1570
1571   if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
1572     einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
1573
1574   s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
1575   if (s->bfd_section == NULL)
1576     s->bfd_section = bfd_make_section (output_bfd, s->name);
1577   if (s->bfd_section == NULL)
1578     {
1579       einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1580              output_bfd->xvec->name, s->name);
1581     }
1582   s->bfd_section->output_section = s->bfd_section;
1583
1584   /* We initialize an output sections output offset to minus its own
1585      vma to allow us to output a section through itself.  */
1586   s->bfd_section->output_offset = 0;
1587   if (!command_line.reduce_memory_overheads)
1588     {
1589       fat_section_userdata_type *new
1590         = stat_alloc (sizeof (fat_section_userdata_type));
1591       memset (new, 0, sizeof (fat_section_userdata_type));
1592       get_userdata (s->bfd_section) = new;
1593     }
1594
1595
1596   /* If there is a base address, make sure that any sections it might
1597      mention are initialized.  */
1598   if (s->addr_tree != NULL)
1599     exp_init_os (s->addr_tree);
1600
1601   if (s->load_base != NULL)
1602     exp_init_os (s->load_base);
1603 }
1604
1605 /* Make sure that all output sections mentioned in an expression are
1606    initialized.  */
1607
1608 static void
1609 exp_init_os (etree_type *exp)
1610 {
1611   switch (exp->type.node_class)
1612     {
1613     case etree_assign:
1614       exp_init_os (exp->assign.src);
1615       break;
1616
1617     case etree_binary:
1618       exp_init_os (exp->binary.lhs);
1619       exp_init_os (exp->binary.rhs);
1620       break;
1621
1622     case etree_trinary:
1623       exp_init_os (exp->trinary.cond);
1624       exp_init_os (exp->trinary.lhs);
1625       exp_init_os (exp->trinary.rhs);
1626       break;
1627
1628     case etree_assert:
1629       exp_init_os (exp->assert_s.child);
1630       break;
1631
1632     case etree_unary:
1633       exp_init_os (exp->unary.child);
1634       break;
1635
1636     case etree_name:
1637       switch (exp->type.node_code)
1638         {
1639         case ADDR:
1640         case LOADADDR:
1641         case SIZEOF:
1642           {
1643             lang_output_section_statement_type *os;
1644
1645             os = lang_output_section_find (exp->name.name);
1646             if (os != NULL && os->bfd_section == NULL)
1647               init_os (os);
1648           }
1649         }
1650       break;
1651
1652     default:
1653       break;
1654     }
1655 }
1656 \f
1657 static void
1658 section_already_linked (bfd *abfd, asection *sec, void *data)
1659 {
1660   lang_input_statement_type *entry = data;
1661
1662   /* If we are only reading symbols from this object, then we want to
1663      discard all sections.  */
1664   if (entry->just_syms_flag)
1665     {
1666       bfd_link_just_syms (abfd, sec, &link_info);
1667       return;
1668     }
1669
1670   if (!(abfd->flags & DYNAMIC))
1671     bfd_section_already_linked (abfd, sec);
1672 }
1673 \f
1674 /* The wild routines.
1675
1676    These expand statements like *(.text) and foo.o to a list of
1677    explicit actions, like foo.o(.text), bar.o(.text) and
1678    foo.o(.text, .data).  */
1679
1680 /* Add SECTION to the output section OUTPUT.  Do this by creating a
1681    lang_input_section statement which is placed at PTR.  FILE is the
1682    input file which holds SECTION.  */
1683
1684 void
1685 lang_add_section (lang_statement_list_type *ptr,
1686                   asection *section,
1687                   lang_output_section_statement_type *output,
1688                   lang_input_statement_type *file)
1689 {
1690   flagword flags = section->flags;
1691   bfd_boolean discard;
1692
1693   /* Discard sections marked with SEC_EXCLUDE.  */
1694   discard = (flags & SEC_EXCLUDE) != 0;
1695
1696   /* Discard input sections which are assigned to a section named
1697      DISCARD_SECTION_NAME.  */
1698   if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1699     discard = TRUE;
1700
1701   /* Discard debugging sections if we are stripping debugging
1702      information.  */
1703   if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1704       && (flags & SEC_DEBUGGING) != 0)
1705     discard = TRUE;
1706
1707   if (discard)
1708     {
1709       if (section->output_section == NULL)
1710         {
1711           /* This prevents future calls from assigning this section.  */
1712           section->output_section = bfd_abs_section_ptr;
1713         }
1714       return;
1715     }
1716
1717   if (section->output_section == NULL)
1718     {
1719       bfd_boolean first;
1720       lang_input_section_type *new;
1721       flagword flags;
1722
1723       if (output->bfd_section == NULL)
1724         init_os (output);
1725
1726       first = ! output->bfd_section->linker_has_input;
1727       output->bfd_section->linker_has_input = 1;
1728
1729       if (!link_info.relocatable
1730           && !stripped_excluded_sections)
1731         {
1732           asection *s = output->bfd_section->map_tail.s;
1733           output->bfd_section->map_tail.s = section;
1734           section->map_head.s = NULL;
1735           section->map_tail.s = s;
1736           if (s != NULL)
1737             s->map_head.s = section;
1738           else
1739             output->bfd_section->map_head.s = section;
1740         }
1741
1742       /* Add a section reference to the list.  */
1743       new = new_stat (lang_input_section, ptr);
1744
1745       new->section = section;
1746       new->ifile = file;
1747       section->output_section = output->bfd_section;
1748
1749       flags = section->flags;
1750
1751       /* We don't copy the SEC_NEVER_LOAD flag from an input section
1752          to an output section, because we want to be able to include a
1753          SEC_NEVER_LOAD section in the middle of an otherwise loaded
1754          section (I don't know why we want to do this, but we do).
1755          build_link_order in ldwrite.c handles this case by turning
1756          the embedded SEC_NEVER_LOAD section into a fill.  */
1757
1758       flags &= ~ SEC_NEVER_LOAD;
1759
1760       /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1761          already been processed.  One reason to do this is that on pe
1762          format targets, .text$foo sections go into .text and it's odd
1763          to see .text with SEC_LINK_ONCE set.  */
1764
1765       if (! link_info.relocatable)
1766         flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1767
1768       /* If this is not the first input section, and the SEC_READONLY
1769          flag is not currently set, then don't set it just because the
1770          input section has it set.  */
1771
1772       if (! first && (output->bfd_section->flags & SEC_READONLY) == 0)
1773         flags &= ~ SEC_READONLY;
1774
1775       /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
1776       if (! first
1777           && ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
1778               != (flags & (SEC_MERGE | SEC_STRINGS))
1779               || ((flags & SEC_MERGE)
1780                   && output->bfd_section->entsize != section->entsize)))
1781         {
1782           output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1783           flags &= ~ (SEC_MERGE | SEC_STRINGS);
1784         }
1785
1786       output->bfd_section->flags |= flags;
1787
1788       if (flags & SEC_MERGE)
1789         output->bfd_section->entsize = section->entsize;
1790
1791       /* If SEC_READONLY is not set in the input section, then clear
1792          it from the output section.  */
1793       if ((section->flags & SEC_READONLY) == 0)
1794         output->bfd_section->flags &= ~SEC_READONLY;
1795
1796       switch (output->sectype)
1797         {
1798         case normal_section:
1799           break;
1800         case dsect_section:
1801         case copy_section:
1802         case info_section:
1803         case overlay_section:
1804           output->bfd_section->flags &= ~SEC_ALLOC;
1805           break;
1806         case noload_section:
1807           output->bfd_section->flags &= ~SEC_LOAD;
1808           output->bfd_section->flags |= SEC_NEVER_LOAD;
1809           break;
1810         }
1811
1812       /* Copy over SEC_SMALL_DATA.  */
1813       if (section->flags & SEC_SMALL_DATA)
1814         output->bfd_section->flags |= SEC_SMALL_DATA;
1815
1816       if (section->alignment_power > output->bfd_section->alignment_power)
1817         output->bfd_section->alignment_power = section->alignment_power;
1818
1819       /* If supplied an alignment, then force it.  */
1820       if (output->section_alignment != -1)
1821         output->bfd_section->alignment_power = output->section_alignment;
1822
1823       if (bfd_get_arch (section->owner) == bfd_arch_tic54x
1824           && (section->flags & SEC_TIC54X_BLOCK) != 0)
1825         {
1826           output->bfd_section->flags |= SEC_TIC54X_BLOCK;
1827           /* FIXME: This value should really be obtained from the bfd...  */
1828           output->block_value = 128;
1829         }
1830     }
1831 }
1832
1833 /* Compare sections ASEC and BSEC according to SORT.  */
1834
1835 static int
1836 compare_section (sort_type sort, asection *asec, asection *bsec)
1837 {
1838   int ret;
1839
1840   switch (sort)
1841     {
1842     default:
1843       abort ();
1844
1845     case by_alignment_name:
1846       ret = (bfd_section_alignment (bsec->owner, bsec)
1847              - bfd_section_alignment (asec->owner, asec));
1848       if (ret)
1849         break;
1850       /* Fall through.  */
1851
1852     case by_name:
1853       ret = strcmp (bfd_get_section_name (asec->owner, asec),
1854                     bfd_get_section_name (bsec->owner, bsec));
1855       break;
1856
1857     case by_name_alignment:
1858       ret = strcmp (bfd_get_section_name (asec->owner, asec),
1859                     bfd_get_section_name (bsec->owner, bsec));
1860       if (ret)
1861         break;
1862       /* Fall through.  */
1863
1864     case by_alignment:
1865       ret = (bfd_section_alignment (bsec->owner, bsec)
1866              - bfd_section_alignment (asec->owner, asec));
1867       break;
1868     }
1869
1870   return ret;
1871 }
1872
1873 /* Handle wildcard sorting.  This returns the lang_input_section which
1874    should follow the one we are going to create for SECTION and FILE,
1875    based on the sorting requirements of WILD.  It returns NULL if the
1876    new section should just go at the end of the current list.  */
1877
1878 static lang_statement_union_type *
1879 wild_sort (lang_wild_statement_type *wild,
1880            struct wildcard_list *sec,
1881            lang_input_statement_type *file,
1882            asection *section)
1883 {
1884   const char *section_name;
1885   lang_statement_union_type *l;
1886
1887   if (!wild->filenames_sorted
1888       && (sec == NULL || sec->spec.sorted == none))
1889     return NULL;
1890
1891   section_name = bfd_get_section_name (file->the_bfd, section);
1892   for (l = wild->children.head; l != NULL; l = l->header.next)
1893     {
1894       lang_input_section_type *ls;
1895
1896       if (l->header.type != lang_input_section_enum)
1897         continue;
1898       ls = &l->input_section;
1899
1900       /* Sorting by filename takes precedence over sorting by section
1901          name.  */
1902
1903       if (wild->filenames_sorted)
1904         {
1905           const char *fn, *ln;
1906           bfd_boolean fa, la;
1907           int i;
1908
1909           /* The PE support for the .idata section as generated by
1910              dlltool assumes that files will be sorted by the name of
1911              the archive and then the name of the file within the
1912              archive.  */
1913
1914           if (file->the_bfd != NULL
1915               && bfd_my_archive (file->the_bfd) != NULL)
1916             {
1917               fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1918               fa = TRUE;
1919             }
1920           else
1921             {
1922               fn = file->filename;
1923               fa = FALSE;
1924             }
1925
1926           if (ls->ifile->the_bfd != NULL
1927               && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1928             {
1929               ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1930               la = TRUE;
1931             }
1932           else
1933             {
1934               ln = ls->ifile->filename;
1935               la = FALSE;
1936             }
1937
1938           i = strcmp (fn, ln);
1939           if (i > 0)
1940             continue;
1941           else if (i < 0)
1942             break;
1943
1944           if (fa || la)
1945             {
1946               if (fa)
1947                 fn = file->filename;
1948               if (la)
1949                 ln = ls->ifile->filename;
1950
1951               i = strcmp (fn, ln);
1952               if (i > 0)
1953                 continue;
1954               else if (i < 0)
1955                 break;
1956             }
1957         }
1958
1959       /* Here either the files are not sorted by name, or we are
1960          looking at the sections for this file.  */
1961
1962       if (sec != NULL && sec->spec.sorted != none)
1963         if (compare_section (sec->spec.sorted, section, ls->section) < 0)
1964           break;
1965     }
1966
1967   return l;
1968 }
1969
1970 /* Expand a wild statement for a particular FILE.  SECTION may be
1971    NULL, in which case it is a wild card.  */
1972
1973 static void
1974 output_section_callback (lang_wild_statement_type *ptr,
1975                          struct wildcard_list *sec,
1976                          asection *section,
1977                          lang_input_statement_type *file,
1978                          void *output)
1979 {
1980   lang_statement_union_type *before;
1981
1982   /* Exclude sections that match UNIQUE_SECTION_LIST.  */
1983   if (unique_section_p (section))
1984     return;
1985
1986   before = wild_sort (ptr, sec, file, section);
1987
1988   /* Here BEFORE points to the lang_input_section which
1989      should follow the one we are about to add.  If BEFORE
1990      is NULL, then the section should just go at the end
1991      of the current list.  */
1992
1993   if (before == NULL)
1994     lang_add_section (&ptr->children, section,
1995                       (lang_output_section_statement_type *) output,
1996                       file);
1997   else
1998     {
1999       lang_statement_list_type list;
2000       lang_statement_union_type **pp;
2001
2002       lang_list_init (&list);
2003       lang_add_section (&list, section,
2004                         (lang_output_section_statement_type *) output,
2005                         file);
2006
2007       /* If we are discarding the section, LIST.HEAD will
2008          be NULL.  */
2009       if (list.head != NULL)
2010         {
2011           ASSERT (list.head->header.next == NULL);
2012
2013           for (pp = &ptr->children.head;
2014                *pp != before;
2015                pp = &(*pp)->header.next)
2016             ASSERT (*pp != NULL);
2017
2018           list.head->header.next = *pp;
2019           *pp = list.head;
2020         }
2021     }
2022 }
2023
2024 /* Check if all sections in a wild statement for a particular FILE
2025    are readonly.  */
2026
2027 static void
2028 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2029                         struct wildcard_list *sec ATTRIBUTE_UNUSED,
2030                         asection *section,
2031                         lang_input_statement_type *file ATTRIBUTE_UNUSED,
2032                         void *data)
2033 {
2034   /* Exclude sections that match UNIQUE_SECTION_LIST.  */
2035   if (unique_section_p (section))
2036     return;
2037
2038   if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2039     ((lang_output_section_statement_type *) data)->all_input_readonly = FALSE;
2040 }
2041
2042 /* This is passed a file name which must have been seen already and
2043    added to the statement tree.  We will see if it has been opened
2044    already and had its symbols read.  If not then we'll read it.  */
2045
2046 static lang_input_statement_type *
2047 lookup_name (const char *name)
2048 {
2049   lang_input_statement_type *search;
2050
2051   for (search = (lang_input_statement_type *) input_file_chain.head;
2052        search != NULL;
2053        search = (lang_input_statement_type *) search->next_real_file)
2054     {
2055       /* Use the local_sym_name as the name of the file that has
2056          already been loaded as filename might have been transformed
2057          via the search directory lookup mechanism.  */
2058       const char * filename = search->local_sym_name;
2059
2060       if (filename == NULL && name == NULL)
2061         return search;
2062       if (filename != NULL
2063           && name != NULL
2064           && strcmp (filename, name) == 0)
2065         break;
2066     }
2067
2068   if (search == NULL)
2069     search = new_afile (name, lang_input_file_is_search_file_enum,
2070                         default_target, FALSE);
2071
2072   /* If we have already added this file, or this file is not real
2073      (FIXME: can that ever actually happen?) or the name is NULL
2074      (FIXME: can that ever actually happen?) don't add this file.  */
2075   if (search->loaded
2076       || ! search->real
2077       || search->filename == NULL)
2078     return search;
2079
2080   if (! load_symbols (search, NULL))
2081     return NULL;
2082
2083   return search;
2084 }
2085
2086 /* Save LIST as a list of libraries whose symbols should not be exported.  */
2087
2088 struct excluded_lib
2089 {
2090   char *name;
2091   struct excluded_lib *next;
2092 };
2093 static struct excluded_lib *excluded_libs;
2094
2095 void
2096 add_excluded_libs (const char *list)
2097 {
2098   const char *p = list, *end;
2099
2100   while (*p != '\0')
2101     {
2102       struct excluded_lib *entry;
2103       end = strpbrk (p, ",:");
2104       if (end == NULL)
2105         end = p + strlen (p);
2106       entry = xmalloc (sizeof (*entry));
2107       entry->next = excluded_libs;
2108       entry->name = xmalloc (end - p + 1);
2109       memcpy (entry->name, p, end - p);
2110       entry->name[end - p] = '\0';
2111       excluded_libs = entry;
2112       if (*end == '\0')
2113         break;
2114       p = end + 1;
2115     }
2116 }
2117
2118 static void
2119 check_excluded_libs (bfd *abfd)
2120 {
2121   struct excluded_lib *lib = excluded_libs;
2122
2123   while (lib)
2124     {
2125       int len = strlen (lib->name);
2126       const char *filename = lbasename (abfd->filename);
2127
2128       if (strcmp (lib->name, "ALL") == 0)
2129         {
2130           abfd->no_export = TRUE;
2131           return;
2132         }
2133
2134       if (strncmp (lib->name, filename, len) == 0
2135           && (filename[len] == '\0'
2136               || (filename[len] == '.' && filename[len + 1] == 'a'
2137                   && filename[len + 2] == '\0')))
2138         {
2139           abfd->no_export = TRUE;
2140           return;
2141         }
2142
2143       lib = lib->next;
2144     }
2145 }
2146
2147 /* Get the symbols for an input file.  */
2148
2149 static bfd_boolean
2150 load_symbols (lang_input_statement_type *entry,
2151               lang_statement_list_type *place)
2152 {
2153   char **matching;
2154
2155   if (entry->loaded)
2156     return TRUE;
2157
2158   ldfile_open_file (entry);
2159
2160   if (! bfd_check_format (entry->the_bfd, bfd_archive)
2161       && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2162     {
2163       bfd_error_type err;
2164       lang_statement_list_type *hold;
2165       bfd_boolean bad_load = TRUE;
2166       bfd_boolean save_ldlang_sysrooted_script;
2167
2168       err = bfd_get_error ();
2169
2170       /* See if the emulation has some special knowledge.  */
2171       if (ldemul_unrecognized_file (entry))
2172         return TRUE;
2173
2174       if (err == bfd_error_file_ambiguously_recognized)
2175         {
2176           char **p;
2177
2178           einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2179           einfo (_("%B: matching formats:"), entry->the_bfd);
2180           for (p = matching; *p != NULL; p++)
2181             einfo (" %s", *p);
2182           einfo ("%F\n");
2183         }
2184       else if (err != bfd_error_file_not_recognized
2185                || place == NULL)
2186           einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2187       else
2188         bad_load = FALSE;
2189
2190       bfd_close (entry->the_bfd);
2191       entry->the_bfd = NULL;
2192
2193       /* Try to interpret the file as a linker script.  */
2194       ldfile_open_command_file (entry->filename);
2195
2196       hold = stat_ptr;
2197       stat_ptr = place;
2198       save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2199       ldlang_sysrooted_script = entry->sysrooted;
2200
2201       ldfile_assumed_script = TRUE;
2202       parser_input = input_script;
2203       /* We want to use the same -Bdynamic/-Bstatic as the one for
2204          ENTRY.  */
2205       config.dynamic_link = entry->dynamic;
2206       yyparse ();
2207       ldfile_assumed_script = FALSE;
2208
2209       ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2210       stat_ptr = hold;
2211
2212       return ! bad_load;
2213     }
2214
2215   if (ldemul_recognized_file (entry))
2216     return TRUE;
2217
2218   /* We don't call ldlang_add_file for an archive.  Instead, the
2219      add_symbols entry point will call ldlang_add_file, via the
2220      add_archive_element callback, for each element of the archive
2221      which is used.  */
2222   switch (bfd_get_format (entry->the_bfd))
2223     {
2224     default:
2225       break;
2226
2227     case bfd_object:
2228       ldlang_add_file (entry);
2229       if (trace_files || trace_file_tries)
2230         info_msg ("%I\n", entry);
2231       break;
2232
2233     case bfd_archive:
2234       check_excluded_libs (entry->the_bfd);
2235
2236       if (entry->whole_archive)
2237         {
2238           bfd *member = NULL;
2239           bfd_boolean loaded = TRUE;
2240
2241           for (;;)
2242             {
2243               member = bfd_openr_next_archived_file (entry->the_bfd, member);
2244
2245               if (member == NULL)
2246                 break;
2247
2248               if (! bfd_check_format (member, bfd_object))
2249                 {
2250                   einfo (_("%F%B: member %B in archive is not an object\n"),
2251                          entry->the_bfd, member);
2252                   loaded = FALSE;
2253                 }
2254
2255               if (! ((*link_info.callbacks->add_archive_element)
2256                      (&link_info, member, "--whole-archive")))
2257                 abort ();
2258
2259               if (! bfd_link_add_symbols (member, &link_info))
2260                 {
2261                   einfo (_("%F%B: could not read symbols: %E\n"), member);
2262                   loaded = FALSE;
2263                 }
2264             }
2265
2266           entry->loaded = loaded;
2267           return loaded;
2268         }
2269       break;
2270     }
2271
2272   if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2273     entry->loaded = TRUE;
2274   else
2275     einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2276
2277   return entry->loaded;
2278 }
2279
2280 /* Handle a wild statement.  S->FILENAME or S->SECTION_LIST or both
2281    may be NULL, indicating that it is a wildcard.  Separate
2282    lang_input_section statements are created for each part of the
2283    expansion; they are added after the wild statement S.  OUTPUT is
2284    the output section.  */
2285
2286 static void
2287 wild (lang_wild_statement_type *s,
2288       const char *target ATTRIBUTE_UNUSED,
2289       lang_output_section_statement_type *output)
2290 {
2291   struct wildcard_list *sec;
2292
2293   walk_wild (s, output_section_callback, output);
2294
2295   for (sec = s->section_list; sec != NULL; sec = sec->next)
2296     {
2297       if (default_common_section != NULL)
2298         break;
2299       if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2300         {
2301           /* Remember the section that common is going to in case we
2302              later get something which doesn't know where to put it.  */
2303           default_common_section = output;
2304         }
2305     }
2306 }
2307
2308 /* Return TRUE iff target is the sought target.  */
2309
2310 static int
2311 get_target (const bfd_target *target, void *data)
2312 {
2313   const char *sought = data;
2314
2315   return strcmp (target->name, sought) == 0;
2316 }
2317
2318 /* Like strcpy() but convert to lower case as well.  */
2319
2320 static void
2321 stricpy (char *dest, char *src)
2322 {
2323   char c;
2324
2325   while ((c = *src++) != 0)
2326     *dest++ = TOLOWER (c);
2327
2328   *dest = 0;
2329 }
2330
2331 /* Remove the first occurrence of needle (if any) in haystack
2332    from haystack.  */
2333
2334 static void
2335 strcut (char *haystack, char *needle)
2336 {
2337   haystack = strstr (haystack, needle);
2338
2339   if (haystack)
2340     {
2341       char *src;
2342
2343       for (src = haystack + strlen (needle); *src;)
2344         *haystack++ = *src++;
2345
2346       *haystack = 0;
2347     }
2348 }
2349
2350 /* Compare two target format name strings.
2351    Return a value indicating how "similar" they are.  */
2352
2353 static int
2354 name_compare (char *first, char *second)
2355 {
2356   char *copy1;
2357   char *copy2;
2358   int result;
2359
2360   copy1 = xmalloc (strlen (first) + 1);
2361   copy2 = xmalloc (strlen (second) + 1);
2362
2363   /* Convert the names to lower case.  */
2364   stricpy (copy1, first);
2365   stricpy (copy2, second);
2366
2367   /* Remove size and endian strings from the name.  */
2368   strcut (copy1, "big");
2369   strcut (copy1, "little");
2370   strcut (copy2, "big");
2371   strcut (copy2, "little");
2372
2373   /* Return a value based on how many characters match,
2374      starting from the beginning.   If both strings are
2375      the same then return 10 * their length.  */
2376   for (result = 0; copy1[result] == copy2[result]; result++)
2377     if (copy1[result] == 0)
2378       {
2379         result *= 10;
2380         break;
2381       }
2382
2383   free (copy1);
2384   free (copy2);
2385
2386   return result;
2387 }
2388
2389 /* Set by closest_target_match() below.  */
2390 static const bfd_target *winner;
2391
2392 /* Scan all the valid bfd targets looking for one that has the endianness
2393    requirement that was specified on the command line, and is the nearest
2394    match to the original output target.  */
2395
2396 static int
2397 closest_target_match (const bfd_target *target, void *data)
2398 {
2399   const bfd_target *original = data;
2400
2401   if (command_line.endian == ENDIAN_BIG
2402       && target->byteorder != BFD_ENDIAN_BIG)
2403     return 0;
2404
2405   if (command_line.endian == ENDIAN_LITTLE
2406       && target->byteorder != BFD_ENDIAN_LITTLE)
2407     return 0;
2408
2409   /* Must be the same flavour.  */
2410   if (target->flavour != original->flavour)
2411     return 0;
2412
2413   /* If we have not found a potential winner yet, then record this one.  */
2414   if (winner == NULL)
2415     {
2416       winner = target;
2417       return 0;
2418     }
2419
2420   /* Oh dear, we now have two potential candidates for a successful match.
2421      Compare their names and choose the better one.  */
2422   if (name_compare (target->name, original->name)
2423       > name_compare (winner->name, original->name))
2424     winner = target;
2425
2426   /* Keep on searching until wqe have checked them all.  */
2427   return 0;
2428 }
2429
2430 /* Return the BFD target format of the first input file.  */
2431
2432 static char *
2433 get_first_input_target (void)
2434 {
2435   char *target = NULL;
2436
2437   LANG_FOR_EACH_INPUT_STATEMENT (s)
2438     {
2439       if (s->header.type == lang_input_statement_enum
2440           && s->real)
2441         {
2442           ldfile_open_file (s);
2443
2444           if (s->the_bfd != NULL
2445               && bfd_check_format (s->the_bfd, bfd_object))
2446             {
2447               target = bfd_get_target (s->the_bfd);
2448
2449               if (target != NULL)
2450                 break;
2451             }
2452         }
2453     }
2454
2455   return target;
2456 }
2457
2458 const char *
2459 lang_get_output_target (void)
2460 {
2461   const char *target;
2462
2463   /* Has the user told us which output format to use?  */
2464   if (output_target != NULL)
2465     return output_target;
2466
2467   /* No - has the current target been set to something other than
2468      the default?  */
2469   if (current_target != default_target)
2470     return current_target;
2471
2472   /* No - can we determine the format of the first input file?  */
2473   target = get_first_input_target ();
2474   if (target != NULL)
2475     return target;
2476
2477   /* Failed - use the default output target.  */
2478   return default_target;
2479 }
2480
2481 /* Open the output file.  */
2482
2483 static bfd *
2484 open_output (const char *name)
2485 {
2486   bfd *output;
2487
2488   output_target = lang_get_output_target ();
2489
2490   /* Has the user requested a particular endianness on the command
2491      line?  */
2492   if (command_line.endian != ENDIAN_UNSET)
2493     {
2494       const bfd_target *target;
2495       enum bfd_endian desired_endian;
2496
2497       /* Get the chosen target.  */
2498       target = bfd_search_for_target (get_target, (void *) output_target);
2499
2500       /* If the target is not supported, we cannot do anything.  */
2501       if (target != NULL)
2502         {
2503           if (command_line.endian == ENDIAN_BIG)
2504             desired_endian = BFD_ENDIAN_BIG;
2505           else
2506             desired_endian = BFD_ENDIAN_LITTLE;
2507
2508           /* See if the target has the wrong endianness.  This should
2509              not happen if the linker script has provided big and
2510              little endian alternatives, but some scrips don't do
2511              this.  */
2512           if (target->byteorder != desired_endian)
2513             {
2514               /* If it does, then see if the target provides
2515                  an alternative with the correct endianness.  */
2516               if (target->alternative_target != NULL
2517                   && (target->alternative_target->byteorder == desired_endian))
2518                 output_target = target->alternative_target->name;
2519               else
2520                 {
2521                   /* Try to find a target as similar as possible to
2522                      the default target, but which has the desired
2523                      endian characteristic.  */
2524                   bfd_search_for_target (closest_target_match,
2525                                          (void *) target);
2526
2527                   /* Oh dear - we could not find any targets that
2528                      satisfy our requirements.  */
2529                   if (winner == NULL)
2530                     einfo (_("%P: warning: could not find any targets"
2531                              " that match endianness requirement\n"));
2532                   else
2533                     output_target = winner->name;
2534                 }
2535             }
2536         }
2537     }
2538
2539   output = bfd_openw (name, output_target);
2540
2541   if (output == NULL)
2542     {
2543       if (bfd_get_error () == bfd_error_invalid_target)
2544         einfo (_("%P%F: target %s not found\n"), output_target);
2545
2546       einfo (_("%P%F: cannot open output file %s: %E\n"), name);
2547     }
2548
2549   delete_output_file_on_failure = TRUE;
2550
2551   if (! bfd_set_format (output, bfd_object))
2552     einfo (_("%P%F:%s: can not make object file: %E\n"), name);
2553   if (! bfd_set_arch_mach (output,
2554                            ldfile_output_architecture,
2555                            ldfile_output_machine))
2556     einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
2557
2558   link_info.hash = bfd_link_hash_table_create (output);
2559   if (link_info.hash == NULL)
2560     einfo (_("%P%F: can not create link hash table: %E\n"));
2561
2562   bfd_set_gp_size (output, g_switch_value);
2563   return output;
2564 }
2565
2566 static void
2567 ldlang_open_output (lang_statement_union_type *statement)
2568 {
2569   switch (statement->header.type)
2570     {
2571     case lang_output_statement_enum:
2572       ASSERT (output_bfd == NULL);
2573       output_bfd = open_output (statement->output_statement.name);
2574       ldemul_set_output_arch ();
2575       if (config.magic_demand_paged && !link_info.relocatable)
2576         output_bfd->flags |= D_PAGED;
2577       else
2578         output_bfd->flags &= ~D_PAGED;
2579       if (config.text_read_only)
2580         output_bfd->flags |= WP_TEXT;
2581       else
2582         output_bfd->flags &= ~WP_TEXT;
2583       if (link_info.traditional_format)
2584         output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
2585       else
2586         output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
2587       break;
2588
2589     case lang_target_statement_enum:
2590       current_target = statement->target_statement.target;
2591       break;
2592     default:
2593       break;
2594     }
2595 }
2596
2597 /* Convert between addresses in bytes and sizes in octets.
2598    For currently supported targets, octets_per_byte is always a power
2599    of two, so we can use shifts.  */
2600 #define TO_ADDR(X) ((X) >> opb_shift)
2601 #define TO_SIZE(X) ((X) << opb_shift)
2602
2603 /* Support the above.  */
2604 static unsigned int opb_shift = 0;
2605
2606 static void
2607 init_opb (void)
2608 {
2609   unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2610                                               ldfile_output_machine);
2611   opb_shift = 0;
2612   if (x > 1)
2613     while ((x & 1) == 0)
2614       {
2615         x >>= 1;
2616         ++opb_shift;
2617       }
2618   ASSERT (x == 1);
2619 }
2620
2621 /* Open all the input files.  */
2622
2623 static void
2624 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
2625 {
2626   for (; s != NULL; s = s->header.next)
2627     {
2628       switch (s->header.type)
2629         {
2630         case lang_constructors_statement_enum:
2631           open_input_bfds (constructor_list.head, force);
2632           break;
2633         case lang_output_section_statement_enum:
2634           open_input_bfds (s->output_section_statement.children.head, force);
2635           break;
2636         case lang_wild_statement_enum:
2637           /* Maybe we should load the file's symbols.  */
2638           if (s->wild_statement.filename
2639               && ! wildcardp (s->wild_statement.filename))
2640             lookup_name (s->wild_statement.filename);
2641           open_input_bfds (s->wild_statement.children.head, force);
2642           break;
2643         case lang_group_statement_enum:
2644           {
2645             struct bfd_link_hash_entry *undefs;
2646
2647             /* We must continually search the entries in the group
2648                until no new symbols are added to the list of undefined
2649                symbols.  */
2650
2651             do
2652               {
2653                 undefs = link_info.hash->undefs_tail;
2654                 open_input_bfds (s->group_statement.children.head, TRUE);
2655               }
2656             while (undefs != link_info.hash->undefs_tail);
2657           }
2658           break;
2659         case lang_target_statement_enum:
2660           current_target = s->target_statement.target;
2661           break;
2662         case lang_input_statement_enum:
2663           if (s->input_statement.real)
2664             {
2665               lang_statement_list_type add;
2666
2667               s->input_statement.target = current_target;
2668
2669               /* If we are being called from within a group, and this
2670                  is an archive which has already been searched, then
2671                  force it to be researched unless the whole archive
2672                  has been loaded already.  */
2673               if (force
2674                   && !s->input_statement.whole_archive
2675                   && s->input_statement.loaded
2676                   && bfd_check_format (s->input_statement.the_bfd,
2677                                        bfd_archive))
2678                 s->input_statement.loaded = FALSE;
2679
2680               lang_list_init (&add);
2681
2682               if (! load_symbols (&s->input_statement, &add))
2683                 config.make_executable = FALSE;
2684
2685               if (add.head != NULL)
2686                 {
2687                   *add.tail = s->header.next;
2688                   s->header.next = add.head;
2689                 }
2690             }
2691           break;
2692         default:
2693           break;
2694         }
2695     }
2696 }
2697
2698 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions.  */
2699
2700 void
2701 lang_track_definedness (const char *name)
2702 {
2703   if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
2704     einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
2705 }
2706
2707 /* New-function for the definedness hash table.  */
2708
2709 static struct bfd_hash_entry *
2710 lang_definedness_newfunc (struct bfd_hash_entry *entry,
2711                           struct bfd_hash_table *table ATTRIBUTE_UNUSED,
2712                           const char *name ATTRIBUTE_UNUSED)
2713 {
2714   struct lang_definedness_hash_entry *ret
2715     = (struct lang_definedness_hash_entry *) entry;
2716
2717   if (ret == NULL)
2718     ret = (struct lang_definedness_hash_entry *)
2719       bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
2720
2721   if (ret == NULL)
2722     einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
2723
2724   ret->iteration = -1;
2725   return &ret->root;
2726 }
2727
2728 /* Return the iteration when the definition of NAME was last updated.  A
2729    value of -1 means that the symbol is not defined in the linker script
2730    or the command line, but may be defined in the linker symbol table.  */
2731
2732 int
2733 lang_symbol_definition_iteration (const char *name)
2734 {
2735   struct lang_definedness_hash_entry *defentry
2736     = (struct lang_definedness_hash_entry *)
2737     bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
2738
2739   /* We've already created this one on the presence of DEFINED in the
2740      script, so it can't be NULL unless something is borked elsewhere in
2741      the code.  */
2742   if (defentry == NULL)
2743     FAIL ();
2744
2745   return defentry->iteration;
2746 }
2747
2748 /* Update the definedness state of NAME.  */
2749
2750 void
2751 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
2752 {
2753   struct lang_definedness_hash_entry *defentry
2754     = (struct lang_definedness_hash_entry *)
2755     bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
2756
2757   /* We don't keep track of symbols not tested with DEFINED.  */
2758   if (defentry == NULL)
2759     return;
2760
2761   /* If the symbol was already defined, and not from an earlier statement
2762      iteration, don't update the definedness iteration, because that'd
2763      make the symbol seem defined in the linker script at this point, and
2764      it wasn't; it was defined in some object.  If we do anyway, DEFINED
2765      would start to yield false before this point and the construct "sym =
2766      DEFINED (sym) ? sym : X;" would change sym to X despite being defined
2767      in an object.  */
2768   if (h->type != bfd_link_hash_undefined
2769       && h->type != bfd_link_hash_common
2770       && h->type != bfd_link_hash_new
2771       && defentry->iteration == -1)
2772     return;
2773
2774   defentry->iteration = lang_statement_iteration;
2775 }
2776
2777 /* Add the supplied name to the symbol table as an undefined reference.
2778    This is a two step process as the symbol table doesn't even exist at
2779    the time the ld command line is processed.  First we put the name
2780    on a list, then, once the output file has been opened, transfer the
2781    name to the symbol table.  */
2782
2783 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
2784
2785 #define ldlang_undef_chain_list_head entry_symbol.next
2786
2787 void
2788 ldlang_add_undef (const char *const name)
2789 {
2790   ldlang_undef_chain_list_type *new =
2791     stat_alloc (sizeof (ldlang_undef_chain_list_type));
2792
2793   new->next = ldlang_undef_chain_list_head;
2794   ldlang_undef_chain_list_head = new;
2795
2796   new->name = xstrdup (name);
2797
2798   if (output_bfd != NULL)
2799     insert_undefined (new->name);
2800 }
2801
2802 /* Insert NAME as undefined in the symbol table.  */
2803
2804 static void
2805 insert_undefined (const char *name)
2806 {
2807   struct bfd_link_hash_entry *h;
2808
2809   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
2810   if (h == NULL)
2811     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2812   if (h->type == bfd_link_hash_new)
2813     {
2814       h->type = bfd_link_hash_undefined;
2815       h->u.undef.abfd = NULL;
2816       bfd_link_add_undef (link_info.hash, h);
2817     }
2818 }
2819
2820 /* Run through the list of undefineds created above and place them
2821    into the linker hash table as undefined symbols belonging to the
2822    script file.  */
2823
2824 static void
2825 lang_place_undefineds (void)
2826 {
2827   ldlang_undef_chain_list_type *ptr;
2828
2829   for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
2830     insert_undefined (ptr->name);
2831 }
2832
2833 /* Check for all readonly or some readwrite sections.  */
2834
2835 static void
2836 check_input_sections
2837   (lang_statement_union_type *s,
2838    lang_output_section_statement_type *output_section_statement)
2839 {
2840   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
2841     {
2842       switch (s->header.type)
2843       {
2844       case lang_wild_statement_enum:
2845         walk_wild (&s->wild_statement, check_section_callback,
2846                    output_section_statement);
2847         if (! output_section_statement->all_input_readonly)
2848           return;
2849         break;
2850       case lang_constructors_statement_enum:
2851         check_input_sections (constructor_list.head,
2852                               output_section_statement);
2853         if (! output_section_statement->all_input_readonly)
2854           return;
2855         break;
2856       case lang_group_statement_enum:
2857         check_input_sections (s->group_statement.children.head,
2858                               output_section_statement);
2859         if (! output_section_statement->all_input_readonly)
2860           return;
2861         break;
2862       default:
2863         break;
2864       }
2865     }
2866 }
2867
2868 /* Update wildcard statements if needed.  */
2869
2870 static void
2871 update_wild_statements (lang_statement_union_type *s)
2872 {
2873   struct wildcard_list *sec;
2874
2875   switch (sort_section)
2876     {
2877     default:
2878       FAIL ();
2879
2880     case none:
2881       break;
2882
2883     case by_name:
2884     case by_alignment:
2885       for (; s != NULL; s = s->header.next)
2886         {
2887           switch (s->header.type)
2888             {
2889             default:
2890               break;
2891
2892             case lang_wild_statement_enum:
2893               sec = s->wild_statement.section_list;
2894               if (sec != NULL)
2895                 {
2896                   switch (sec->spec.sorted)
2897                     {
2898                     case none:
2899                       sec->spec.sorted = sort_section;
2900                       break;
2901                     case by_name:
2902                       if (sort_section == by_alignment)
2903                         sec->spec.sorted = by_name_alignment;
2904                       break;
2905                     case by_alignment:
2906                       if (sort_section == by_name)
2907                         sec->spec.sorted = by_alignment_name;
2908                       break;
2909                     default:
2910                       break;
2911                     }
2912                 }
2913               break;
2914
2915             case lang_constructors_statement_enum:
2916               update_wild_statements (constructor_list.head);
2917               break;
2918
2919             case lang_output_section_statement_enum:
2920               update_wild_statements
2921                 (s->output_section_statement.children.head);
2922               break;
2923
2924             case lang_group_statement_enum:
2925               update_wild_statements (s->group_statement.children.head);
2926               break;
2927             }
2928         }
2929       break;
2930     }
2931 }
2932
2933 /* Open input files and attach to output sections.  */
2934
2935 static void
2936 map_input_to_output_sections
2937   (lang_statement_union_type *s, const char *target,
2938    lang_output_section_statement_type *os)
2939 {
2940   for (; s != NULL; s = s->header.next)
2941     {
2942       switch (s->header.type)
2943         {
2944         case lang_wild_statement_enum:
2945           wild (&s->wild_statement, target, os);
2946           break;
2947         case lang_constructors_statement_enum:
2948           map_input_to_output_sections (constructor_list.head,
2949                                         target,
2950                                         os);
2951           break;
2952         case lang_output_section_statement_enum:
2953           if (s->output_section_statement.constraint)
2954             {
2955               if (s->output_section_statement.constraint != ONLY_IF_RW
2956                   && s->output_section_statement.constraint != ONLY_IF_RO)
2957                 break;
2958               s->output_section_statement.all_input_readonly = TRUE;
2959               check_input_sections (s->output_section_statement.children.head,
2960                                     &s->output_section_statement);
2961               if ((s->output_section_statement.all_input_readonly
2962                    && s->output_section_statement.constraint == ONLY_IF_RW)
2963                   || (!s->output_section_statement.all_input_readonly
2964                       && s->output_section_statement.constraint == ONLY_IF_RO))
2965                 {
2966                   s->output_section_statement.constraint = -1;
2967                   break;
2968                 }
2969             }
2970
2971           map_input_to_output_sections (s->output_section_statement.children.head,
2972                                         target,
2973                                         &s->output_section_statement);
2974           break;
2975         case lang_output_statement_enum:
2976           break;
2977         case lang_target_statement_enum:
2978           target = s->target_statement.target;
2979           break;
2980         case lang_group_statement_enum:
2981           map_input_to_output_sections (s->group_statement.children.head,
2982                                         target,
2983                                         os);
2984           break;
2985         case lang_data_statement_enum:
2986           /* Make sure that any sections mentioned in the expression
2987              are initialized.  */
2988           exp_init_os (s->data_statement.exp);
2989           if (os != NULL && os->bfd_section == NULL)
2990             init_os (os);
2991           /* The output section gets contents, and then we inspect for
2992              any flags set in the input script which override any ALLOC.  */
2993           os->bfd_section->flags |= SEC_HAS_CONTENTS;
2994           if (!(os->flags & SEC_NEVER_LOAD))
2995             os->bfd_section->flags |= SEC_ALLOC | SEC_LOAD;
2996           break;
2997         case lang_fill_statement_enum:
2998         case lang_input_section_enum:
2999         case lang_object_symbols_statement_enum:
3000         case lang_reloc_statement_enum:
3001         case lang_padding_statement_enum:
3002         case lang_input_statement_enum:
3003           if (os != NULL && os->bfd_section == NULL)
3004             init_os (os);
3005           break;
3006         case lang_assignment_statement_enum:
3007           if (os != NULL && os->bfd_section == NULL)
3008             init_os (os);
3009
3010           /* Make sure that any sections mentioned in the assignment
3011              are initialized.  */
3012           exp_init_os (s->assignment_statement.exp);
3013           break;
3014         case lang_afile_asection_pair_statement_enum:
3015           FAIL ();
3016           break;
3017         case lang_address_statement_enum:
3018           /* Mark the specified section with the supplied address.
3019
3020              If this section was actually a segment marker, then the
3021              directive is ignored if the linker script explicitly
3022              processed the segment marker.  Originally, the linker
3023              treated segment directives (like -Ttext on the
3024              command-line) as section directives.  We honor the
3025              section directive semantics for backwards compatibilty;
3026              linker scripts that do not specifically check for
3027              SEGMENT_START automatically get the old semantics.  */
3028           if (!s->address_statement.segment
3029               || !s->address_statement.segment->used)
3030             {
3031               lang_output_section_statement_type *aos
3032                 = (lang_output_section_statement_lookup
3033                    (s->address_statement.section_name));
3034
3035               if (aos->bfd_section == NULL)
3036                 init_os (aos);
3037               aos->addr_tree = s->address_statement.address;
3038             }
3039           break;
3040         }
3041     }
3042 }
3043
3044 /* An output section might have been removed after its statement was
3045    added.  For example, ldemul_before_allocation can remove dynamic
3046    sections if they turn out to be not needed.  Clean them up here.  */
3047
3048 void
3049 strip_excluded_output_sections (void)
3050 {
3051   lang_output_section_statement_type *os;
3052
3053   /* Run lang_size_sections (if not already done) to ensure that all
3054      symbols defined in the linker script are put in the bfd hash
3055      table.  */
3056   if (expld.phase != lang_mark_phase_enum)
3057     {
3058       expld.phase = lang_mark_phase_enum;
3059       expld.dataseg.phase = exp_dataseg_none;
3060       one_lang_size_sections_pass (NULL, FALSE);
3061       lang_reset_memory_regions ();
3062     }
3063
3064   for (os = &lang_output_section_statement.head->output_section_statement;
3065        os != NULL;
3066        os = os->next)
3067     {
3068       asection *output_section;
3069       bfd_boolean exclude;
3070
3071       if (os->constraint == -1)
3072         continue;
3073
3074       output_section = os->bfd_section;
3075       if (output_section == NULL)
3076         continue;
3077
3078       exclude = (output_section->rawsize == 0
3079                  && (output_section->flags & SEC_KEEP) == 0
3080                  && !bfd_section_removed_from_list (output_bfd,
3081                                                     output_section));
3082
3083       /* Some sections have not yet been sized, notably .gnu.version,
3084          .dynsym, .dynstr and .hash.  These all have SEC_LINKER_CREATED
3085          input sections, so don't drop output sections that have such
3086          input sections unless they are also marked SEC_EXCLUDE.  */
3087       if (exclude && output_section->map_head.s != NULL)
3088         {
3089           asection *s;
3090
3091           for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3092             if ((s->flags & SEC_LINKER_CREATED) != 0
3093                 && (s->flags & SEC_EXCLUDE) == 0)
3094               {
3095                 exclude = FALSE;
3096                 break;
3097               }
3098         }
3099
3100       /* TODO: Don't just junk map_head.s, turn them into link_orders.  */
3101       output_section->map_head.link_order = NULL;
3102       output_section->map_tail.link_order = NULL;
3103
3104       if (exclude)
3105         {
3106           /* We don't set bfd_section to NULL since bfd_section of the
3107              removed output section statement may still be used.  */
3108           os->ignored = TRUE;
3109           output_section->flags |= SEC_EXCLUDE;
3110           bfd_section_list_remove (output_bfd, output_section);
3111           output_bfd->section_count--;
3112         }
3113     }
3114
3115   /* Stop future calls to lang_add_section from messing with map_head
3116      and map_tail link_order fields.  */
3117   stripped_excluded_sections = TRUE;
3118 }
3119
3120 static void
3121 print_output_section_statement
3122   (lang_output_section_statement_type *output_section_statement)
3123 {
3124   asection *section = output_section_statement->bfd_section;
3125   int len;
3126
3127   if (output_section_statement != abs_output_section)
3128     {
3129       minfo ("\n%s", output_section_statement->name);
3130
3131       if (section != NULL)
3132         {
3133           print_dot = section->vma;
3134
3135           len = strlen (output_section_statement->name);
3136           if (len >= SECTION_NAME_MAP_LENGTH - 1)
3137             {
3138               print_nl ();
3139               len = 0;
3140             }
3141           while (len < SECTION_NAME_MAP_LENGTH)
3142             {
3143               print_space ();
3144               ++len;
3145             }
3146
3147           minfo ("0x%V %W", section->vma, section->size);
3148
3149           if (output_section_statement->load_base != NULL)
3150             {
3151               bfd_vma addr;
3152
3153               addr = exp_get_abs_int (output_section_statement->load_base, 0,
3154                                       "load base");
3155               minfo (_(" load address 0x%V"), addr);
3156             }
3157         }
3158
3159       print_nl ();
3160     }
3161
3162   print_statement_list (output_section_statement->children.head,
3163                         output_section_statement);
3164 }
3165
3166 /* Scan for the use of the destination in the right hand side
3167    of an expression.  In such cases we will not compute the
3168    correct expression, since the value of DST that is used on
3169    the right hand side will be its final value, not its value
3170    just before this expression is evaluated.  */
3171
3172 static bfd_boolean
3173 scan_for_self_assignment (const char * dst, etree_type * rhs)
3174 {
3175   if (rhs == NULL || dst == NULL)
3176     return FALSE;
3177
3178   switch (rhs->type.node_class)
3179     {
3180     case etree_binary:
3181       return scan_for_self_assignment (dst, rhs->binary.lhs)
3182         ||   scan_for_self_assignment (dst, rhs->binary.rhs);
3183
3184     case etree_trinary:
3185       return scan_for_self_assignment (dst, rhs->trinary.lhs)
3186         ||   scan_for_self_assignment (dst, rhs->trinary.rhs);
3187
3188     case etree_assign:
3189     case etree_provided:
3190     case etree_provide:
3191       if (strcmp (dst, rhs->assign.dst) == 0)
3192         return TRUE;
3193       return scan_for_self_assignment (dst, rhs->assign.src);
3194
3195     case etree_unary:
3196       return scan_for_self_assignment (dst, rhs->unary.child);
3197
3198     case etree_value:
3199       if (rhs->value.str)
3200         return strcmp (dst, rhs->value.str) == 0;
3201       return FALSE;
3202
3203     case etree_name:
3204       if (rhs->name.name)
3205         return strcmp (dst, rhs->name.name) == 0;
3206       return FALSE;
3207
3208     default:
3209       break;
3210     }
3211
3212   return FALSE;
3213 }
3214
3215
3216 static void
3217 print_assignment (lang_assignment_statement_type *assignment,
3218                   lang_output_section_statement_type *output_section)
3219 {
3220   unsigned int i;
3221   bfd_boolean is_dot;
3222   bfd_boolean computation_is_valid = TRUE;
3223   etree_type *tree;
3224
3225   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3226     print_space ();
3227
3228   if (assignment->exp->type.node_class == etree_assert)
3229     {
3230       is_dot = FALSE;
3231       tree = assignment->exp->assert_s.child;
3232       computation_is_valid = TRUE;
3233     }
3234   else
3235     {
3236       const char *dst = assignment->exp->assign.dst;
3237
3238       is_dot = (dst[0] == '.' && dst[1] == 0);
3239       tree = assignment->exp->assign.src;
3240       computation_is_valid = is_dot || (scan_for_self_assignment (dst, tree) == FALSE);
3241     }
3242
3243   exp_fold_tree (tree, output_section->bfd_section, &print_dot);
3244   if (expld.result.valid_p)
3245     {
3246       bfd_vma value;
3247
3248       if (computation_is_valid)
3249         {
3250           value = expld.result.value;
3251
3252           if (expld.result.section)
3253             value += expld.result.section->vma;
3254
3255           minfo ("0x%V", value);
3256           if (is_dot)
3257             print_dot = value;
3258         }
3259       else
3260         {
3261           struct bfd_link_hash_entry *h;
3262
3263           h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
3264                                     FALSE, FALSE, TRUE);
3265           if (h)
3266             {
3267               value = h->u.def.value;
3268
3269               if (expld.result.section)
3270               value += expld.result.section->vma;
3271
3272               minfo ("[0x%V]", value);
3273             }
3274           else
3275             minfo ("[unresolved]");
3276         }
3277     }
3278   else
3279     {
3280       minfo ("*undef*   ");
3281 #ifdef BFD64
3282       minfo ("        ");
3283 #endif
3284     }
3285
3286   minfo ("                ");
3287   exp_print_tree (assignment->exp);
3288   print_nl ();
3289 }
3290
3291 static void
3292 print_input_statement (lang_input_statement_type *statm)
3293 {
3294   if (statm->filename != NULL)
3295     {
3296       fprintf (config.map_file, "LOAD %s\n", statm->filename);
3297     }
3298 }
3299
3300 /* Print all symbols defined in a particular section.  This is called
3301    via bfd_link_hash_traverse, or by print_all_symbols.  */
3302
3303 static bfd_boolean
3304 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
3305 {
3306   asection *sec = ptr;
3307
3308   if ((hash_entry->type == bfd_link_hash_defined
3309        || hash_entry->type == bfd_link_hash_defweak)
3310       && sec == hash_entry->u.def.section)
3311     {
3312       int i;
3313
3314       for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3315         print_space ();
3316       minfo ("0x%V   ",
3317              (hash_entry->u.def.value
3318               + hash_entry->u.def.section->output_offset
3319               + hash_entry->u.def.section->output_section->vma));
3320
3321       minfo ("             %T\n", hash_entry->root.string);
3322     }
3323
3324   return TRUE;
3325 }
3326
3327 static void
3328 print_all_symbols (sec)
3329      asection *sec;
3330 {
3331   struct fat_user_section_struct *ud = get_userdata (sec);
3332   struct map_symbol_def *def;
3333
3334   if (!ud)
3335     return;
3336
3337   *ud->map_symbol_def_tail = 0;
3338   for (def = ud->map_symbol_def_head; def; def = def->next)
3339     print_one_symbol (def->entry, sec);
3340 }
3341
3342 /* Print information about an input section to the map file.  */
3343
3344 static void
3345 print_input_section (lang_input_section_type *in)
3346 {
3347   asection *i = in->section;
3348   bfd_size_type size = i->size;
3349
3350   init_opb ();
3351   if (size != 0)
3352     {
3353       int len;
3354       bfd_vma addr;
3355
3356       print_space ();
3357       minfo ("%s", i->name);
3358
3359       len = 1 + strlen (i->name);
3360       if (len >= SECTION_NAME_MAP_LENGTH - 1)
3361         {
3362           print_nl ();
3363           len = 0;
3364         }
3365       while (len < SECTION_NAME_MAP_LENGTH)
3366         {
3367           print_space ();
3368           ++len;
3369         }
3370
3371       if (i->output_section != NULL && (i->flags & SEC_EXCLUDE) == 0)
3372         addr = i->output_section->vma + i->output_offset;
3373       else
3374         {
3375           addr = print_dot;
3376           size = 0;
3377         }
3378
3379       minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
3380
3381       if (size != i->rawsize && i->rawsize != 0)
3382         {
3383           len = SECTION_NAME_MAP_LENGTH + 3;
3384 #ifdef BFD64
3385           len += 16;
3386 #else
3387           len += 8;
3388 #endif
3389           while (len > 0)
3390             {
3391               print_space ();
3392               --len;
3393             }
3394
3395           minfo (_("%W (size before relaxing)\n"), i->rawsize);
3396         }
3397
3398       if (i->output_section != NULL && (i->flags & SEC_EXCLUDE) == 0)
3399         {
3400           if (command_line.reduce_memory_overheads)
3401             bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
3402           else
3403             print_all_symbols (i);
3404
3405           print_dot = addr + TO_ADDR (size);
3406         }
3407     }
3408 }
3409
3410 static void
3411 print_fill_statement (lang_fill_statement_type *fill)
3412 {
3413   size_t size;
3414   unsigned char *p;
3415   fputs (" FILL mask 0x", config.map_file);
3416   for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
3417     fprintf (config.map_file, "%02x", *p);
3418   fputs ("\n", config.map_file);
3419 }
3420
3421 static void
3422 print_data_statement (lang_data_statement_type *data)
3423 {
3424   int i;
3425   bfd_vma addr;
3426   bfd_size_type size;
3427   const char *name;
3428
3429   init_opb ();
3430   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3431     print_space ();
3432
3433   addr = data->output_vma;
3434   if (data->output_section != NULL)
3435     addr += data->output_section->vma;
3436
3437   switch (data->type)
3438     {
3439     default:
3440       abort ();
3441     case BYTE:
3442       size = BYTE_SIZE;
3443       name = "BYTE";
3444       break;
3445     case SHORT:
3446       size = SHORT_SIZE;
3447       name = "SHORT";
3448       break;
3449     case LONG:
3450       size = LONG_SIZE;
3451       name = "LONG";
3452       break;
3453     case QUAD:
3454       size = QUAD_SIZE;
3455       name = "QUAD";
3456       break;
3457     case SQUAD:
3458       size = QUAD_SIZE;
3459       name = "SQUAD";
3460       break;
3461     }
3462
3463   minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
3464
3465   if (data->exp->type.node_class != etree_value)
3466     {
3467       print_space ();
3468       exp_print_tree (data->exp);
3469     }
3470
3471   print_nl ();
3472
3473   print_dot = addr + TO_ADDR (size);
3474 }
3475
3476 /* Print an address statement.  These are generated by options like
3477    -Ttext.  */
3478
3479 static void
3480 print_address_statement (lang_address_statement_type *address)
3481 {
3482   minfo (_("Address of section %s set to "), address->section_name);
3483   exp_print_tree (address->address);
3484   print_nl ();
3485 }
3486
3487 /* Print a reloc statement.  */
3488
3489 static void
3490 print_reloc_statement (lang_reloc_statement_type *reloc)
3491 {
3492   int i;
3493   bfd_vma addr;
3494   bfd_size_type size;
3495
3496   init_opb ();
3497   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3498     print_space ();
3499
3500   addr = reloc->output_vma;
3501   if (reloc->output_section != NULL)
3502     addr += reloc->output_section->vma;
3503
3504   size = bfd_get_reloc_size (reloc->howto);
3505
3506   minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
3507
3508   if (reloc->name != NULL)
3509     minfo ("%s+", reloc->name);
3510   else
3511     minfo ("%s+", reloc->section->name);
3512
3513   exp_print_tree (reloc->addend_exp);
3514
3515   print_nl ();
3516
3517   print_dot = addr + TO_ADDR (size);
3518 }
3519
3520 static void
3521 print_padding_statement (lang_padding_statement_type *s)
3522 {
3523   int len;
3524   bfd_vma addr;
3525
3526   init_opb ();
3527   minfo (" *fill*");
3528
3529   len = sizeof " *fill*" - 1;
3530   while (len < SECTION_NAME_MAP_LENGTH)
3531     {
3532       print_space ();
3533       ++len;
3534     }
3535
3536   addr = s->output_offset;
3537   if (s->output_section != NULL)
3538     addr += s->output_section->vma;
3539   minfo ("0x%V %W ", addr, (bfd_vma) s->size);
3540
3541   if (s->fill->size != 0)
3542     {
3543       size_t size;
3544       unsigned char *p;
3545       for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
3546         fprintf (config.map_file, "%02x", *p);
3547     }
3548
3549   print_nl ();
3550
3551   print_dot = addr + TO_ADDR (s->size);
3552 }
3553
3554 static void
3555 print_wild_statement (lang_wild_statement_type *w,
3556                       lang_output_section_statement_type *os)
3557 {
3558   struct wildcard_list *sec;
3559
3560   print_space ();
3561
3562   if (w->filenames_sorted)
3563     minfo ("SORT(");
3564   if (w->filename != NULL)
3565     minfo ("%s", w->filename);
3566   else
3567     minfo ("*");
3568   if (w->filenames_sorted)
3569     minfo (")");
3570
3571   minfo ("(");
3572   for (sec = w->section_list; sec; sec = sec->next)
3573     {
3574       if (sec->spec.sorted)
3575         minfo ("SORT(");
3576       if (sec->spec.exclude_name_list != NULL)
3577         {
3578           name_list *tmp;
3579           minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
3580           for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
3581             minfo (" %s", tmp->name);
3582           minfo (") ");
3583         }
3584       if (sec->spec.name != NULL)
3585         minfo ("%s", sec->spec.name);
3586       else
3587         minfo ("*");
3588       if (sec->spec.sorted)
3589         minfo (")");
3590       if (sec->next)
3591         minfo (" ");
3592     }
3593   minfo (")");
3594
3595   print_nl ();
3596
3597   print_statement_list (w->children.head, os);
3598 }
3599
3600 /* Print a group statement.  */
3601
3602 static void
3603 print_group (lang_group_statement_type *s,
3604              lang_output_section_statement_type *os)
3605 {
3606   fprintf (config.map_file, "START GROUP\n");
3607   print_statement_list (s->children.head, os);
3608   fprintf (config.map_file, "END GROUP\n");
3609 }
3610
3611 /* Print the list of statements in S.
3612    This can be called for any statement type.  */
3613
3614 static void
3615 print_statement_list (lang_statement_union_type *s,
3616                       lang_output_section_statement_type *os)
3617 {
3618   while (s != NULL)
3619     {
3620       print_statement (s, os);
3621       s = s->header.next;
3622     }
3623 }
3624
3625 /* Print the first statement in statement list S.
3626    This can be called for any statement type.  */
3627
3628 static void
3629 print_statement (lang_statement_union_type *s,
3630                  lang_output_section_statement_type *os)
3631 {
3632   switch (s->header.type)
3633     {
3634     default:
3635       fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
3636       FAIL ();
3637       break;
3638     case lang_constructors_statement_enum:
3639       if (constructor_list.head != NULL)
3640         {
3641           if (constructors_sorted)
3642             minfo (" SORT (CONSTRUCTORS)\n");
3643           else
3644             minfo (" CONSTRUCTORS\n");
3645           print_statement_list (constructor_list.head, os);
3646         }
3647       break;
3648     case lang_wild_statement_enum:
3649       print_wild_statement (&s->wild_statement, os);
3650       break;
3651     case lang_address_statement_enum:
3652       print_address_statement (&s->address_statement);
3653       break;
3654     case lang_object_symbols_statement_enum:
3655       minfo (" CREATE_OBJECT_SYMBOLS\n");
3656       break;
3657     case lang_fill_statement_enum:
3658       print_fill_statement (&s->fill_statement);
3659       break;
3660     case lang_data_statement_enum:
3661       print_data_statement (&s->data_statement);
3662       break;
3663     case lang_reloc_statement_enum:
3664       print_reloc_statement (&s->reloc_statement);
3665       break;
3666     case lang_input_section_enum:
3667       print_input_section (&s->input_section);
3668       break;
3669     case lang_padding_statement_enum:
3670       print_padding_statement (&s->padding_statement);
3671       break;
3672     case lang_output_section_statement_enum:
3673       print_output_section_statement (&s->output_section_statement);
3674       break;
3675     case lang_assignment_statement_enum:
3676       print_assignment (&s->assignment_statement, os);
3677       break;
3678     case lang_target_statement_enum:
3679       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
3680       break;
3681     case lang_output_statement_enum:
3682       minfo ("OUTPUT(%s", s->output_statement.name);
3683       if (output_target != NULL)
3684         minfo (" %s", output_target);
3685       minfo (")\n");
3686       break;
3687     case lang_input_statement_enum:
3688       print_input_statement (&s->input_statement);
3689       break;
3690     case lang_group_statement_enum:
3691       print_group (&s->group_statement, os);
3692       break;
3693     case lang_afile_asection_pair_statement_enum:
3694       FAIL ();
3695       break;
3696     }
3697 }
3698
3699 static void
3700 print_statements (void)
3701 {
3702   print_statement_list (statement_list.head, abs_output_section);
3703 }
3704
3705 /* Print the first N statements in statement list S to STDERR.
3706    If N == 0, nothing is printed.
3707    If N < 0, the entire list is printed.
3708    Intended to be called from GDB.  */
3709
3710 void
3711 dprint_statement (lang_statement_union_type *s, int n)
3712 {
3713   FILE *map_save = config.map_file;
3714
3715   config.map_file = stderr;
3716
3717   if (n < 0)
3718     print_statement_list (s, abs_output_section);
3719   else
3720     {
3721       while (s && --n >= 0)
3722         {
3723           print_statement (s, abs_output_section);
3724           s = s->header.next;
3725         }
3726     }
3727
3728   config.map_file = map_save;
3729 }
3730
3731 static void
3732 insert_pad (lang_statement_union_type **ptr,
3733             fill_type *fill,
3734             unsigned int alignment_needed,
3735             asection *output_section,
3736             bfd_vma dot)
3737 {
3738   static fill_type zero_fill = { 1, { 0 } };
3739   lang_statement_union_type *pad = NULL;
3740
3741   if (ptr != &statement_list.head)
3742     pad = ((lang_statement_union_type *)
3743            ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
3744   if (pad != NULL
3745       && pad->header.type == lang_padding_statement_enum
3746       && pad->padding_statement.output_section == output_section)
3747     {
3748       /* Use the existing pad statement.  */
3749     }
3750   else if ((pad = *ptr) != NULL
3751       && pad->header.type == lang_padding_statement_enum
3752       && pad->padding_statement.output_section == output_section)
3753     {
3754       /* Use the existing pad statement.  */
3755     }
3756   else
3757     {
3758       /* Make a new padding statement, linked into existing chain.  */
3759       pad = stat_alloc (sizeof (lang_padding_statement_type));
3760       pad->header.next = *ptr;
3761       *ptr = pad;
3762       pad->header.type = lang_padding_statement_enum;
3763       pad->padding_statement.output_section = output_section;
3764       if (fill == NULL)
3765         fill = &zero_fill;
3766       pad->padding_statement.fill = fill;
3767     }
3768   pad->padding_statement.output_offset = dot - output_section->vma;
3769   pad->padding_statement.size = alignment_needed;
3770   output_section->size += alignment_needed;
3771 }
3772
3773 /* Work out how much this section will move the dot point.  */
3774
3775 static bfd_vma
3776 size_input_section
3777   (lang_statement_union_type **this_ptr,
3778    lang_output_section_statement_type *output_section_statement,
3779    fill_type *fill,
3780    bfd_vma dot)
3781 {
3782   lang_input_section_type *is = &((*this_ptr)->input_section);
3783   asection *i = is->section;
3784
3785   if (!is->ifile->just_syms_flag && (i->flags & SEC_EXCLUDE) == 0)
3786     {
3787       unsigned int alignment_needed;
3788       asection *o;
3789
3790       /* Align this section first to the input sections requirement,
3791          then to the output section's requirement.  If this alignment
3792          is greater than any seen before, then record it too.  Perform
3793          the alignment by inserting a magic 'padding' statement.  */
3794
3795       if (output_section_statement->subsection_alignment != -1)
3796         i->alignment_power = output_section_statement->subsection_alignment;
3797
3798       o = output_section_statement->bfd_section;
3799       if (o->alignment_power < i->alignment_power)
3800         o->alignment_power = i->alignment_power;
3801
3802       alignment_needed = align_power (dot, i->alignment_power) - dot;
3803
3804       if (alignment_needed != 0)
3805         {
3806           insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
3807           dot += alignment_needed;
3808         }
3809
3810       /* Remember where in the output section this input section goes.  */
3811
3812       i->output_offset = dot - o->vma;
3813
3814       /* Mark how big the output section must be to contain this now.  */
3815       dot += TO_ADDR (i->size);
3816       o->size = TO_SIZE (dot - o->vma);
3817     }
3818   else
3819     {
3820       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
3821     }
3822
3823   return dot;
3824 }
3825
3826 static int
3827 sort_sections_by_lma (const void *arg1, const void *arg2)
3828 {
3829   const asection *sec1 = *(const asection **) arg1;
3830   const asection *sec2 = *(const asection **) arg2;
3831
3832   if (bfd_section_lma (sec1->owner, sec1)
3833       < bfd_section_lma (sec2->owner, sec2))
3834     return -1;
3835   else if (bfd_section_lma (sec1->owner, sec1)
3836            > bfd_section_lma (sec2->owner, sec2))
3837     return 1;
3838
3839   return 0;
3840 }
3841
3842 #define IGNORE_SECTION(s) \
3843   ((s->flags & SEC_NEVER_LOAD) != 0                             \
3844    || (s->flags & SEC_ALLOC) == 0                               \
3845    || ((s->flags & SEC_THREAD_LOCAL) != 0                       \
3846         && (s->flags & SEC_LOAD) == 0))
3847
3848 /* Check to see if any allocated sections overlap with other allocated
3849    sections.  This can happen if a linker script specifies the output
3850    section addresses of the two sections.  */
3851
3852 static void
3853 lang_check_section_addresses (void)
3854 {
3855   asection *s, *os;
3856   asection **sections, **spp;
3857   unsigned int count;
3858   bfd_vma s_start;
3859   bfd_vma s_end;
3860   bfd_vma os_start;
3861   bfd_vma os_end;
3862   bfd_size_type amt;
3863
3864   if (bfd_count_sections (output_bfd) <= 1)
3865     return;
3866
3867   amt = bfd_count_sections (output_bfd) * sizeof (asection *);
3868   sections = xmalloc (amt);
3869
3870   /* Scan all sections in the output list.  */
3871   count = 0;
3872   for (s = output_bfd->sections; s != NULL; s = s->next)
3873     {
3874       /* Only consider loadable sections with real contents.  */
3875       if (IGNORE_SECTION (s) || s->size == 0)
3876         continue;
3877
3878       sections[count] = s;
3879       count++;
3880     }
3881
3882   if (count <= 1)
3883     return;
3884
3885   qsort (sections, (size_t) count, sizeof (asection *),
3886          sort_sections_by_lma);
3887
3888   spp = sections;
3889   s = *spp++;
3890   s_start = bfd_section_lma (output_bfd, s);
3891   s_end = s_start + TO_ADDR (s->size) - 1;
3892   for (count--; count; count--)
3893     {
3894       /* We must check the sections' LMA addresses not their VMA
3895          addresses because overlay sections can have overlapping VMAs
3896          but they must have distinct LMAs.  */
3897       os = s;
3898       os_start = s_start;
3899       os_end = s_end;
3900       s = *spp++;
3901       s_start = bfd_section_lma (output_bfd, s);
3902       s_end = s_start + TO_ADDR (s->size) - 1;
3903
3904       /* Look for an overlap.  */
3905       if (s_end >= os_start && s_start <= os_end)
3906         einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
3907                s->name, s_start, s_end, os->name, os_start, os_end);
3908     }
3909
3910   free (sections);
3911 }
3912
3913 /* Make sure the new address is within the region.  We explicitly permit the
3914    current address to be at the exact end of the region when the address is
3915    non-zero, in case the region is at the end of addressable memory and the
3916    calculation wraps around.  */
3917
3918 static void
3919 os_region_check (lang_output_section_statement_type *os,
3920                  lang_memory_region_type *region,
3921                  etree_type *tree,
3922                  bfd_vma base)
3923 {
3924   if ((region->current < region->origin
3925        || (region->current - region->origin > region->length))
3926       && ((region->current != region->origin + region->length)
3927           || base == 0))
3928     {
3929       if (tree != NULL)
3930         {
3931           einfo (_("%X%P: address 0x%v of %B section %s"
3932                    " is not within region %s\n"),
3933                  region->current,
3934                  os->bfd_section->owner,
3935                  os->bfd_section->name,
3936                  region->name);
3937         }
3938       else
3939         {
3940           einfo (_("%X%P: region %s is full (%B section %s)\n"),
3941                  region->name,
3942                  os->bfd_section->owner,
3943                  os->bfd_section->name);
3944         }
3945       /* Reset the region pointer.  */
3946       region->current = region->origin;
3947     }
3948 }
3949
3950 /* Set the sizes for all the output sections.  */
3951
3952 static bfd_vma
3953 lang_size_sections_1
3954   (lang_statement_union_type *s,
3955    lang_output_section_statement_type *output_section_statement,
3956    lang_statement_union_type **prev,
3957    fill_type *fill,
3958    bfd_vma dot,
3959    bfd_boolean *relax,
3960    bfd_boolean check_regions)
3961 {
3962   /* Size up the sections from their constituent parts.  */
3963   for (; s != NULL; s = s->header.next)
3964     {
3965       switch (s->header.type)
3966         {
3967         case lang_output_section_statement_enum:
3968           {
3969             bfd_vma newdot, after;
3970             lang_output_section_statement_type *os;
3971
3972             os = &s->output_section_statement;
3973             if (os->bfd_section == NULL)
3974               /* This section was removed or never actually created.  */
3975               break;
3976
3977             /* If this is a COFF shared library section, use the size and
3978                address from the input section.  FIXME: This is COFF
3979                specific; it would be cleaner if there were some other way
3980                to do this, but nothing simple comes to mind.  */
3981             if ((bfd_get_flavour (output_bfd) == bfd_target_ecoff_flavour
3982                  || bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
3983                 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
3984               {
3985                 asection *input;
3986
3987                 if (os->children.head == NULL
3988                     || os->children.head->header.next != NULL
3989                     || (os->children.head->header.type
3990                         != lang_input_section_enum))
3991                   einfo (_("%P%X: Internal error on COFF shared library"
3992                            " section %s\n"), os->name);
3993
3994                 input = os->children.head->input_section.section;
3995                 bfd_set_section_vma (os->bfd_section->owner,
3996                                      os->bfd_section,
3997                                      bfd_section_vma (input->owner, input));
3998                 os->bfd_section->size = input->size;
3999                 break;
4000               }
4001
4002             if (bfd_is_abs_section (os->bfd_section))
4003               {
4004                 /* No matter what happens, an abs section starts at zero.  */
4005                 ASSERT (os->bfd_section->vma == 0);
4006               }
4007             else
4008               {
4009                 if (os->addr_tree == NULL)
4010                   {
4011                     /* No address specified for this section, get one
4012                        from the region specification.  */
4013                     if (os->region == NULL
4014                         || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4015                             && os->region->name[0] == '*'
4016                             && strcmp (os->region->name,
4017                                        DEFAULT_MEMORY_REGION) == 0))
4018                       {
4019                         os->region = lang_memory_default (os->bfd_section);
4020                       }
4021
4022                     /* If a loadable section is using the default memory
4023                        region, and some non default memory regions were
4024                        defined, issue an error message.  */
4025                     if (!IGNORE_SECTION (os->bfd_section)
4026                         && ! link_info.relocatable
4027                         && check_regions
4028                         && strcmp (os->region->name,
4029                                    DEFAULT_MEMORY_REGION) == 0
4030                         && lang_memory_region_list != NULL
4031                         && (strcmp (lang_memory_region_list->name,
4032                                     DEFAULT_MEMORY_REGION) != 0
4033                             || lang_memory_region_list->next != NULL)
4034                         && expld.phase != lang_mark_phase_enum)
4035                       {
4036                         /* By default this is an error rather than just a
4037                            warning because if we allocate the section to the
4038                            default memory region we can end up creating an
4039                            excessively large binary, or even seg faulting when
4040                            attempting to perform a negative seek.  See
4041                            sources.redhat.com/ml/binutils/2003-04/msg00423.html
4042                            for an example of this.  This behaviour can be
4043                            overridden by the using the --no-check-sections
4044                            switch.  */
4045                         if (command_line.check_section_addresses)
4046                           einfo (_("%P%F: error: no memory region specified"
4047                                    " for loadable section `%s'\n"),
4048                                  bfd_get_section_name (output_bfd,
4049                                                        os->bfd_section));
4050                         else
4051                           einfo (_("%P: warning: no memory region specified"
4052                                    " for loadable section `%s'\n"),
4053                                  bfd_get_section_name (output_bfd,
4054                                                        os->bfd_section));
4055                       }
4056
4057                     newdot = os->region->current;
4058
4059                     if (os->section_alignment == -1)
4060                       {
4061                         bfd_vma savedot = newdot;
4062                         newdot = align_power (newdot,
4063                                               os->bfd_section->alignment_power);
4064
4065                         if (newdot != savedot
4066                             && config.warn_section_align
4067                             && expld.phase != lang_mark_phase_enum)
4068                           einfo (_("%P: warning: changing start of section"
4069                                    " %s by %lu bytes\n"),
4070                                  os->name, (unsigned long) (newdot - savedot));
4071                       }
4072                   }
4073                 else
4074                   {
4075                     newdot = dot;
4076                     os->processed = -1;
4077                     exp_fold_tree (os->addr_tree, bfd_abs_section_ptr,
4078                                    &newdot);
4079                     os->processed = 0;
4080
4081                     if (!expld.result.valid_p
4082                         && expld.phase != lang_mark_phase_enum)
4083                       einfo (_("%F%S: non constant or forward reference"
4084                                " address expression for section %s\n"),
4085                              os->name);
4086
4087                     newdot = expld.result.value + expld.result.section->vma;
4088                   }
4089
4090                 /* The section starts here.
4091                    First, align to what the section needs.  */
4092
4093                 if (os->section_alignment != -1)
4094                   newdot = align_power (newdot, os->section_alignment);
4095
4096                 bfd_set_section_vma (0, os->bfd_section, newdot);
4097
4098                 os->bfd_section->output_offset = 0;
4099               }
4100
4101             lang_size_sections_1 (os->children.head, os, &os->children.head,
4102                                   os->fill, newdot, relax, check_regions);
4103
4104             os->processed = 1;
4105
4106             if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4107               {
4108                 ASSERT (os->bfd_section->size == 0);
4109                 break;
4110               }
4111
4112             dot = os->bfd_section->vma;
4113
4114             /* Put the section within the requested block size, or
4115                align at the block boundary.  */
4116             after = ((dot
4117                       + TO_ADDR (os->bfd_section->size)
4118                       + os->block_value - 1)
4119                      & - (bfd_vma) os->block_value);
4120
4121             os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
4122
4123             /* .tbss sections effectively have zero size.  */
4124             if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4125                 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4126                 || link_info.relocatable)
4127               dot += TO_ADDR (os->bfd_section->size);
4128
4129             if (os->update_dot_tree != 0)
4130               exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
4131
4132             /* Update dot in the region ?
4133                We only do this if the section is going to be allocated,
4134                since unallocated sections do not contribute to the region's
4135                overall size in memory.
4136
4137                If the SEC_NEVER_LOAD bit is not set, it will affect the
4138                addresses of sections after it. We have to update
4139                dot.  */
4140             if (os->region != NULL
4141                 && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
4142                     || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
4143               {
4144                 os->region->current = dot;
4145
4146                 if (check_regions)
4147                   /* Make sure the new address is within the region.  */
4148                   os_region_check (os, os->region, os->addr_tree,
4149                                    os->bfd_section->vma);
4150
4151                 /* If there's no load address specified, use the run
4152                    region as the load region.  */
4153                 if (os->lma_region == NULL && os->load_base == NULL)
4154                   os->lma_region = os->region;
4155
4156                 if (os->lma_region != NULL && os->lma_region != os->region)
4157                   {
4158                     /* Set load_base, which will be handled later.  */
4159                     os->load_base = exp_intop (os->lma_region->current);
4160                     os->lma_region->current +=
4161                       TO_ADDR (os->bfd_section->size);
4162                     if (check_regions)
4163                       os_region_check (os, os->lma_region, NULL,
4164                                        os->bfd_section->lma);
4165                   }
4166               }
4167           }
4168           break;
4169
4170         case lang_constructors_statement_enum:
4171           dot = lang_size_sections_1 (constructor_list.head,
4172                                       output_section_statement,
4173                                       &s->wild_statement.children.head,
4174                                       fill, dot, relax, check_regions);
4175           break;
4176
4177         case lang_data_statement_enum:
4178           {
4179             unsigned int size = 0;
4180
4181             s->data_statement.output_vma =
4182               dot - output_section_statement->bfd_section->vma;
4183             s->data_statement.output_section =
4184               output_section_statement->bfd_section;
4185
4186             /* We might refer to provided symbols in the expression, and
4187                need to mark them as needed.  */
4188             exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4189
4190             switch (s->data_statement.type)
4191               {
4192               default:
4193                 abort ();
4194               case QUAD:
4195               case SQUAD:
4196                 size = QUAD_SIZE;
4197                 break;
4198               case LONG:
4199                 size = LONG_SIZE;
4200                 break;
4201               case SHORT:
4202                 size = SHORT_SIZE;
4203                 break;
4204               case BYTE:
4205                 size = BYTE_SIZE;
4206                 break;
4207               }
4208             if (size < TO_SIZE ((unsigned) 1))
4209               size = TO_SIZE ((unsigned) 1);
4210             dot += TO_ADDR (size);
4211             output_section_statement->bfd_section->size += size;
4212           }
4213           break;
4214
4215         case lang_reloc_statement_enum:
4216           {
4217             int size;
4218
4219             s->reloc_statement.output_vma =
4220               dot - output_section_statement->bfd_section->vma;
4221             s->reloc_statement.output_section =
4222               output_section_statement->bfd_section;
4223             size = bfd_get_reloc_size (s->reloc_statement.howto);
4224             dot += TO_ADDR (size);
4225             output_section_statement->bfd_section->size += size;
4226           }
4227           break;
4228
4229         case lang_wild_statement_enum:
4230           dot = lang_size_sections_1 (s->wild_statement.children.head,
4231                                       output_section_statement,
4232                                       &s->wild_statement.children.head,
4233                                       fill, dot, relax, check_regions);
4234           break;
4235
4236         case lang_object_symbols_statement_enum:
4237           link_info.create_object_symbols_section =
4238             output_section_statement->bfd_section;
4239           break;
4240
4241         case lang_output_statement_enum:
4242         case lang_target_statement_enum:
4243           break;
4244
4245         case lang_input_section_enum:
4246           {
4247             asection *i;
4248
4249             i = (*prev)->input_section.section;
4250             if (relax)
4251               {
4252                 bfd_boolean again;
4253
4254                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
4255                   einfo (_("%P%F: can't relax section: %E\n"));
4256                 if (again)
4257                   *relax = TRUE;
4258               }
4259             dot = size_input_section (prev, output_section_statement,
4260                                       output_section_statement->fill, dot);
4261           }
4262           break;
4263
4264         case lang_input_statement_enum:
4265           break;
4266
4267         case lang_fill_statement_enum:
4268           s->fill_statement.output_section =
4269             output_section_statement->bfd_section;
4270
4271           fill = s->fill_statement.fill;
4272           break;
4273
4274         case lang_assignment_statement_enum:
4275           {
4276             bfd_vma newdot = dot;
4277
4278             exp_fold_tree (s->assignment_statement.exp,
4279                            output_section_statement->bfd_section,
4280                            &newdot);
4281
4282             if (newdot != dot && !output_section_statement->ignored)
4283               {
4284                 if (output_section_statement == abs_output_section)
4285                   {
4286                     /* If we don't have an output section, then just adjust
4287                        the default memory address.  */
4288                     lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
4289                                                FALSE)->current = newdot;
4290                   }
4291                 else
4292                   {
4293                     /* Insert a pad after this statement.  We can't
4294                        put the pad before when relaxing, in case the
4295                        assignment references dot.  */
4296                     insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
4297                                 output_section_statement->bfd_section, dot);
4298
4299                     /* Don't neuter the pad below when relaxing.  */
4300                     s = s->header.next;
4301
4302                     /* If dot is advanced, this implies that the section
4303                        should have space allocated to it, unless the
4304                        user has explicitly stated that the section
4305                        should never be loaded.  */
4306                     if (!(output_section_statement->flags
4307                           & (SEC_NEVER_LOAD | SEC_ALLOC)))
4308                       output_section_statement->bfd_section->flags |= SEC_ALLOC;
4309                   }
4310                 dot = newdot;
4311               }
4312           }
4313           break;
4314
4315         case lang_padding_statement_enum:
4316           /* If this is the first time lang_size_sections is called,
4317              we won't have any padding statements.  If this is the
4318              second or later passes when relaxing, we should allow
4319              padding to shrink.  If padding is needed on this pass, it
4320              will be added back in.  */
4321           s->padding_statement.size = 0;
4322
4323           /* Make sure output_offset is valid.  If relaxation shrinks
4324              the section and this pad isn't needed, it's possible to
4325              have output_offset larger than the final size of the
4326              section.  bfd_set_section_contents will complain even for
4327              a pad size of zero.  */
4328           s->padding_statement.output_offset
4329             = dot - output_section_statement->bfd_section->vma;
4330           break;
4331
4332         case lang_group_statement_enum:
4333           dot = lang_size_sections_1 (s->group_statement.children.head,
4334                                       output_section_statement,
4335                                       &s->group_statement.children.head,
4336                                       fill, dot, relax, check_regions);
4337           break;
4338
4339         default:
4340           FAIL ();
4341           break;
4342
4343           /* We can only get here when relaxing is turned on.  */
4344         case lang_address_statement_enum:
4345           break;
4346         }
4347       prev = &s->header.next;
4348     }
4349   return dot;
4350 }
4351
4352 void
4353 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
4354 {
4355   lang_statement_iteration++;
4356   lang_size_sections_1 (statement_list.head, abs_output_section,
4357                         &statement_list.head, 0, 0, relax, check_regions);
4358 }
4359
4360 void
4361 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
4362 {
4363   expld.phase = lang_allocating_phase_enum;
4364   expld.dataseg.phase = exp_dataseg_none;
4365
4366   one_lang_size_sections_pass (relax, check_regions);
4367   if (expld.dataseg.phase == exp_dataseg_end_seen
4368       && link_info.relro && expld.dataseg.relro_end)
4369     {
4370       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
4371          to put expld.dataseg.relro on a (common) page boundary.  */
4372       bfd_vma old_min_base, relro_end, maxpage;
4373
4374       expld.dataseg.phase = exp_dataseg_relro_adjust;
4375       old_min_base = expld.dataseg.min_base;
4376       maxpage = expld.dataseg.maxpagesize;
4377       expld.dataseg.base += (-expld.dataseg.relro_end
4378                              & (expld.dataseg.pagesize - 1));
4379       /* Compute the expected PT_GNU_RELRO segment end.  */
4380       relro_end = (expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
4381                   & ~(expld.dataseg.pagesize - 1);
4382       if (old_min_base + maxpage < expld.dataseg.base)
4383         {
4384           expld.dataseg.base -= maxpage;
4385           relro_end -= maxpage;
4386         }
4387       one_lang_size_sections_pass (relax, check_regions);
4388       if (expld.dataseg.relro_end > relro_end)
4389         {
4390           /* The alignment of sections between DATA_SEGMENT_ALIGN
4391              and DATA_SEGMENT_RELRO_END caused huge padding to be
4392              inserted at DATA_SEGMENT_RELRO_END.  Try some other base.  */
4393           asection *sec;
4394           unsigned int max_alignment_power = 0;
4395
4396           /* Find maximum alignment power of sections between
4397              DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END.  */
4398           for (sec = output_bfd->sections; sec; sec = sec->next)
4399             if (sec->vma >= expld.dataseg.base
4400                 && sec->vma < expld.dataseg.relro_end
4401                 && sec->alignment_power > max_alignment_power)
4402               max_alignment_power = sec->alignment_power;
4403
4404           if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
4405             {
4406               if (expld.dataseg.base - (1 << max_alignment_power)
4407                   < old_min_base)
4408                 expld.dataseg.base += expld.dataseg.pagesize;
4409               expld.dataseg.base -= (1 << max_alignment_power);
4410               one_lang_size_sections_pass (relax, check_regions);
4411             }
4412         }
4413       link_info.relro_start = expld.dataseg.base;
4414       link_info.relro_end = expld.dataseg.relro_end;
4415     }
4416   else if (expld.dataseg.phase == exp_dataseg_end_seen)
4417     {
4418       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
4419          a page could be saved in the data segment.  */
4420       bfd_vma first, last;
4421
4422       first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
4423       last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
4424       if (first && last
4425           && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
4426               != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
4427           && first + last <= expld.dataseg.pagesize)
4428         {
4429           expld.dataseg.phase = exp_dataseg_adjust;
4430           one_lang_size_sections_pass (relax, check_regions);
4431         }
4432     }
4433
4434   expld.phase = lang_final_phase_enum;
4435 }
4436
4437 /* Worker function for lang_do_assignments.  Recursiveness goes here.  */
4438
4439 static bfd_vma
4440 lang_do_assignments_1
4441   (lang_statement_union_type *s,
4442    lang_output_section_statement_type *output_section_statement,
4443    fill_type *fill,
4444    bfd_vma dot)
4445 {
4446   for (; s != NULL; s = s->header.next)
4447     {
4448       switch (s->header.type)
4449         {
4450         case lang_constructors_statement_enum:
4451           dot = lang_do_assignments_1 (constructor_list.head,
4452                                        output_section_statement,
4453                                        fill,
4454                                        dot);
4455           break;
4456
4457         case lang_output_section_statement_enum:
4458           {
4459             lang_output_section_statement_type *os;
4460
4461             os = &(s->output_section_statement);
4462             if (os->bfd_section != NULL && !os->ignored)
4463               {
4464                 dot = os->bfd_section->vma;
4465                 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
4466                 /* .tbss sections effectively have zero size.  */
4467                 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4468                     || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4469                     || link_info.relocatable)
4470                   dot += TO_ADDR (os->bfd_section->size);
4471               }
4472             if (os->load_base)
4473               {
4474                 /* If nothing has been placed into the output section then
4475                    it won't have a bfd_section.  */
4476                 if (os->bfd_section && !os->ignored)
4477                   {
4478                     os->bfd_section->lma
4479                       = exp_get_abs_int (os->load_base, 0, "load base");
4480                   }
4481               }
4482           }
4483           break;
4484
4485         case lang_wild_statement_enum:
4486
4487           dot = lang_do_assignments_1 (s->wild_statement.children.head,
4488                                        output_section_statement,
4489                                        fill, dot);
4490           break;
4491
4492         case lang_object_symbols_statement_enum:
4493         case lang_output_statement_enum:
4494         case lang_target_statement_enum:
4495           break;
4496
4497         case lang_data_statement_enum:
4498           exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4499           if (expld.result.valid_p)
4500             s->data_statement.value = (expld.result.value
4501                                        + expld.result.section->vma);
4502           else
4503             einfo (_("%F%P: invalid data statement\n"));
4504           {
4505             unsigned int size;
4506             switch (s->data_statement.type)
4507               {
4508               default:
4509                 abort ();
4510               case QUAD:
4511               case SQUAD:
4512                 size = QUAD_SIZE;
4513                 break;
4514               case LONG:
4515                 size = LONG_SIZE;
4516                 break;
4517               case SHORT:
4518                 size = SHORT_SIZE;
4519                 break;
4520               case BYTE:
4521                 size = BYTE_SIZE;
4522                 break;
4523               }
4524             if (size < TO_SIZE ((unsigned) 1))
4525               size = TO_SIZE ((unsigned) 1);
4526             dot += TO_ADDR (size);
4527           }
4528           break;
4529
4530         case lang_reloc_statement_enum:
4531           exp_fold_tree (s->reloc_statement.addend_exp,
4532                          bfd_abs_section_ptr, &dot);
4533           if (expld.result.valid_p)
4534             s->reloc_statement.addend_value = expld.result.value;
4535           else
4536             einfo (_("%F%P: invalid reloc statement\n"));
4537           dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
4538           break;
4539
4540         case lang_input_section_enum:
4541           {
4542             asection *in = s->input_section.section;
4543
4544             if ((in->flags & SEC_EXCLUDE) == 0)
4545               dot += TO_ADDR (in->size);
4546           }
4547           break;
4548
4549         case lang_input_statement_enum:
4550           break;
4551
4552         case lang_fill_statement_enum:
4553           fill = s->fill_statement.fill;
4554           break;
4555
4556         case lang_assignment_statement_enum:
4557           exp_fold_tree (s->assignment_statement.exp,
4558                          output_section_statement->bfd_section,
4559                          &dot);
4560           break;
4561
4562         case lang_padding_statement_enum:
4563           dot += TO_ADDR (s->padding_statement.size);
4564           break;
4565
4566         case lang_group_statement_enum:
4567           dot = lang_do_assignments_1 (s->group_statement.children.head,
4568                                        output_section_statement,
4569                                        fill, dot);
4570           break;
4571
4572         default:
4573           FAIL ();
4574           break;
4575
4576         case lang_address_statement_enum:
4577           break;
4578         }
4579     }
4580   return dot;
4581 }
4582
4583 void
4584 lang_do_assignments (void)
4585 {
4586   lang_statement_iteration++;
4587   lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
4588   ldemul_do_assignments ();
4589 }
4590
4591 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
4592    operator .startof. (section_name), it produces an undefined symbol
4593    .startof.section_name.  Similarly, when it sees
4594    .sizeof. (section_name), it produces an undefined symbol
4595    .sizeof.section_name.  For all the output sections, we look for
4596    such symbols, and set them to the correct value.  */
4597
4598 static void
4599 lang_set_startof (void)
4600 {
4601   asection *s;
4602
4603   if (link_info.relocatable)
4604     return;
4605
4606   for (s = output_bfd->sections; s != NULL; s = s->next)
4607     {
4608       const char *secname;
4609       char *buf;
4610       struct bfd_link_hash_entry *h;
4611
4612       secname = bfd_get_section_name (output_bfd, s);
4613       buf = xmalloc (10 + strlen (secname));
4614
4615       sprintf (buf, ".startof.%s", secname);
4616       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
4617       if (h != NULL && h->type == bfd_link_hash_undefined)
4618         {
4619           h->type = bfd_link_hash_defined;
4620           h->u.def.value = bfd_get_section_vma (output_bfd, s);
4621           h->u.def.section = bfd_abs_section_ptr;
4622         }
4623
4624       sprintf (buf, ".sizeof.%s", secname);
4625       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
4626       if (h != NULL && h->type == bfd_link_hash_undefined)
4627         {
4628           h->type = bfd_link_hash_defined;
4629           h->u.def.value = TO_ADDR (s->size);
4630           h->u.def.section = bfd_abs_section_ptr;
4631         }
4632
4633       free (buf);
4634     }
4635 }
4636
4637 static void
4638 lang_finish (void)
4639 {
4640   struct bfd_link_hash_entry *h;
4641   bfd_boolean warn;
4642
4643   if (link_info.relocatable || link_info.shared)
4644     warn = FALSE;
4645   else
4646     warn = TRUE;
4647
4648   if (entry_symbol.name == NULL)
4649     {
4650       /* No entry has been specified.  Look for the default entry, but
4651          don't warn if we don't find it.  */
4652       entry_symbol.name = entry_symbol_default;
4653       warn = FALSE;
4654     }
4655
4656   h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
4657                             FALSE, FALSE, TRUE);
4658   if (h != NULL
4659       && (h->type == bfd_link_hash_defined
4660           || h->type == bfd_link_hash_defweak)
4661       && h->u.def.section->output_section != NULL)
4662     {
4663       bfd_vma val;
4664
4665       val = (h->u.def.value
4666              + bfd_get_section_vma (output_bfd,
4667                                     h->u.def.section->output_section)
4668              + h->u.def.section->output_offset);
4669       if (! bfd_set_start_address (output_bfd, val))
4670         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
4671     }
4672   else
4673     {
4674       bfd_vma val;
4675       const char *send;
4676
4677       /* We couldn't find the entry symbol.  Try parsing it as a
4678          number.  */
4679       val = bfd_scan_vma (entry_symbol.name, &send, 0);
4680       if (*send == '\0')
4681         {
4682           if (! bfd_set_start_address (output_bfd, val))
4683             einfo (_("%P%F: can't set start address\n"));
4684         }
4685       else
4686         {
4687           asection *ts;
4688
4689           /* Can't find the entry symbol, and it's not a number.  Use
4690              the first address in the text section.  */
4691           ts = bfd_get_section_by_name (output_bfd, entry_section);
4692           if (ts != NULL)
4693             {
4694               if (warn)
4695                 einfo (_("%P: warning: cannot find entry symbol %s;"
4696                          " defaulting to %V\n"),
4697                        entry_symbol.name,
4698                        bfd_get_section_vma (output_bfd, ts));
4699               if (! bfd_set_start_address (output_bfd,
4700                                            bfd_get_section_vma (output_bfd,
4701                                                                 ts)))
4702                 einfo (_("%P%F: can't set start address\n"));
4703             }
4704           else
4705             {
4706               if (warn)
4707                 einfo (_("%P: warning: cannot find entry symbol %s;"
4708                          " not setting start address\n"),
4709                        entry_symbol.name);
4710             }
4711         }
4712     }
4713
4714   /* Don't bfd_hash_table_free (&lang_definedness_table);
4715      map file output may result in a call of lang_track_definedness.  */
4716 }
4717
4718 /* This is a small function used when we want to ignore errors from
4719    BFD.  */
4720
4721 static void
4722 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
4723 {
4724   /* Don't do anything.  */
4725 }
4726
4727 /* Check that the architecture of all the input files is compatible
4728    with the output file.  Also call the backend to let it do any
4729    other checking that is needed.  */
4730
4731 static void
4732 lang_check (void)
4733 {
4734   lang_statement_union_type *file;
4735   bfd *input_bfd;
4736   const bfd_arch_info_type *compatible;
4737
4738   for (file = file_chain.head; file != NULL; file = file->input_statement.next)
4739     {
4740       input_bfd = file->input_statement.the_bfd;
4741       compatible
4742         = bfd_arch_get_compatible (input_bfd, output_bfd,
4743                                    command_line.accept_unknown_input_arch);
4744
4745       /* In general it is not possible to perform a relocatable
4746          link between differing object formats when the input
4747          file has relocations, because the relocations in the
4748          input format may not have equivalent representations in
4749          the output format (and besides BFD does not translate
4750          relocs for other link purposes than a final link).  */
4751       if ((link_info.relocatable || link_info.emitrelocations)
4752           && (compatible == NULL
4753               || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
4754           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
4755         {
4756           einfo (_("%P%F: Relocatable linking with relocations from"
4757                    " format %s (%B) to format %s (%B) is not supported\n"),
4758                  bfd_get_target (input_bfd), input_bfd,
4759                  bfd_get_target (output_bfd), output_bfd);
4760           /* einfo with %F exits.  */
4761         }
4762
4763       if (compatible == NULL)
4764         {
4765           if (command_line.warn_mismatch)
4766             einfo (_("%P: warning: %s architecture of input file `%B'"
4767                      " is incompatible with %s output\n"),
4768                    bfd_printable_name (input_bfd), input_bfd,
4769                    bfd_printable_name (output_bfd));
4770         }
4771       else if (bfd_count_sections (input_bfd))
4772         {
4773           /* If the input bfd has no contents, it shouldn't set the
4774              private data of the output bfd.  */
4775
4776           bfd_error_handler_type pfn = NULL;
4777
4778           /* If we aren't supposed to warn about mismatched input
4779              files, temporarily set the BFD error handler to a
4780              function which will do nothing.  We still want to call
4781              bfd_merge_private_bfd_data, since it may set up
4782              information which is needed in the output file.  */
4783           if (! command_line.warn_mismatch)
4784             pfn = bfd_set_error_handler (ignore_bfd_errors);
4785           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
4786             {
4787               if (command_line.warn_mismatch)
4788                 einfo (_("%P%X: failed to merge target specific data"
4789                          " of file %B\n"), input_bfd);
4790             }
4791           if (! command_line.warn_mismatch)
4792             bfd_set_error_handler (pfn);
4793         }
4794     }
4795 }
4796
4797 /* Look through all the global common symbols and attach them to the
4798    correct section.  The -sort-common command line switch may be used
4799    to roughly sort the entries by size.  */
4800
4801 static void
4802 lang_common (void)
4803 {
4804   if (command_line.inhibit_common_definition)
4805     return;
4806   if (link_info.relocatable
4807       && ! command_line.force_common_definition)
4808     return;
4809
4810   if (! config.sort_common)
4811     bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
4812   else
4813     {
4814       int power;
4815
4816       for (power = 4; power >= 0; power--)
4817         bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
4818     }
4819 }
4820
4821 /* Place one common symbol in the correct section.  */
4822
4823 static bfd_boolean
4824 lang_one_common (struct bfd_link_hash_entry *h, void *info)
4825 {
4826   unsigned int power_of_two;
4827   bfd_vma size;
4828   asection *section;
4829
4830   if (h->type != bfd_link_hash_common)
4831     return TRUE;
4832
4833   size = h->u.c.size;
4834   power_of_two = h->u.c.p->alignment_power;
4835
4836   if (config.sort_common
4837       && power_of_two < (unsigned int) *(int *) info)
4838     return TRUE;
4839
4840   section = h->u.c.p->section;
4841
4842   /* Increase the size of the section to align the common sym.  */
4843   section->size += ((bfd_vma) 1 << (power_of_two + opb_shift)) - 1;
4844   section->size &= (- (bfd_vma) 1 << (power_of_two + opb_shift));
4845
4846   /* Adjust the alignment if necessary.  */
4847   if (power_of_two > section->alignment_power)
4848     section->alignment_power = power_of_two;
4849
4850   /* Change the symbol from common to defined.  */
4851   h->type = bfd_link_hash_defined;
4852   h->u.def.section = section;
4853   h->u.def.value = section->size;
4854
4855   /* Increase the size of the section.  */
4856   section->size += size;
4857
4858   /* Make sure the section is allocated in memory, and make sure that
4859      it is no longer a common section.  */
4860   section->flags |= SEC_ALLOC;
4861   section->flags &= ~SEC_IS_COMMON;
4862
4863   if (config.map_file != NULL)
4864     {
4865       static bfd_boolean header_printed;
4866       int len;
4867       char *name;
4868       char buf[50];
4869
4870       if (! header_printed)
4871         {
4872           minfo (_("\nAllocating common symbols\n"));
4873           minfo (_("Common symbol       size              file\n\n"));
4874           header_printed = TRUE;
4875         }
4876
4877       name = demangle (h->root.string);
4878       minfo ("%s", name);
4879       len = strlen (name);
4880       free (name);
4881
4882       if (len >= 19)
4883         {
4884           print_nl ();
4885           len = 0;
4886         }
4887       while (len < 20)
4888         {
4889           print_space ();
4890           ++len;
4891         }
4892
4893       minfo ("0x");
4894       if (size <= 0xffffffff)
4895         sprintf (buf, "%lx", (unsigned long) size);
4896       else
4897         sprintf_vma (buf, size);
4898       minfo ("%s", buf);
4899       len = strlen (buf);
4900
4901       while (len < 16)
4902         {
4903           print_space ();
4904           ++len;
4905         }
4906
4907       minfo ("%B\n", section->owner);
4908     }
4909
4910   return TRUE;
4911 }
4912
4913 /* Run through the input files and ensure that every input section has
4914    somewhere to go.  If one is found without a destination then create
4915    an input request and place it into the statement tree.  */
4916
4917 static void
4918 lang_place_orphans (void)
4919 {
4920   LANG_FOR_EACH_INPUT_STATEMENT (file)
4921     {
4922       asection *s;
4923
4924       for (s = file->the_bfd->sections; s != NULL; s = s->next)
4925         {
4926           if (s->output_section == NULL)
4927             {
4928               /* This section of the file is not attached, root
4929                  around for a sensible place for it to go.  */
4930
4931               if (file->just_syms_flag)
4932                 bfd_link_just_syms (file->the_bfd, s, &link_info);
4933               else if ((s->flags & SEC_EXCLUDE) != 0)
4934                 s->output_section = bfd_abs_section_ptr;
4935               else if (strcmp (s->name, "COMMON") == 0)
4936                 {
4937                   /* This is a lonely common section which must have
4938                      come from an archive.  We attach to the section
4939                      with the wildcard.  */
4940                   if (! link_info.relocatable
4941                       || command_line.force_common_definition)
4942                     {
4943                       if (default_common_section == NULL)
4944                         {
4945                           default_common_section =
4946                             lang_output_section_statement_lookup (".bss");
4947
4948                         }
4949                       lang_add_section (&default_common_section->children, s,
4950                                         default_common_section, file);
4951                     }
4952                 }
4953               else if (ldemul_place_orphan (file, s))
4954                 ;
4955               else
4956                 {
4957                   lang_output_section_statement_type *os;
4958
4959                   os = lang_output_section_statement_lookup (s->name);
4960                   lang_add_section (&os->children, s, os, file);
4961                 }
4962             }
4963         }
4964     }
4965 }
4966
4967 void
4968 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
4969 {
4970   flagword *ptr_flags;
4971
4972   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
4973   while (*flags)
4974     {
4975       switch (*flags)
4976         {
4977         case 'A': case 'a':
4978           *ptr_flags |= SEC_ALLOC;
4979           break;
4980
4981         case 'R': case 'r':
4982           *ptr_flags |= SEC_READONLY;
4983           break;
4984
4985         case 'W': case 'w':
4986           *ptr_flags |= SEC_DATA;
4987           break;
4988
4989         case 'X': case 'x':
4990           *ptr_flags |= SEC_CODE;
4991           break;
4992
4993         case 'L': case 'l':
4994         case 'I': case 'i':
4995           *ptr_flags |= SEC_LOAD;
4996           break;
4997
4998         default:
4999           einfo (_("%P%F: invalid syntax in flags\n"));
5000           break;
5001         }
5002       flags++;
5003     }
5004 }
5005
5006 /* Call a function on each input file.  This function will be called
5007    on an archive, but not on the elements.  */
5008
5009 void
5010 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
5011 {
5012   lang_input_statement_type *f;
5013
5014   for (f = (lang_input_statement_type *) input_file_chain.head;
5015        f != NULL;
5016        f = (lang_input_statement_type *) f->next_real_file)
5017     func (f);
5018 }
5019
5020 /* Call a function on each file.  The function will be called on all
5021    the elements of an archive which are included in the link, but will
5022    not be called on the archive file itself.  */
5023
5024 void
5025 lang_for_each_file (void (*func) (lang_input_statement_type *))
5026 {
5027   LANG_FOR_EACH_INPUT_STATEMENT (f)
5028     {
5029       func (f);
5030     }
5031 }
5032
5033 void
5034 ldlang_add_file (lang_input_statement_type *entry)
5035 {
5036   bfd **pp;
5037
5038   lang_statement_append (&file_chain,
5039                          (lang_statement_union_type *) entry,
5040                          &entry->next);
5041
5042   /* The BFD linker needs to have a list of all input BFDs involved in
5043      a link.  */
5044   ASSERT (entry->the_bfd->link_next == NULL);
5045   ASSERT (entry->the_bfd != output_bfd);
5046   for (pp = &link_info.input_bfds; *pp != NULL; pp = &(*pp)->link_next)
5047     ;
5048   *pp = entry->the_bfd;
5049   entry->the_bfd->usrdata = entry;
5050   bfd_set_gp_size (entry->the_bfd, g_switch_value);
5051
5052   /* Look through the sections and check for any which should not be
5053      included in the link.  We need to do this now, so that we can
5054      notice when the backend linker tries to report multiple
5055      definition errors for symbols which are in sections we aren't
5056      going to link.  FIXME: It might be better to entirely ignore
5057      symbols which are defined in sections which are going to be
5058      discarded.  This would require modifying the backend linker for
5059      each backend which might set the SEC_LINK_ONCE flag.  If we do
5060      this, we should probably handle SEC_EXCLUDE in the same way.  */
5061
5062   bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
5063 }
5064
5065 void
5066 lang_add_output (const char *name, int from_script)
5067 {
5068   /* Make -o on command line override OUTPUT in script.  */
5069   if (!had_output_filename || !from_script)
5070     {
5071       output_filename = name;
5072       had_output_filename = TRUE;
5073     }
5074 }
5075
5076 static lang_output_section_statement_type *current_section;
5077
5078 static int
5079 topower (int x)
5080 {
5081   unsigned int i = 1;
5082   int l;
5083
5084   if (x < 0)
5085     return -1;
5086
5087   for (l = 0; l < 32; l++)
5088     {
5089       if (i >= (unsigned int) x)
5090         return l;
5091       i <<= 1;
5092     }
5093
5094   return 0;
5095 }
5096
5097 lang_output_section_statement_type *
5098 lang_enter_output_section_statement (const char *output_section_statement_name,
5099                                      etree_type *address_exp,
5100                                      enum section_type sectype,
5101                                      etree_type *align,
5102                                      etree_type *subalign,
5103                                      etree_type *ebase,
5104                                      int constraint)
5105 {
5106   lang_output_section_statement_type *os;
5107
5108   current_section =
5109    os =
5110     lang_output_section_statement_lookup_1 (output_section_statement_name,
5111                                             constraint);
5112
5113   /* Make next things chain into subchain of this.  */
5114
5115   if (os->addr_tree == NULL)
5116     {
5117       os->addr_tree = address_exp;
5118     }
5119   os->sectype = sectype;
5120   if (sectype != noload_section)
5121     os->flags = SEC_NO_FLAGS;
5122   else
5123     os->flags = SEC_NEVER_LOAD;
5124   os->block_value = 1;
5125   stat_ptr = &os->children;
5126
5127   os->subsection_alignment =
5128     topower (exp_get_value_int (subalign, -1, "subsection alignment"));
5129   os->section_alignment =
5130     topower (exp_get_value_int (align, -1, "section alignment"));
5131
5132   os->load_base = ebase;
5133   return os;
5134 }
5135
5136 void
5137 lang_final (void)
5138 {
5139   lang_output_statement_type *new =
5140     new_stat (lang_output_statement, stat_ptr);
5141
5142   new->name = output_filename;
5143 }
5144
5145 /* Reset the current counters in the regions.  */
5146
5147 void
5148 lang_reset_memory_regions (void)
5149 {
5150   lang_memory_region_type *p = lang_memory_region_list;
5151   asection *o;
5152   lang_output_section_statement_type *os;
5153
5154   for (p = lang_memory_region_list; p != NULL; p = p->next)
5155     {
5156       p->old_length = (bfd_size_type) (p->current - p->origin);
5157       p->current = p->origin;
5158     }
5159
5160   for (os = &lang_output_section_statement.head->output_section_statement;
5161        os != NULL;
5162        os = os->next)
5163     os->processed = 0;
5164
5165   for (o = output_bfd->sections; o != NULL; o = o->next)
5166     {
5167       /* Save the last size for possible use by bfd_relax_section.  */
5168       o->rawsize = o->size;
5169       o->size = 0;
5170     }
5171 }
5172
5173 /* Worker for lang_gc_sections_1.  */
5174
5175 static void
5176 gc_section_callback (lang_wild_statement_type *ptr,
5177                      struct wildcard_list *sec ATTRIBUTE_UNUSED,
5178                      asection *section,
5179                      lang_input_statement_type *file ATTRIBUTE_UNUSED,
5180                      void *data ATTRIBUTE_UNUSED)
5181 {
5182   /* If the wild pattern was marked KEEP, the member sections
5183      should be as well.  */
5184   if (ptr->keep_sections)
5185     section->flags |= SEC_KEEP;
5186 }
5187
5188 /* Iterate over sections marking them against GC.  */
5189
5190 static void
5191 lang_gc_sections_1 (lang_statement_union_type *s)
5192 {
5193   for (; s != NULL; s = s->header.next)
5194     {
5195       switch (s->header.type)
5196         {
5197         case lang_wild_statement_enum:
5198           walk_wild (&s->wild_statement, gc_section_callback, NULL);
5199           break;
5200         case lang_constructors_statement_enum:
5201           lang_gc_sections_1 (constructor_list.head);
5202           break;
5203         case lang_output_section_statement_enum:
5204           lang_gc_sections_1 (s->output_section_statement.children.head);
5205           break;
5206         case lang_group_statement_enum:
5207           lang_gc_sections_1 (s->group_statement.children.head);
5208           break;
5209         default:
5210           break;
5211         }
5212     }
5213 }
5214
5215 static void
5216 lang_gc_sections (void)
5217 {
5218   struct bfd_link_hash_entry *h;
5219   ldlang_undef_chain_list_type *ulist;
5220
5221   /* Keep all sections so marked in the link script.  */
5222
5223   lang_gc_sections_1 (statement_list.head);
5224
5225   /* Keep all sections containing symbols undefined on the command-line,
5226      and the section containing the entry symbol.  */
5227
5228   for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
5229     {
5230       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
5231                                 FALSE, FALSE, FALSE);
5232
5233       if (h != NULL
5234           && (h->type == bfd_link_hash_defined
5235               || h->type == bfd_link_hash_defweak)
5236           && ! bfd_is_abs_section (h->u.def.section))
5237         {
5238           h->u.def.section->flags |= SEC_KEEP;
5239         }
5240     }
5241
5242   /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5243      the special case of debug info.  (See bfd/stabs.c)
5244      Twiddle the flag here, to simplify later linker code.  */
5245   if (link_info.relocatable)
5246     {
5247       LANG_FOR_EACH_INPUT_STATEMENT (f)
5248         {
5249           asection *sec;
5250           for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
5251             if ((sec->flags & SEC_DEBUGGING) == 0)
5252               sec->flags &= ~SEC_EXCLUDE;
5253         }
5254     }
5255
5256   if (link_info.gc_sections)
5257     bfd_gc_sections (output_bfd, &link_info);
5258 }
5259
5260 void
5261 lang_process (void)
5262 {
5263   current_target = default_target;
5264
5265   /* Open the output file.  */
5266   lang_for_each_statement (ldlang_open_output);
5267   init_opb ();
5268
5269   ldemul_create_output_section_statements ();
5270
5271   /* Add to the hash table all undefineds on the command line.  */
5272   lang_place_undefineds ();
5273
5274   if (!bfd_section_already_linked_table_init ())
5275     einfo (_("%P%F: Failed to create hash table\n"));
5276
5277   /* Create a bfd for each input file.  */
5278   current_target = default_target;
5279   open_input_bfds (statement_list.head, FALSE);
5280
5281   link_info.gc_sym_list = &entry_symbol;
5282   if (entry_symbol.name == NULL)
5283     link_info.gc_sym_list = ldlang_undef_chain_list_head;
5284
5285   ldemul_after_open ();
5286
5287   bfd_section_already_linked_table_free ();
5288
5289   /* Make sure that we're not mixing architectures.  We call this
5290      after all the input files have been opened, but before we do any
5291      other processing, so that any operations merge_private_bfd_data
5292      does on the output file will be known during the rest of the
5293      link.  */
5294   lang_check ();
5295
5296   /* Handle .exports instead of a version script if we're told to do so.  */
5297   if (command_line.version_exports_section)
5298     lang_do_version_exports_section ();
5299
5300   /* Build all sets based on the information gathered from the input
5301      files.  */
5302   ldctor_build_sets ();
5303
5304   /* Remove unreferenced sections if asked to.  */
5305   lang_gc_sections ();
5306
5307   /* Size up the common data.  */
5308   lang_common ();
5309
5310   /* Update wild statements.  */
5311   update_wild_statements (statement_list.head);
5312
5313   /* Run through the contours of the script and attach input sections
5314      to the correct output sections.  */
5315   map_input_to_output_sections (statement_list.head, NULL, NULL);
5316
5317   /* Find any sections not attached explicitly and handle them.  */
5318   lang_place_orphans ();
5319
5320   if (! link_info.relocatable)
5321     {
5322       asection *found;
5323
5324       /* Merge SEC_MERGE sections.  This has to be done after GC of
5325          sections, so that GCed sections are not merged, but before
5326          assigning dynamic symbols, since removing whole input sections
5327          is hard then.  */
5328       bfd_merge_sections (output_bfd, &link_info);
5329
5330       /* Look for a text section and set the readonly attribute in it.  */
5331       found = bfd_get_section_by_name (output_bfd, ".text");
5332
5333       if (found != NULL)
5334         {
5335           if (config.text_read_only)
5336             found->flags |= SEC_READONLY;
5337           else
5338             found->flags &= ~SEC_READONLY;
5339         }
5340     }
5341
5342   /* Do anything special before sizing sections.  This is where ELF
5343      and other back-ends size dynamic sections.  */
5344   ldemul_before_allocation ();
5345
5346   /* We must record the program headers before we try to fix the
5347      section positions, since they will affect SIZEOF_HEADERS.  */
5348   lang_record_phdrs ();
5349
5350   /* Size up the sections.  */
5351   lang_size_sections (NULL, !command_line.relax);
5352
5353   /* Now run around and relax if we can.  */
5354   if (command_line.relax)
5355     {
5356       /* Keep relaxing until bfd_relax_section gives up.  */
5357       bfd_boolean relax_again;
5358
5359       do
5360         {
5361           relax_again = FALSE;
5362
5363           /* Note: pe-dll.c does something like this also.  If you find
5364              you need to change this code, you probably need to change
5365              pe-dll.c also.  DJ  */
5366
5367           /* Do all the assignments with our current guesses as to
5368              section sizes.  */
5369           lang_do_assignments ();
5370
5371           /* We must do this after lang_do_assignments, because it uses
5372              size.  */
5373           lang_reset_memory_regions ();
5374
5375           /* Perform another relax pass - this time we know where the
5376              globals are, so can make a better guess.  */
5377           lang_size_sections (&relax_again, FALSE);
5378
5379           /* If the normal relax is done and the relax finalize pass
5380              is not performed yet, we perform another relax pass.  */
5381           if (!relax_again && link_info.need_relax_finalize)
5382             {
5383               link_info.need_relax_finalize = FALSE;
5384               relax_again = TRUE;
5385             }
5386         }
5387       while (relax_again);
5388
5389       /* Final extra sizing to report errors.  */
5390       lang_do_assignments ();
5391       lang_reset_memory_regions ();
5392       lang_size_sections (NULL, TRUE);
5393     }
5394
5395   /* See if anything special should be done now we know how big
5396      everything is.  */
5397   ldemul_after_allocation ();
5398
5399   /* Fix any .startof. or .sizeof. symbols.  */
5400   lang_set_startof ();
5401
5402   /* Do all the assignments, now that we know the final resting places
5403      of all the symbols.  */
5404
5405   lang_do_assignments ();
5406
5407   /* Make sure that the section addresses make sense.  */
5408   if (! link_info.relocatable
5409       && command_line.check_section_addresses)
5410     lang_check_section_addresses ();
5411
5412   /* Final stuffs.  */
5413   ldemul_finish ();
5414   lang_finish ();
5415 }
5416
5417 /* EXPORTED TO YACC */
5418
5419 void
5420 lang_add_wild (struct wildcard_spec *filespec,
5421                struct wildcard_list *section_list,
5422                bfd_boolean keep_sections)
5423 {
5424   struct wildcard_list *curr, *next;
5425   lang_wild_statement_type *new;
5426
5427   /* Reverse the list as the parser puts it back to front.  */
5428   for (curr = section_list, section_list = NULL;
5429        curr != NULL;
5430        section_list = curr, curr = next)
5431     {
5432       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
5433         placed_commons = TRUE;
5434
5435       next = curr->next;
5436       curr->next = section_list;
5437     }
5438
5439   if (filespec != NULL && filespec->name != NULL)
5440     {
5441       if (strcmp (filespec->name, "*") == 0)
5442         filespec->name = NULL;
5443       else if (! wildcardp (filespec->name))
5444         lang_has_input_file = TRUE;
5445     }
5446
5447   new = new_stat (lang_wild_statement, stat_ptr);
5448   new->filename = NULL;
5449   new->filenames_sorted = FALSE;
5450   if (filespec != NULL)
5451     {
5452       new->filename = filespec->name;
5453       new->filenames_sorted = filespec->sorted == by_name;
5454     }
5455   new->section_list = section_list;
5456   new->keep_sections = keep_sections;
5457   lang_list_init (&new->children);
5458   analyze_walk_wild_section_handler (new);
5459 }
5460
5461 void
5462 lang_section_start (const char *name, etree_type *address,
5463                     const segment_type *segment)
5464 {
5465   lang_address_statement_type *ad;
5466
5467   ad = new_stat (lang_address_statement, stat_ptr);
5468   ad->section_name = name;
5469   ad->address = address;
5470   ad->segment = segment;
5471 }
5472
5473 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
5474    because of a -e argument on the command line, or zero if this is
5475    called by ENTRY in a linker script.  Command line arguments take
5476    precedence.  */
5477
5478 void
5479 lang_add_entry (const char *name, bfd_boolean cmdline)
5480 {
5481   if (entry_symbol.name == NULL
5482       || cmdline
5483       || ! entry_from_cmdline)
5484     {
5485       entry_symbol.name = name;
5486       entry_from_cmdline = cmdline;
5487     }
5488 }
5489
5490 /* Set the default start symbol to NAME.  .em files should use this,
5491    not lang_add_entry, to override the use of "start" if neither the
5492    linker script nor the command line specifies an entry point.  NAME
5493    must be permanently allocated.  */
5494 void
5495 lang_default_entry (const char *name)
5496 {
5497   entry_symbol_default = name;
5498 }
5499
5500 void
5501 lang_add_target (const char *name)
5502 {
5503   lang_target_statement_type *new = new_stat (lang_target_statement,
5504                                               stat_ptr);
5505
5506   new->target = name;
5507
5508 }
5509
5510 void
5511 lang_add_map (const char *name)
5512 {
5513   while (*name)
5514     {
5515       switch (*name)
5516         {
5517         case 'F':
5518           map_option_f = TRUE;
5519           break;
5520         }
5521       name++;
5522     }
5523 }
5524
5525 void
5526 lang_add_fill (fill_type *fill)
5527 {
5528   lang_fill_statement_type *new = new_stat (lang_fill_statement,
5529                                             stat_ptr);
5530
5531   new->fill = fill;
5532 }
5533
5534 void
5535 lang_add_data (int type, union etree_union *exp)
5536 {
5537
5538   lang_data_statement_type *new = new_stat (lang_data_statement,
5539                                             stat_ptr);
5540
5541   new->exp = exp;
5542   new->type = type;
5543
5544 }
5545
5546 /* Create a new reloc statement.  RELOC is the BFD relocation type to
5547    generate.  HOWTO is the corresponding howto structure (we could
5548    look this up, but the caller has already done so).  SECTION is the
5549    section to generate a reloc against, or NAME is the name of the
5550    symbol to generate a reloc against.  Exactly one of SECTION and
5551    NAME must be NULL.  ADDEND is an expression for the addend.  */
5552
5553 void
5554 lang_add_reloc (bfd_reloc_code_real_type reloc,
5555                 reloc_howto_type *howto,
5556                 asection *section,
5557                 const char *name,
5558                 union etree_union *addend)
5559 {
5560   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
5561
5562   p->reloc = reloc;
5563   p->howto = howto;
5564   p->section = section;
5565   p->name = name;
5566   p->addend_exp = addend;
5567
5568   p->addend_value = 0;
5569   p->output_section = NULL;
5570   p->output_vma = 0;
5571 }
5572
5573 lang_assignment_statement_type *
5574 lang_add_assignment (etree_type *exp)
5575 {
5576   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
5577                                                   stat_ptr);
5578
5579   new->exp = exp;
5580   return new;
5581 }
5582
5583 void
5584 lang_add_attribute (enum statement_enum attribute)
5585 {
5586   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
5587 }
5588
5589 void
5590 lang_startup (const char *name)
5591 {
5592   if (startup_file != NULL)
5593     {
5594       einfo (_("%P%Fmultiple STARTUP files\n"));
5595     }
5596   first_file->filename = name;
5597   first_file->local_sym_name = name;
5598   first_file->real = TRUE;
5599
5600   startup_file = name;
5601 }
5602
5603 void
5604 lang_float (bfd_boolean maybe)
5605 {
5606   lang_float_flag = maybe;
5607 }
5608
5609
5610 /* Work out the load- and run-time regions from a script statement, and
5611    store them in *LMA_REGION and *REGION respectively.
5612
5613    MEMSPEC is the name of the run-time region, or the value of
5614    DEFAULT_MEMORY_REGION if the statement didn't specify one.
5615    LMA_MEMSPEC is the name of the load-time region, or null if the
5616    statement didn't specify one.HAVE_LMA_P is TRUE if the statement
5617    had an explicit load address.
5618
5619    It is an error to specify both a load region and a load address.  */
5620
5621 static void
5622 lang_get_regions (lang_memory_region_type **region,
5623                   lang_memory_region_type **lma_region,
5624                   const char *memspec,
5625                   const char *lma_memspec,
5626                   bfd_boolean have_lma,
5627                   bfd_boolean have_vma)
5628 {
5629   *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
5630
5631   /* If no runtime region or VMA has been specified, but the load region
5632      has been specified, then use the load region for the runtime region
5633      as well.  */
5634   if (lma_memspec != NULL
5635       && ! have_vma
5636       && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
5637     *region = *lma_region;
5638   else
5639     *region = lang_memory_region_lookup (memspec, FALSE);
5640
5641   if (have_lma && lma_memspec != 0)
5642     einfo (_("%X%P:%S: section has both a load address and a load region\n"));
5643 }
5644
5645 void
5646 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
5647                                      lang_output_section_phdr_list *phdrs,
5648                                      const char *lma_memspec)
5649 {
5650   lang_get_regions (&current_section->region,
5651                     &current_section->lma_region,
5652                     memspec, lma_memspec,
5653                     current_section->load_base != NULL,
5654                     current_section->addr_tree != NULL);
5655   current_section->fill = fill;
5656   current_section->phdrs = phdrs;
5657   stat_ptr = &statement_list;
5658 }
5659
5660 /* Create an absolute symbol with the given name with the value of the
5661    address of first byte of the section named.
5662
5663    If the symbol already exists, then do nothing.  */
5664
5665 void
5666 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
5667 {
5668   struct bfd_link_hash_entry *h;
5669
5670   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
5671   if (h == NULL)
5672     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
5673
5674   if (h->type == bfd_link_hash_new
5675       || h->type == bfd_link_hash_undefined)
5676     {
5677       asection *sec;
5678
5679       h->type = bfd_link_hash_defined;
5680
5681       sec = bfd_get_section_by_name (output_bfd, secname);
5682       if (sec == NULL)
5683         h->u.def.value = 0;
5684       else
5685         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
5686
5687       h->u.def.section = bfd_abs_section_ptr;
5688     }
5689 }
5690
5691 /* Create an absolute symbol with the given name with the value of the
5692    address of the first byte after the end of the section named.
5693
5694    If the symbol already exists, then do nothing.  */
5695
5696 void
5697 lang_abs_symbol_at_end_of (const char *secname, const char *name)
5698 {
5699   struct bfd_link_hash_entry *h;
5700
5701   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
5702   if (h == NULL)
5703     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
5704
5705   if (h->type == bfd_link_hash_new
5706       || h->type == bfd_link_hash_undefined)
5707     {
5708       asection *sec;
5709
5710       h->type = bfd_link_hash_defined;
5711
5712       sec = bfd_get_section_by_name (output_bfd, secname);
5713       if (sec == NULL)
5714         h->u.def.value = 0;
5715       else
5716         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
5717                           + TO_ADDR (sec->size));
5718
5719       h->u.def.section = bfd_abs_section_ptr;
5720     }
5721 }
5722
5723 void
5724 lang_statement_append (lang_statement_list_type *list,
5725                        lang_statement_union_type *element,
5726                        lang_statement_union_type **field)
5727 {
5728   *(list->tail) = element;
5729   list->tail = field;
5730 }
5731
5732 /* Set the output format type.  -oformat overrides scripts.  */
5733
5734 void
5735 lang_add_output_format (const char *format,
5736                         const char *big,
5737                         const char *little,
5738                         int from_script)
5739 {
5740   if (output_target == NULL || !from_script)
5741     {
5742       if (command_line.endian == ENDIAN_BIG
5743           && big != NULL)
5744         format = big;
5745       else if (command_line.endian == ENDIAN_LITTLE
5746                && little != NULL)
5747         format = little;
5748
5749       output_target = format;
5750     }
5751 }
5752
5753 /* Enter a group.  This creates a new lang_group_statement, and sets
5754    stat_ptr to build new statements within the group.  */
5755
5756 void
5757 lang_enter_group (void)
5758 {
5759   lang_group_statement_type *g;
5760
5761   g = new_stat (lang_group_statement, stat_ptr);
5762   lang_list_init (&g->children);
5763   stat_ptr = &g->children;
5764 }
5765
5766 /* Leave a group.  This just resets stat_ptr to start writing to the
5767    regular list of statements again.  Note that this will not work if
5768    groups can occur inside anything else which can adjust stat_ptr,
5769    but currently they can't.  */
5770
5771 void
5772 lang_leave_group (void)
5773 {
5774   stat_ptr = &statement_list;
5775 }
5776
5777 /* Add a new program header.  This is called for each entry in a PHDRS
5778    command in a linker script.  */
5779
5780 void
5781 lang_new_phdr (const char *name,
5782                etree_type *type,
5783                bfd_boolean filehdr,
5784                bfd_boolean phdrs,
5785                etree_type *at,
5786                etree_type *flags)
5787 {
5788   struct lang_phdr *n, **pp;
5789
5790   n = stat_alloc (sizeof (struct lang_phdr));
5791   n->next = NULL;
5792   n->name = name;
5793   n->type = exp_get_value_int (type, 0, "program header type");
5794   n->filehdr = filehdr;
5795   n->phdrs = phdrs;
5796   n->at = at;
5797   n->flags = flags;
5798
5799   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
5800     ;
5801   *pp = n;
5802 }
5803
5804 /* Record the program header information in the output BFD.  FIXME: We
5805    should not be calling an ELF specific function here.  */
5806
5807 static void
5808 lang_record_phdrs (void)
5809 {
5810   unsigned int alc;
5811   asection **secs;
5812   lang_output_section_phdr_list *last;
5813   struct lang_phdr *l;
5814   lang_output_section_statement_type *os;
5815
5816   alc = 10;
5817   secs = xmalloc (alc * sizeof (asection *));
5818   last = NULL;
5819   for (l = lang_phdr_list; l != NULL; l = l->next)
5820     {
5821       unsigned int c;
5822       flagword flags;
5823       bfd_vma at;
5824
5825       c = 0;
5826       for (os = &lang_output_section_statement.head->output_section_statement;
5827            os != NULL;
5828            os = os->next)
5829         {
5830           lang_output_section_phdr_list *pl;
5831
5832           if (os->constraint == -1)
5833             continue;
5834
5835           pl = os->phdrs;
5836           if (pl != NULL)
5837             last = pl;
5838           else
5839             {
5840               if (os->sectype == noload_section
5841                   || os->bfd_section == NULL
5842                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
5843                 continue;
5844               pl = last;
5845             }
5846
5847           if (os->bfd_section == NULL)
5848             continue;
5849
5850           for (; pl != NULL; pl = pl->next)
5851             {
5852               if (strcmp (pl->name, l->name) == 0)
5853                 {
5854                   if (c >= alc)
5855                     {
5856                       alc *= 2;
5857                       secs = xrealloc (secs, alc * sizeof (asection *));
5858                     }
5859                   secs[c] = os->bfd_section;
5860                   ++c;
5861                   pl->used = TRUE;
5862                 }
5863             }
5864         }
5865
5866       if (l->flags == NULL)
5867         flags = 0;
5868       else
5869         flags = exp_get_vma (l->flags, 0, "phdr flags");
5870
5871       if (l->at == NULL)
5872         at = 0;
5873       else
5874         at = exp_get_vma (l->at, 0, "phdr load address");
5875
5876       if (! bfd_record_phdr (output_bfd, l->type,
5877                              l->flags != NULL, flags, l->at != NULL,
5878                              at, l->filehdr, l->phdrs, c, secs))
5879         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
5880     }
5881
5882   free (secs);
5883
5884   /* Make sure all the phdr assignments succeeded.  */
5885   for (os = &lang_output_section_statement.head->output_section_statement;
5886        os != NULL;
5887        os = os->next)
5888     {
5889       lang_output_section_phdr_list *pl;
5890
5891       if (os->constraint == -1
5892           || os->bfd_section == NULL)
5893         continue;
5894
5895       for (pl = os->phdrs;
5896            pl != NULL;
5897            pl = pl->next)
5898         if (! pl->used && strcmp (pl->name, "NONE") != 0)
5899           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
5900                  os->name, pl->name);
5901     }
5902 }
5903
5904 /* Record a list of sections which may not be cross referenced.  */
5905
5906 void
5907 lang_add_nocrossref (lang_nocrossref_type *l)
5908 {
5909   struct lang_nocrossrefs *n;
5910
5911   n = xmalloc (sizeof *n);
5912   n->next = nocrossref_list;
5913   n->list = l;
5914   nocrossref_list = n;
5915
5916   /* Set notice_all so that we get informed about all symbols.  */
5917   link_info.notice_all = TRUE;
5918 }
5919 \f
5920 /* Overlay handling.  We handle overlays with some static variables.  */
5921
5922 /* The overlay virtual address.  */
5923 static etree_type *overlay_vma;
5924 /* And subsection alignment.  */
5925 static etree_type *overlay_subalign;
5926
5927 /* An expression for the maximum section size seen so far.  */
5928 static etree_type *overlay_max;
5929
5930 /* A list of all the sections in this overlay.  */
5931
5932 struct overlay_list {
5933   struct overlay_list *next;
5934   lang_output_section_statement_type *os;
5935 };
5936
5937 static struct overlay_list *overlay_list;
5938
5939 /* Start handling an overlay.  */
5940
5941 void
5942 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
5943 {
5944   /* The grammar should prevent nested overlays from occurring.  */
5945   ASSERT (overlay_vma == NULL
5946           && overlay_subalign == NULL
5947           && overlay_max == NULL);
5948
5949   overlay_vma = vma_expr;
5950   overlay_subalign = subalign;
5951 }
5952
5953 /* Start a section in an overlay.  We handle this by calling
5954    lang_enter_output_section_statement with the correct VMA.
5955    lang_leave_overlay sets up the LMA and memory regions.  */
5956
5957 void
5958 lang_enter_overlay_section (const char *name)
5959 {
5960   struct overlay_list *n;
5961   etree_type *size;
5962
5963   lang_enter_output_section_statement (name, overlay_vma, normal_section,
5964                                        0, overlay_subalign, 0, 0);
5965
5966   /* If this is the first section, then base the VMA of future
5967      sections on this one.  This will work correctly even if `.' is
5968      used in the addresses.  */
5969   if (overlay_list == NULL)
5970     overlay_vma = exp_nameop (ADDR, name);
5971
5972   /* Remember the section.  */
5973   n = xmalloc (sizeof *n);
5974   n->os = current_section;
5975   n->next = overlay_list;
5976   overlay_list = n;
5977
5978   size = exp_nameop (SIZEOF, name);
5979
5980   /* Arrange to work out the maximum section end address.  */
5981   if (overlay_max == NULL)
5982     overlay_max = size;
5983   else
5984     overlay_max = exp_binop (MAX_K, overlay_max, size);
5985 }
5986
5987 /* Finish a section in an overlay.  There isn't any special to do
5988    here.  */
5989
5990 void
5991 lang_leave_overlay_section (fill_type *fill,
5992                             lang_output_section_phdr_list *phdrs)
5993 {
5994   const char *name;
5995   char *clean, *s2;
5996   const char *s1;
5997   char *buf;
5998
5999   name = current_section->name;
6000
6001   /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6002      region and that no load-time region has been specified.  It doesn't
6003      really matter what we say here, since lang_leave_overlay will
6004      override it.  */
6005   lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
6006
6007   /* Define the magic symbols.  */
6008
6009   clean = xmalloc (strlen (name) + 1);
6010   s2 = clean;
6011   for (s1 = name; *s1 != '\0'; s1++)
6012     if (ISALNUM (*s1) || *s1 == '_')
6013       *s2++ = *s1;
6014   *s2 = '\0';
6015
6016   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
6017   sprintf (buf, "__load_start_%s", clean);
6018   lang_add_assignment (exp_assop ('=', buf,
6019                                   exp_nameop (LOADADDR, name)));
6020
6021   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
6022   sprintf (buf, "__load_stop_%s", clean);
6023   lang_add_assignment (exp_assop ('=', buf,
6024                                   exp_binop ('+',
6025                                              exp_nameop (LOADADDR, name),
6026                                              exp_nameop (SIZEOF, name))));
6027
6028   free (clean);
6029 }
6030
6031 /* Finish an overlay.  If there are any overlay wide settings, this
6032    looks through all the sections in the overlay and sets them.  */
6033
6034 void
6035 lang_leave_overlay (etree_type *lma_expr,
6036                     int nocrossrefs,
6037                     fill_type *fill,
6038                     const char *memspec,
6039                     lang_output_section_phdr_list *phdrs,
6040                     const char *lma_memspec)
6041 {
6042   lang_memory_region_type *region;
6043   lang_memory_region_type *lma_region;
6044   struct overlay_list *l;
6045   lang_nocrossref_type *nocrossref;
6046
6047   lang_get_regions (&region, &lma_region,
6048                     memspec, lma_memspec,
6049                     lma_expr != NULL, FALSE);
6050
6051   nocrossref = NULL;
6052
6053   /* After setting the size of the last section, set '.' to end of the
6054      overlay region.  */
6055   if (overlay_list != NULL)
6056     overlay_list->os->update_dot_tree
6057       = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
6058
6059   l = overlay_list;
6060   while (l != NULL)
6061     {
6062       struct overlay_list *next;
6063
6064       if (fill != NULL && l->os->fill == NULL)
6065         l->os->fill = fill;
6066
6067       l->os->region = region;
6068       l->os->lma_region = lma_region;
6069
6070       /* The first section has the load address specified in the
6071          OVERLAY statement.  The rest are worked out from that.
6072          The base address is not needed (and should be null) if
6073          an LMA region was specified.  */
6074       if (l->next == 0)
6075         l->os->load_base = lma_expr;
6076       else if (lma_region == 0)
6077         l->os->load_base = exp_binop ('+',
6078                                       exp_nameop (LOADADDR, l->next->os->name),
6079                                       exp_nameop (SIZEOF, l->next->os->name));
6080
6081       if (phdrs != NULL && l->os->phdrs == NULL)
6082         l->os->phdrs = phdrs;
6083
6084       if (nocrossrefs)
6085         {
6086           lang_nocrossref_type *nc;
6087
6088           nc = xmalloc (sizeof *nc);
6089           nc->name = l->os->name;
6090           nc->next = nocrossref;
6091           nocrossref = nc;
6092         }
6093
6094       next = l->next;
6095       free (l);
6096       l = next;
6097     }
6098
6099   if (nocrossref != NULL)
6100     lang_add_nocrossref (nocrossref);
6101
6102   overlay_vma = NULL;
6103   overlay_list = NULL;
6104   overlay_max = NULL;
6105 }
6106 \f
6107 /* Version handling.  This is only useful for ELF.  */
6108
6109 /* This global variable holds the version tree that we build.  */
6110
6111 struct bfd_elf_version_tree *lang_elf_version_info;
6112
6113 /* If PREV is NULL, return first version pattern matching particular symbol.
6114    If PREV is non-NULL, return first version pattern matching particular
6115    symbol after PREV (previously returned by lang_vers_match).  */
6116
6117 static struct bfd_elf_version_expr *
6118 lang_vers_match (struct bfd_elf_version_expr_head *head,
6119                  struct bfd_elf_version_expr *prev,
6120                  const char *sym)
6121 {
6122   const char *cxx_sym = sym;
6123   const char *java_sym = sym;
6124   struct bfd_elf_version_expr *expr = NULL;
6125
6126   if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6127     {
6128       cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
6129       if (!cxx_sym)
6130         cxx_sym = sym;
6131     }
6132   if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6133     {
6134       java_sym = cplus_demangle (sym, DMGL_JAVA);
6135       if (!java_sym)
6136         java_sym = sym;
6137     }
6138
6139   if (head->htab && (prev == NULL || prev->symbol))
6140     {
6141       struct bfd_elf_version_expr e;
6142
6143       switch (prev ? prev->mask : 0)
6144         {
6145           case 0:
6146             if (head->mask & BFD_ELF_VERSION_C_TYPE)
6147               {
6148                 e.symbol = sym;
6149                 expr = htab_find (head->htab, &e);
6150                 while (expr && strcmp (expr->symbol, sym) == 0)
6151                   if (expr->mask == BFD_ELF_VERSION_C_TYPE)
6152                     goto out_ret;
6153                 else
6154                   expr = expr->next;
6155               }
6156             /* Fallthrough */
6157           case BFD_ELF_VERSION_C_TYPE:
6158             if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6159               {
6160                 e.symbol = cxx_sym;
6161                 expr = htab_find (head->htab, &e);
6162                 while (expr && strcmp (expr->symbol, cxx_sym) == 0)
6163                   if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6164                     goto out_ret;
6165                 else
6166                   expr = expr->next;
6167               }
6168             /* Fallthrough */
6169           case BFD_ELF_VERSION_CXX_TYPE:
6170             if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6171               {
6172                 e.symbol = java_sym;
6173                 expr = htab_find (head->htab, &e);
6174                 while (expr && strcmp (expr->symbol, java_sym) == 0)
6175                   if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6176                     goto out_ret;
6177                 else
6178                   expr = expr->next;
6179               }
6180             /* Fallthrough */
6181           default:
6182             break;
6183         }
6184     }
6185
6186   /* Finally, try the wildcards.  */
6187   if (prev == NULL || prev->symbol)
6188     expr = head->remaining;
6189   else
6190     expr = prev->next;
6191   while (expr)
6192     {
6193       const char *s;
6194
6195       if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
6196         break;
6197
6198       if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6199         s = java_sym;
6200       else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6201         s = cxx_sym;
6202       else
6203         s = sym;
6204       if (fnmatch (expr->pattern, s, 0) == 0)
6205         break;
6206       expr = expr->next;
6207     }
6208
6209 out_ret:
6210   if (cxx_sym != sym)
6211     free ((char *) cxx_sym);
6212   if (java_sym != sym)
6213     free ((char *) java_sym);
6214   return expr;
6215 }
6216
6217 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
6218    return a string pointing to the symbol name.  */
6219
6220 static const char *
6221 realsymbol (const char *pattern)
6222 {
6223   const char *p;
6224   bfd_boolean changed = FALSE, backslash = FALSE;
6225   char *s, *symbol = xmalloc (strlen (pattern) + 1);
6226
6227   for (p = pattern, s = symbol; *p != '\0'; ++p)
6228     {
6229       /* It is a glob pattern only if there is no preceding
6230          backslash.  */
6231       if (! backslash && (*p == '?' || *p == '*' || *p == '['))
6232         {
6233           free (symbol);
6234           return NULL;
6235         }
6236
6237       if (backslash)
6238         {
6239           /* Remove the preceding backslash.  */
6240           *(s - 1) = *p;
6241           changed = TRUE;
6242         }
6243       else
6244         *s++ = *p;
6245
6246       backslash = *p == '\\';
6247     }
6248
6249   if (changed)
6250     {
6251       *s = '\0';
6252       return symbol;
6253     }
6254   else
6255     {
6256       free (symbol);
6257       return pattern;
6258     }
6259 }
6260
6261 /* This is called for each variable name or match expression.  */
6262
6263 struct bfd_elf_version_expr *
6264 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
6265                        const char *new,
6266                        const char *lang)
6267 {
6268   struct bfd_elf_version_expr *ret;
6269
6270   ret = xmalloc (sizeof *ret);
6271   ret->next = orig;
6272   ret->pattern = new;
6273   ret->symver = 0;
6274   ret->script = 0;
6275   ret->symbol = realsymbol (new);
6276
6277   if (lang == NULL || strcasecmp (lang, "C") == 0)
6278     ret->mask = BFD_ELF_VERSION_C_TYPE;
6279   else if (strcasecmp (lang, "C++") == 0)
6280     ret->mask = BFD_ELF_VERSION_CXX_TYPE;
6281   else if (strcasecmp (lang, "Java") == 0)
6282     ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
6283   else
6284     {
6285       einfo (_("%X%P: unknown language `%s' in version information\n"),
6286              lang);
6287       ret->mask = BFD_ELF_VERSION_C_TYPE;
6288     }
6289
6290   return ldemul_new_vers_pattern (ret);
6291 }
6292
6293 /* This is called for each set of variable names and match
6294    expressions.  */
6295
6296 struct bfd_elf_version_tree *
6297 lang_new_vers_node (struct bfd_elf_version_expr *globals,
6298                     struct bfd_elf_version_expr *locals)
6299 {
6300   struct bfd_elf_version_tree *ret;
6301
6302   ret = xcalloc (1, sizeof *ret);
6303   ret->globals.list = globals;
6304   ret->locals.list = locals;
6305   ret->match = lang_vers_match;
6306   ret->name_indx = (unsigned int) -1;
6307   return ret;
6308 }
6309
6310 /* This static variable keeps track of version indices.  */
6311
6312 static int version_index;
6313
6314 static hashval_t
6315 version_expr_head_hash (const void *p)
6316 {
6317   const struct bfd_elf_version_expr *e = p;
6318
6319   return htab_hash_string (e->symbol);
6320 }
6321
6322 static int
6323 version_expr_head_eq (const void *p1, const void *p2)
6324 {
6325   const struct bfd_elf_version_expr *e1 = p1;
6326   const struct bfd_elf_version_expr *e2 = p2;
6327
6328   return strcmp (e1->symbol, e2->symbol) == 0;
6329 }
6330
6331 static void
6332 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
6333 {
6334   size_t count = 0;
6335   struct bfd_elf_version_expr *e, *next;
6336   struct bfd_elf_version_expr **list_loc, **remaining_loc;
6337
6338   for (e = head->list; e; e = e->next)
6339     {
6340       if (e->symbol)
6341         count++;
6342       head->mask |= e->mask;
6343     }
6344
6345   if (count)
6346     {
6347       head->htab = htab_create (count * 2, version_expr_head_hash,
6348                                 version_expr_head_eq, NULL);
6349       list_loc = &head->list;
6350       remaining_loc = &head->remaining;
6351       for (e = head->list; e; e = next)
6352         {
6353           next = e->next;
6354           if (!e->symbol)
6355             {
6356               *remaining_loc = e;
6357               remaining_loc = &e->next;
6358             }
6359           else
6360             {
6361               void **loc = htab_find_slot (head->htab, e, INSERT);
6362
6363               if (*loc)
6364                 {
6365                   struct bfd_elf_version_expr *e1, *last;
6366
6367                   e1 = *loc;
6368                   last = NULL;
6369                   do
6370                     {
6371                       if (e1->mask == e->mask)
6372                         {
6373                           last = NULL;
6374                           break;
6375                         }
6376                       last = e1;
6377                       e1 = e1->next;
6378                     }
6379                   while (e1 && strcmp (e1->symbol, e->symbol) == 0);
6380
6381                   if (last == NULL)
6382                     {
6383                       /* This is a duplicate.  */
6384                       /* FIXME: Memory leak.  Sometimes pattern is not
6385                          xmalloced alone, but in larger chunk of memory.  */
6386                       /* free (e->symbol); */
6387                       free (e);
6388                     }
6389                   else
6390                     {
6391                       e->next = last->next;
6392                       last->next = e;
6393                     }
6394                 }
6395               else
6396                 {
6397                   *loc = e;
6398                   *list_loc = e;
6399                   list_loc = &e->next;
6400                 }
6401             }
6402         }
6403       *remaining_loc = NULL;
6404       *list_loc = head->remaining;
6405     }
6406   else
6407     head->remaining = head->list;
6408 }
6409
6410 /* This is called when we know the name and dependencies of the
6411    version.  */
6412
6413 void
6414 lang_register_vers_node (const char *name,
6415                          struct bfd_elf_version_tree *version,
6416                          struct bfd_elf_version_deps *deps)
6417 {
6418   struct bfd_elf_version_tree *t, **pp;
6419   struct bfd_elf_version_expr *e1;
6420
6421   if (name == NULL)
6422     name = "";
6423
6424   if ((name[0] == '\0' && lang_elf_version_info != NULL)
6425       || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
6426     {
6427       einfo (_("%X%P: anonymous version tag cannot be combined"
6428                " with other version tags\n"));
6429       free (version);
6430       return;
6431     }
6432
6433   /* Make sure this node has a unique name.  */
6434   for (t = lang_elf_version_info; t != NULL; t = t->next)
6435     if (strcmp (t->name, name) == 0)
6436       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
6437
6438   lang_finalize_version_expr_head (&version->globals);
6439   lang_finalize_version_expr_head (&version->locals);
6440
6441   /* Check the global and local match names, and make sure there
6442      aren't any duplicates.  */
6443
6444   for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
6445     {
6446       for (t = lang_elf_version_info; t != NULL; t = t->next)
6447         {
6448           struct bfd_elf_version_expr *e2;
6449
6450           if (t->locals.htab && e1->symbol)
6451             {
6452               e2 = htab_find (t->locals.htab, e1);
6453               while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
6454                 {
6455                   if (e1->mask == e2->mask)
6456                     einfo (_("%X%P: duplicate expression `%s'"
6457                              " in version information\n"), e1->symbol);
6458                   e2 = e2->next;
6459                 }
6460             }
6461           else if (!e1->symbol)
6462             for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
6463               if (strcmp (e1->pattern, e2->pattern) == 0
6464                   && e1->mask == e2->mask)
6465                 einfo (_("%X%P: duplicate expression `%s'"
6466                          " in version information\n"), e1->pattern);
6467         }
6468     }
6469
6470   for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
6471     {
6472       for (t = lang_elf_version_info; t != NULL; t = t->next)
6473         {
6474           struct bfd_elf_version_expr *e2;
6475
6476           if (t->globals.htab && e1->symbol)
6477             {
6478               e2 = htab_find (t->globals.htab, e1);
6479               while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
6480                 {
6481                   if (e1->mask == e2->mask)
6482                     einfo (_("%X%P: duplicate expression `%s'"
6483                              " in version information\n"),
6484                            e1->symbol);
6485                   e2 = e2->next;
6486                 }
6487             }
6488           else if (!e1->symbol)
6489             for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
6490               if (strcmp (e1->pattern, e2->pattern) == 0
6491                   && e1->mask == e2->mask)
6492                 einfo (_("%X%P: duplicate expression `%s'"
6493                          " in version information\n"), e1->pattern);
6494         }
6495     }
6496
6497   version->deps = deps;
6498   version->name = name;
6499   if (name[0] != '\0')
6500     {
6501       ++version_index;
6502       version->vernum = version_index;
6503     }
6504   else
6505     version->vernum = 0;
6506
6507   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
6508     ;
6509   *pp = version;
6510 }
6511
6512 /* This is called when we see a version dependency.  */
6513
6514 struct bfd_elf_version_deps *
6515 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
6516 {
6517   struct bfd_elf_version_deps *ret;
6518   struct bfd_elf_version_tree *t;
6519
6520   ret = xmalloc (sizeof *ret);
6521   ret->next = list;
6522
6523   for (t = lang_elf_version_info; t != NULL; t = t->next)
6524     {
6525       if (strcmp (t->name, name) == 0)
6526         {
6527           ret->version_needed = t;
6528           return ret;
6529         }
6530     }
6531
6532   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
6533
6534   return ret;
6535 }
6536
6537 static void
6538 lang_do_version_exports_section (void)
6539 {
6540   struct bfd_elf_version_expr *greg = NULL, *lreg;
6541
6542   LANG_FOR_EACH_INPUT_STATEMENT (is)
6543     {
6544       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
6545       char *contents, *p;
6546       bfd_size_type len;
6547
6548       if (sec == NULL)
6549         continue;
6550
6551       len = sec->size;
6552       contents = xmalloc (len);
6553       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
6554         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
6555
6556       p = contents;
6557       while (p < contents + len)
6558         {
6559           greg = lang_new_vers_pattern (greg, p, NULL);
6560           p = strchr (p, '\0') + 1;
6561         }
6562
6563       /* Do not free the contents, as we used them creating the regex.  */
6564
6565       /* Do not include this section in the link.  */
6566       sec->flags |= SEC_EXCLUDE;
6567     }
6568
6569   lreg = lang_new_vers_pattern (NULL, "*", NULL);
6570   lang_register_vers_node (command_line.version_exports_section,
6571                            lang_new_vers_node (greg, lreg), NULL);
6572 }
6573
6574 void
6575 lang_add_unique (const char *name)
6576 {
6577   struct unique_sections *ent;
6578
6579   for (ent = unique_section_list; ent; ent = ent->next)
6580     if (strcmp (ent->name, name) == 0)
6581       return;
6582
6583   ent = xmalloc (sizeof *ent);
6584   ent->name = xstrdup (name);
6585   ent->next = unique_section_list;
6586   unique_section_list = ent;
6587 }