ld/ldlang.c

   1 /* Linker command language support.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001
   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, 59 Temple Place - Suite 330, Boston, MA
  21 02111-1307, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libiberty.h"
  26 #include "obstack.h"
  27 #include "bfdlink.h"
  28
  29 #include "ld.h"
  30 #include "ldmain.h"
  31 #include "ldgram.h"
  32 #include "ldexp.h"
  33 #include "ldlang.h"
  34 #include "ldlex.h"
  35 #include "ldmisc.h"
  36 #include "ldctor.h"
  37 #include "ldfile.h"
  38 #include "ldemul.h"
  39 #include "fnmatch.h"
  40 #include "demangle.h"
  41
  42 #include <ctype.h>
  43
  44 /* FORWARDS */
  45 static lang_statement_union_type *new_statement PARAMS ((enum statement_enum,
  46                                                          size_t,
  47                                                          lang_statement_list_type *));
  48
  49 /* LOCALS */
  50 static struct obstack stat_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 boolean placed_commons = false;
  57 static lang_output_section_statement_type *default_common_section;
  58 static boolean map_option_f;
  59 static bfd_vma print_dot;
  60 static lang_input_statement_type *first_file;
  61 static const char *current_target;
  62 static const char *output_target;
  63 static lang_statement_list_type statement_list;
  64 static struct lang_phdr *lang_phdr_list;
  65
  66 static void lang_for_each_statement_worker
  67   PARAMS ((void (*) (lang_statement_union_type *),
  68            lang_statement_union_type *));
  69 static lang_input_statement_type *new_afile
  70   PARAMS ((const char *, lang_input_file_enum_type, const char *, boolean));
  71 static lang_memory_region_type *lang_memory_default PARAMS ((asection *));
  72 static void lang_map_flags PARAMS ((flagword));
  73 static void init_os PARAMS ((lang_output_section_statement_type *));
  74 static void exp_init_os PARAMS ((etree_type *));
  75 static void section_already_linked PARAMS ((bfd *, asection *, PTR));
  76 static struct bfd_hash_entry *already_linked_newfunc
  77   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  78 static void already_linked_table_init PARAMS ((void));
  79 static void already_linked_table_free PARAMS ((void));
  80 static boolean wildcardp PARAMS ((const char *));
  81 static lang_statement_union_type *wild_sort
  82   PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
  83            asection *));
  84 static void output_section_callback
  85   PARAMS ((lang_wild_statement_type *, asection *,
  86            lang_input_statement_type *, PTR));
  87 static lang_input_statement_type *lookup_name PARAMS ((const char *));
  88 static void load_symbols
  89   PARAMS ((lang_input_statement_type *, lang_statement_list_type *));
  90 static void wild
  91   PARAMS ((lang_wild_statement_type *, const char *, const char *,
  92            const char *, lang_output_section_statement_type *));
  93 static bfd *open_output PARAMS ((const char *));
  94 static void ldlang_open_output PARAMS ((lang_statement_union_type *));
  95 static void open_input_bfds PARAMS ((lang_statement_union_type *, boolean));
  96 static void lang_reasonable_defaults PARAMS ((void));
  97 static void lang_place_undefineds PARAMS ((void));
  98 static void map_input_to_output_sections
  99   PARAMS ((lang_statement_union_type *, const char *,
 100            lang_output_section_statement_type *));
 101 static void print_output_section_statement
 102   PARAMS ((lang_output_section_statement_type *));
 103 static void print_assignment
 104   PARAMS ((lang_assignment_statement_type *,
 105            lang_output_section_statement_type *));
 106 static void print_input_statement PARAMS ((lang_input_statement_type *));
 107 static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
 108 static void print_input_section PARAMS ((lang_input_section_type *));
 109 static void print_fill_statement PARAMS ((lang_fill_statement_type *));
 110 static void print_data_statement PARAMS ((lang_data_statement_type *));
 111 static void print_address_statement PARAMS ((lang_address_statement_type *));
 112 static void print_reloc_statement PARAMS ((lang_reloc_statement_type *));
 113 static void print_padding_statement PARAMS ((lang_padding_statement_type *));
 114 static void print_wild_statement
 115   PARAMS ((lang_wild_statement_type *, lang_output_section_statement_type *));
 116 static void print_group
 117   PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *));
 118 static void print_statement
 119   PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
 120 static void print_statement_list
 121   PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
 122 static void print_statements PARAMS ((void));
 123 static bfd_vma insert_pad
 124   PARAMS ((lang_statement_union_type **, fill_type,
 125            unsigned int, asection *, bfd_vma));
 126 static bfd_vma size_input_section
 127   PARAMS ((lang_statement_union_type **, lang_output_section_statement_type *,
 128            fill_type, bfd_vma, boolean));
 129 static void lang_finish PARAMS ((void));
 130 static void ignore_bfd_errors PARAMS ((const char *, ...));
 131 static void record_bfd_errors PARAMS ((const char *, ...));
 132 static void lang_check PARAMS ((void));
 133 static void lang_common PARAMS ((void));
 134 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
 135 static void lang_place_orphans PARAMS ((void));
 136 static int topower PARAMS ((int));
 137 static void lang_set_startof PARAMS ((void));
 138 static void reset_memory_regions PARAMS ((void));
 139 static void gc_section_callback
 140   PARAMS ((lang_wild_statement_type *, asection *,
 141            lang_input_statement_type *, PTR));
 142 static void lang_record_phdrs PARAMS ((void));
 143 static void lang_gc_wild
 144   PARAMS ((lang_wild_statement_type *, const char *, const char *));
 145 static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
 146 static void lang_gc_sections PARAMS ((void));
 147 static int lang_vers_match_lang_c
 148   PARAMS ((struct bfd_elf_version_expr *, const char *));
 149 static int lang_vers_match_lang_cplusplus
 150   PARAMS ((struct bfd_elf_version_expr *, const char *));
 151 static int lang_vers_match_lang_java
 152   PARAMS ((struct bfd_elf_version_expr *, const char *));
 153 static void lang_do_version_exports_section PARAMS ((void));
 154 static void lang_check_section_addresses PARAMS ((void));
 155 static void os_region_check
 156   PARAMS ((lang_output_section_statement_type *,
 157            struct memory_region_struct *, etree_type *, bfd_vma));
 158
 159 typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
 160                                     asection *, lang_input_statement_type *,
 161                                     PTR));
 162 static void walk_wild
 163   PARAMS ((lang_wild_statement_type *, const char *, const char *,
 164          callback_t, PTR));
 165 static void walk_wild_section
 166   PARAMS ((lang_wild_statement_type *, const char *,
 167            lang_input_statement_type *, callback_t, PTR));
 168 static void walk_wild_file
 169   PARAMS ((lang_wild_statement_type *, const char *,
 170            lang_input_statement_type *, callback_t, PTR));
 171
 172 static int    get_target PARAMS ((const bfd_target *, PTR));
 173 static void   stricpy PARAMS ((char *, char *));
 174 static void   strcut PARAMS ((char *, char *));
 175 static int    name_compare PARAMS ((char *, char *));
 176 static int    closest_target_match PARAMS ((const bfd_target *, PTR));
 177 static char * get_first_input_target PARAMS ((void));
 178
 179 /* EXPORTS */
 180 lang_output_section_statement_type *abs_output_section;
 181 lang_statement_list_type lang_output_section_statement;
 182 lang_statement_list_type *stat_ptr = &statement_list;
 183 lang_statement_list_type file_chain = { NULL, NULL };
 184 const char *entry_symbol = NULL;
 185 boolean entry_from_cmdline;
 186 boolean lang_has_input_file = false;
 187 boolean had_output_filename = false;
 188 boolean lang_float_flag = false;
 189 boolean delete_output_file_on_failure = false;
 190 struct lang_nocrossrefs *nocrossref_list;
 191 struct unique_sections *unique_section_list;
 192
 193 etree_type *base; /* Relocation base - or null */
 194
 195 #if defined(__STDC__) || defined(ALMOST_STDC)
 196 #define cat(a,b) a##b
 197 #else
 198 #define cat(a,b) a/**/b
 199 #endif
 200
 201 /* Don't beautify the line below with "innocent" whitespace, it breaks the K&R C preprocessor!  */
 202 #define new_stat(x, y) (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
 203
 204 #define outside_section_address(q) ((q)->output_offset + (q)->output_section->vma)
 205
 206 #define outside_symbol_address(q) ((q)->value + outside_section_address (q->section))
 207
 208 #define SECTION_NAME_MAP_LENGTH (16)
 209
 210 PTR
 211 stat_alloc (size)
 212      size_t size;
 213 {
 214   return obstack_alloc (&stat_obstack, size);
 215 }
 216
 217 boolean
 218 unique_section_p (secnam)
 219      const char *secnam;
 220 {
 221   struct unique_sections *unam;
 222
 223   for (unam = unique_section_list; unam; unam = unam->next)
 224     if (wildcardp (unam->name)
 225         ? fnmatch (unam->name, secnam, 0) == 0
 226         : strcmp (unam->name, secnam) == 0)
 227       {
 228         return true;
 229       }
 230
 231   return false;
 232 }
 233
 234 /* Generic traversal routines for finding matching sections.  */
 235
 236 static void
 237 walk_wild_section (ptr, section, file, callback, data)
 238      lang_wild_statement_type *ptr;
 239      const char *section;
 240      lang_input_statement_type *file;
 241      callback_t callback;
 242      PTR data;
 243 {
 244   /* Don't process sections from files which were excluded.  */
 245   if (ptr->exclude_filename_list != NULL)
 246     {
 247       struct name_list *list_tmp;
 248       for (list_tmp = ptr->exclude_filename_list; list_tmp; list_tmp = list_tmp->next)
 249         {
 250           boolean match;
 251
 252           if (wildcardp (list_tmp->name))
 253             match = fnmatch (list_tmp->name, file->filename, 0) == 0 ? true : false;
 254           else
 255             match = strcmp (list_tmp->name, file->filename) == 0 ? true : false;
 256
 257           if (match)
 258             return;
 259         }
 260     }
 261
 262   if (file->just_syms_flag == false)
 263     {
 264       register asection *s;
 265       boolean wildcard = false;
 266
 267       if (section != NULL)
 268         wildcard = wildcardp (section);
 269
 270       for (s = file->the_bfd->sections; s != NULL; s = s->next)
 271         {
 272           boolean match;
 273           const char *sname = bfd_get_section_name (file->the_bfd, s);
 274
 275           if (section == NULL)
 276             match = true;
 277           else if (wildcard)
 278             match = fnmatch (section, sname, 0) == 0 ? true : false;
 279           else
 280             match = strcmp (section, sname) == 0 ? true : false;
 281
 282           /* If this is a wild-card output section statement, exclude
 283              sections that match UNIQUE_SECTION_LIST.  */
 284           if (match && (data == NULL || !unique_section_p (sname)))
 285             (*callback) (ptr, s, file, data);
 286         }
 287     }
 288 }
 289
 290 /* Handle a wild statement for a single file F.  */
 291
 292 static void
 293 walk_wild_file (s, section, f, callback, data)
 294      lang_wild_statement_type *s;
 295      const char *section;
 296      lang_input_statement_type *f;
 297      callback_t callback;
 298      PTR data;
 299 {
 300   if (f->the_bfd == NULL
 301       || ! bfd_check_format (f->the_bfd, bfd_archive))
 302     walk_wild_section (s, section, f, callback, data);
 303   else
 304     {
 305       bfd *member;
 306
 307       /* This is an archive file.  We must map each member of the
 308          archive separately.  */
 309       member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL);
 310       while (member != NULL)
 311         {
 312           /* When lookup_name is called, it will call the add_symbols
 313              entry point for the archive.  For each element of the
 314              archive which is included, BFD will call ldlang_add_file,
 315              which will set the usrdata field of the member to the
 316              lang_input_statement.  */
 317           if (member->usrdata != NULL)
 318             {
 319               walk_wild_section (s, section,
 320                                  (lang_input_statement_type *) member->usrdata,
 321                                  callback, data);
 322             }
 323
 324           member = bfd_openr_next_archived_file (f->the_bfd, member);
 325         }
 326     }
 327 }
 328
 329 static void
 330 walk_wild (s, section, file, callback, data)
 331      lang_wild_statement_type *s;
 332      const char *section;
 333      const char *file;
 334      callback_t callback;
 335      PTR data;
 336 {
 337   if (file == (char *) NULL)
 338     {
 339       /* Perform the iteration over all files in the list.  */
 340       LANG_FOR_EACH_INPUT_STATEMENT (f)
 341         {
 342           walk_wild_file (s, section, f, callback, data);
 343         }
 344     }
 345   else if (wildcardp (file))
 346     {
 347       LANG_FOR_EACH_INPUT_STATEMENT (f)
 348         {
 349           if (fnmatch (file, f->filename, FNM_FILE_NAME) == 0)
 350             walk_wild_file (s, section, f, callback, data);
 351         }
 352     }
 353   else
 354     {
 355       lang_input_statement_type *f;
 356
 357       /* Perform the iteration over a single file.  */
 358       f = lookup_name (file);
 359       walk_wild_file (s, section, f, callback, data);
 360     }
 361 }
 362
 363 /* lang_for_each_statement walks the parse tree and calls the provided
 364    function for each node.  */
 365
 366 static void
 367 lang_for_each_statement_worker (func, s)
 368      void (*func) PARAMS ((lang_statement_union_type *));
 369      lang_statement_union_type *s;
 370 {
 371   for (; s != (lang_statement_union_type *) NULL; s = s->next)
 372     {
 373       func (s);
 374
 375       switch (s->header.type)
 376         {
 377         case lang_constructors_statement_enum:
 378           lang_for_each_statement_worker (func, constructor_list.head);
 379           break;
 380         case lang_output_section_statement_enum:
 381           lang_for_each_statement_worker
 382             (func,
 383              s->output_section_statement.children.head);
 384           break;
 385         case lang_wild_statement_enum:
 386           lang_for_each_statement_worker
 387             (func,
 388              s->wild_statement.children.head);
 389           break;
 390         case lang_group_statement_enum:
 391           lang_for_each_statement_worker (func,
 392                                           s->group_statement.children.head);
 393           break;
 394         case lang_data_statement_enum:
 395         case lang_reloc_statement_enum:
 396         case lang_object_symbols_statement_enum:
 397         case lang_output_statement_enum:
 398         case lang_target_statement_enum:
 399         case lang_input_section_enum:
 400         case lang_input_statement_enum:
 401         case lang_assignment_statement_enum:
 402         case lang_padding_statement_enum:
 403         case lang_address_statement_enum:
 404         case lang_fill_statement_enum:
 405           break;
 406         default:
 407           FAIL ();
 408           break;
 409         }
 410     }
 411 }
 412
 413 void
 414 lang_for_each_statement (func)
 415      void (*func) PARAMS ((lang_statement_union_type *));
 416 {
 417   lang_for_each_statement_worker (func, statement_list.head);
 418 }
 419
 420 /*----------------------------------------------------------------------*/
 421
 422 void
 423 lang_list_init (list)
 424      lang_statement_list_type *list;
 425 {
 426   list->head = (lang_statement_union_type *) NULL;
 427   list->tail = &list->head;
 428 }
 429
 430 /* Build a new statement node for the parse tree.  */
 431
 432 static lang_statement_union_type *
 433 new_statement (type, size, list)
 434      enum statement_enum type;
 435      size_t size;
 436      lang_statement_list_type *list;
 437 {
 438   lang_statement_union_type *new = (lang_statement_union_type *)
 439   stat_alloc (size);
 440
 441   new->header.type = type;
 442   new->header.next = (lang_statement_union_type *) NULL;
 443   lang_statement_append (list, new, &new->header.next);
 444   return new;
 445 }
 446
 447 /* Build a new input file node for the language.  There are several
 448    ways in which we treat an input file, eg, we only look at symbols,
 449    or prefix it with a -l etc.
 450
 451    We can be supplied with requests for input files more than once;
 452    they may, for example be split over serveral lines like foo.o(.text)
 453    foo.o(.data) etc, so when asked for a file we check that we havn't
 454    got it already so we don't duplicate the bfd.  */
 455
 456 static lang_input_statement_type *
 457 new_afile (name, file_type, target, add_to_list)
 458      const char *name;
 459      lang_input_file_enum_type file_type;
 460      const char *target;
 461      boolean add_to_list;
 462 {
 463   lang_input_statement_type *p;
 464
 465   if (add_to_list)
 466     p = new_stat (lang_input_statement, stat_ptr);
 467   else
 468     {
 469       p = ((lang_input_statement_type *)
 470            stat_alloc (sizeof (lang_input_statement_type)));
 471       p->header.next = NULL;
 472     }
 473
 474   lang_has_input_file = true;
 475   p->target = target;
 476   switch (file_type)
 477     {
 478     case lang_input_file_is_symbols_only_enum:
 479       p->filename = name;
 480       p->is_archive = false;
 481       p->real = true;
 482       p->local_sym_name = name;
 483       p->just_syms_flag = true;
 484       p->search_dirs_flag = false;
 485       break;
 486     case lang_input_file_is_fake_enum:
 487       p->filename = name;
 488       p->is_archive = false;
 489       p->real = false;
 490       p->local_sym_name = name;
 491       p->just_syms_flag = false;
 492       p->search_dirs_flag = false;
 493       break;
 494     case lang_input_file_is_l_enum:
 495       p->is_archive = true;
 496       p->filename = name;
 497       p->real = true;
 498       p->local_sym_name = concat ("-l", name, (const char *) NULL);
 499       p->just_syms_flag = false;
 500       p->search_dirs_flag = true;
 501       break;
 502     case lang_input_file_is_marker_enum:
 503       p->filename = name;
 504       p->is_archive = false;
 505       p->real = false;
 506       p->local_sym_name = name;
 507       p->just_syms_flag = false;
 508       p->search_dirs_flag = true;
 509       break;
 510     case lang_input_file_is_search_file_enum:
 511       p->filename = name;
 512       p->is_archive = false;
 513       p->real = true;
 514       p->local_sym_name = name;
 515       p->just_syms_flag = false;
 516       p->search_dirs_flag = true;
 517       break;
 518     case lang_input_file_is_file_enum:
 519       p->filename = name;
 520       p->is_archive = false;
 521       p->real = true;
 522       p->local_sym_name = name;
 523       p->just_syms_flag = false;
 524       p->search_dirs_flag = false;
 525       break;
 526     default:
 527       FAIL ();
 528     }
 529   p->the_bfd = (bfd *) NULL;
 530   p->asymbols = (asymbol **) NULL;
 531   p->next_real_file = (lang_statement_union_type *) NULL;
 532   p->next = (lang_statement_union_type *) NULL;
 533   p->symbol_count = 0;
 534   p->dynamic = config.dynamic_link;
 535   p->whole_archive = whole_archive;
 536   p->loaded = false;
 537   lang_statement_append (&input_file_chain,
 538                          (lang_statement_union_type *) p,
 539                          &p->next_real_file);
 540   return p;
 541 }
 542
 543 lang_input_statement_type *
 544 lang_add_input_file (name, file_type, target)
 545      const char *name;
 546      lang_input_file_enum_type file_type;
 547      const char *target;
 548 {
 549   lang_has_input_file = true;
 550   return new_afile (name, file_type, target, true);
 551 }
 552
 553 /* Build enough state so that the parser can build its tree.  */
 554
 555 void
 556 lang_init ()
 557 {
 558   obstack_begin (&stat_obstack, 1000);
 559
 560   stat_ptr = &statement_list;
 561
 562   lang_list_init (stat_ptr);
 563
 564   lang_list_init (&input_file_chain);
 565   lang_list_init (&lang_output_section_statement);
 566   lang_list_init (&file_chain);
 567   first_file = lang_add_input_file ((char *) NULL,
 568                                     lang_input_file_is_marker_enum,
 569                                     (char *) NULL);
 570   abs_output_section =
 571     lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
 572
 573   abs_output_section->bfd_section = bfd_abs_section_ptr;
 574
 575 }
 576
 577 /*----------------------------------------------------------------------
 578   A region is an area of memory declared with the
 579   MEMORY {  name:org=exp, len=exp ... }
 580   syntax.
 581
 582   We maintain a list of all the regions here.
 583
 584   If no regions are specified in the script, then the default is used
 585   which is created when looked up to be the entire data space.  */
 586
 587 static lang_memory_region_type *lang_memory_region_list;
 588 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
 589
 590 lang_memory_region_type *
 591 lang_memory_region_lookup (name)
 592      const char *const name;
 593 {
 594   lang_memory_region_type *p;
 595
 596   for (p = lang_memory_region_list;
 597        p != (lang_memory_region_type *) NULL;
 598        p = p->next)
 599     {
 600       if (strcmp (p->name, name) == 0)
 601         {
 602           return p;
 603         }
 604     }
 605
 606 #if 0
 607   /* This code used to always use the first region in the list as the
 608      default region.  I changed it to instead use a region
 609      encompassing all of memory as the default region.  This permits
 610      NOLOAD sections to work reasonably without requiring a region.
 611      People should specify what region they mean, if they really want
 612      a region.  */
 613   if (strcmp (name, "*default*") == 0)
 614     {
 615       if (lang_memory_region_list != (lang_memory_region_type *) NULL)
 616         {
 617           return lang_memory_region_list;
 618         }
 619     }
 620 #endif
 621
 622   {
 623     lang_memory_region_type *new =
 624     (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type));
 625
 626     new->name = xstrdup (name);
 627     new->next = (lang_memory_region_type *) NULL;
 628
 629     *lang_memory_region_list_tail = new;
 630     lang_memory_region_list_tail = &new->next;
 631     new->origin = 0;
 632     new->flags = 0;
 633     new->not_flags = 0;
 634     new->length = ~(bfd_size_type) 0;
 635     new->current = 0;
 636     new->had_full_message = false;
 637
 638     return new;
 639   }
 640 }
 641
 642 static lang_memory_region_type *
 643 lang_memory_default (section)
 644      asection *section;
 645 {
 646   lang_memory_region_type *p;
 647
 648   flagword sec_flags = section->flags;
 649
 650   /* Override SEC_DATA to mean a writable section.  */
 651   if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
 652     sec_flags |= SEC_DATA;
 653
 654   for (p = lang_memory_region_list;
 655        p != (lang_memory_region_type *) NULL;
 656        p = p->next)
 657     {
 658       if ((p->flags & sec_flags) != 0
 659           && (p->not_flags & sec_flags) == 0)
 660         {
 661           return p;
 662         }
 663     }
 664   return lang_memory_region_lookup ("*default*");
 665 }
 666
 667 lang_output_section_statement_type *
 668 lang_output_section_find (name)
 669      const char *const name;
 670 {
 671   lang_statement_union_type *u;
 672   lang_output_section_statement_type *lookup;
 673
 674   for (u = lang_output_section_statement.head;
 675        u != (lang_statement_union_type *) NULL;
 676        u = lookup->next)
 677     {
 678       lookup = &u->output_section_statement;
 679       if (strcmp (name, lookup->name) == 0)
 680         {
 681           return lookup;
 682         }
 683     }
 684   return (lang_output_section_statement_type *) NULL;
 685 }
 686
 687 lang_output_section_statement_type *
 688 lang_output_section_statement_lookup (name)
 689      const char *const name;
 690 {
 691   lang_output_section_statement_type *lookup;
 692
 693   lookup = lang_output_section_find (name);
 694   if (lookup == (lang_output_section_statement_type *) NULL)
 695     {
 696
 697       lookup = (lang_output_section_statement_type *)
 698         new_stat (lang_output_section_statement, stat_ptr);
 699       lookup->region = (lang_memory_region_type *) NULL;
 700       lookup->lma_region = (lang_memory_region_type *) NULL;
 701       lookup->fill = 0;
 702       lookup->block_value = 1;
 703       lookup->name = name;
 704
 705       lookup->next = (lang_statement_union_type *) NULL;
 706       lookup->bfd_section = (asection *) NULL;
 707       lookup->processed = false;
 708       lookup->sectype = normal_section;
 709       lookup->addr_tree = (etree_type *) NULL;
 710       lang_list_init (&lookup->children);
 711
 712       lookup->memspec = (const char *) NULL;
 713       lookup->flags = 0;
 714       lookup->subsection_alignment = -1;
 715       lookup->section_alignment = -1;
 716       lookup->load_base = (union etree_union *) NULL;
 717       lookup->phdrs = NULL;
 718
 719       lang_statement_append (&lang_output_section_statement,
 720                              (lang_statement_union_type *) lookup,
 721                              &lookup->next);
 722     }
 723   return lookup;
 724 }
 725
 726 static void
 727 lang_map_flags (flag)
 728      flagword flag;
 729 {
 730   if (flag & SEC_ALLOC)
 731     minfo ("a");
 732
 733   if (flag & SEC_CODE)
 734     minfo ("x");
 735
 736   if (flag & SEC_READONLY)
 737     minfo ("r");
 738
 739   if (flag & SEC_DATA)
 740     minfo ("w");
 741
 742   if (flag & SEC_LOAD)
 743     minfo ("l");
 744 }
 745
 746 void
 747 lang_map ()
 748 {
 749   lang_memory_region_type *m;
 750
 751   minfo (_("\nMemory Configuration\n\n"));
 752   fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
 753            _("Name"), _("Origin"), _("Length"), _("Attributes"));
 754
 755   for (m = lang_memory_region_list;
 756        m != (lang_memory_region_type *) NULL;
 757        m = m->next)
 758     {
 759       char buf[100];
 760       int len;
 761
 762       fprintf (config.map_file, "%-16s ", m->name);
 763
 764       sprintf_vma (buf, m->origin);
 765       minfo ("0x%s ", buf);
 766       len = strlen (buf);
 767       while (len < 16)
 768         {
 769           print_space ();
 770           ++len;
 771         }
 772
 773       minfo ("0x%V", m->length);
 774       if (m->flags || m->not_flags)
 775         {
 776 #ifndef BFD64
 777           minfo ("        ");
 778 #endif
 779           if (m->flags)
 780             {
 781               print_space ();
 782               lang_map_flags (m->flags);
 783             }
 784
 785           if (m->not_flags)
 786             {
 787               minfo (" !");
 788               lang_map_flags (m->not_flags);
 789             }
 790         }
 791
 792       print_nl ();
 793     }
 794
 795   fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
 796
 797   print_statements ();
 798 }
 799
 800 /* Initialize an output section.  */
 801
 802 static void
 803 init_os (s)
 804      lang_output_section_statement_type *s;
 805 {
 806   section_userdata_type *new;
 807
 808   if (s->bfd_section != NULL)
 809     return;
 810
 811   if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
 812     einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME);
 813
 814   new = ((section_userdata_type *)
 815          stat_alloc (sizeof (section_userdata_type)));
 816
 817   s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
 818   if (s->bfd_section == (asection *) NULL)
 819     s->bfd_section = bfd_make_section (output_bfd, s->name);
 820   if (s->bfd_section == (asection *) NULL)
 821     {
 822       einfo (_("%P%F: output format %s cannot represent section called %s\n"),
 823              output_bfd->xvec->name, s->name);
 824     }
 825   s->bfd_section->output_section = s->bfd_section;
 826
 827   /* We initialize an output sections output offset to minus its own
 828      vma to allow us to output a section through itself.  */
 829   s->bfd_section->output_offset = 0;
 830   get_userdata (s->bfd_section) = (PTR) new;
 831
 832   /* If there is a base address, make sure that any sections it might
 833      mention are initialized.  */
 834   if (s->addr_tree != NULL)
 835     exp_init_os (s->addr_tree);
 836 }
 837
 838 /* Make sure that all output sections mentioned in an expression are
 839    initialized.  */
 840
 841 static void
 842 exp_init_os (exp)
 843      etree_type *exp;
 844 {
 845   switch (exp->type.node_class)
 846     {
 847     case etree_assign:
 848       exp_init_os (exp->assign.src);
 849       break;
 850
 851     case etree_binary:
 852       exp_init_os (exp->binary.lhs);
 853       exp_init_os (exp->binary.rhs);
 854       break;
 855
 856     case etree_trinary:
 857       exp_init_os (exp->trinary.cond);
 858       exp_init_os (exp->trinary.lhs);
 859       exp_init_os (exp->trinary.rhs);
 860       break;
 861
 862     case etree_unary:
 863       exp_init_os (exp->unary.child);
 864       break;
 865
 866     case etree_name:
 867       switch (exp->type.node_code)
 868         {
 869         case ADDR:
 870         case LOADADDR:
 871         case SIZEOF:
 872           {
 873             lang_output_section_statement_type *os;
 874
 875             os = lang_output_section_find (exp->name.name);
 876             if (os != NULL && os->bfd_section == NULL)
 877               init_os (os);
 878           }
 879         }
 880       break;
 881
 882     default:
 883       break;
 884     }
 885 }
 886 \f
 887 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
 888    once into the output.  This routine checks each section, and
 889    arrange to discard it if a section of the same name has already
 890    been linked.  If the section has COMDAT information, then it uses
 891    that to decide whether the section should be included.  This code
 892    assumes that all relevant sections have the SEC_LINK_ONCE flag set;
 893    that is, it does not depend solely upon the section name.
 894    section_already_linked is called via bfd_map_over_sections.  */
 895
 896 /* This is the shape of the elements inside the already_linked hash
 897    table. It maps a name onto a list of already_linked elements with
 898    the same name.  It's possible to get more than one element in a
 899    list if the COMDAT sections have different names.  */
 900
 901 struct already_linked_hash_entry
 902 {
 903   struct bfd_hash_entry root;
 904   struct already_linked *entry;
 905 };
 906
 907 struct already_linked
 908 {
 909   struct already_linked *next;
 910   asection *sec;
 911 };
 912
 913 /* The hash table.  */
 914
 915 static struct bfd_hash_table already_linked_table;
 916
 917 static void
 918 section_already_linked (abfd, sec, data)
 919      bfd *abfd;
 920      asection *sec;
 921      PTR data;
 922 {
 923   lang_input_statement_type *entry = (lang_input_statement_type *) data;
 924   flagword flags;
 925   const char *name;
 926   struct already_linked *l;
 927   struct already_linked_hash_entry *already_linked_list;
 928
 929   /* If we are only reading symbols from this object, then we want to
 930      discard all sections.  */
 931   if (entry->just_syms_flag)
 932     {
 933       sec->output_section = bfd_abs_section_ptr;
 934       sec->output_offset = sec->vma;
 935       return;
 936     }
 937
 938   flags = bfd_get_section_flags (abfd, sec);
 939
 940   if ((flags & SEC_LINK_ONCE) == 0)
 941     return;
 942
 943   /* FIXME: When doing a relocatable link, we may have trouble
 944      copying relocations in other sections that refer to local symbols
 945      in the section being discarded.  Those relocations will have to
 946      be converted somehow; as of this writing I'm not sure that any of
 947      the backends handle that correctly.
 948
 949      It is tempting to instead not discard link once sections when
 950      doing a relocatable link (technically, they should be discarded
 951      whenever we are building constructors).  However, that fails,
 952      because the linker winds up combining all the link once sections
 953      into a single large link once section, which defeats the purpose
 954      of having link once sections in the first place.
 955
 956      Also, not merging link once sections in a relocatable link
 957      causes trouble for MIPS ELF, which relies in link once semantics
 958      to handle the .reginfo section correctly.  */
 959
 960   name = bfd_get_section_name (abfd, sec);
 961
 962   already_linked_list =
 963     ((struct already_linked_hash_entry *)
 964      bfd_hash_lookup (&already_linked_table, name, true, false));
 965
 966   for (l = already_linked_list->entry; l != NULL; l = l->next)
 967     {
 968       if (sec->comdat == NULL
 969           || l->sec->comdat == NULL
 970           || strcmp (sec->comdat->name, l->sec->comdat->name) == 0)
 971         {
 972           /* The section has already been linked.  See if we should
 973              issue a warning.  */
 974           switch (flags & SEC_LINK_DUPLICATES)
 975             {
 976             default:
 977               abort ();
 978
 979             case SEC_LINK_DUPLICATES_DISCARD:
 980               break;
 981
 982             case SEC_LINK_DUPLICATES_ONE_ONLY:
 983               if (sec->comdat == NULL)
 984                 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
 985                        abfd, name);
 986               else
 987                 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
 988                        abfd, name, sec->comdat->name);
 989               break;
 990
 991             case SEC_LINK_DUPLICATES_SAME_CONTENTS:
 992               /* FIXME: We should really dig out the contents of both
 993                  sections and memcmp them.  The COFF/PE spec says that
 994                  the Microsoft linker does not implement this
 995                  correctly, so I'm not going to bother doing it
 996                  either.  */
 997               /* Fall through.  */
 998             case SEC_LINK_DUPLICATES_SAME_SIZE:
 999               if (bfd_section_size (abfd, sec)
1000                   != bfd_section_size (l->sec->owner, l->sec))
1001                 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1002                        abfd, name);
1003               break;
1004             }
1005
1006           /* Set the output_section field so that wild_doit does not
1007              create a lang_input_section structure for this section.
1008              Since there might be a symbol in the section being
1009              discarded, we must retain a pointer to the section which
1010              we are really going to use.  */
1011           sec->output_section = bfd_abs_section_ptr;
1012           sec->kept_section = l->sec;
1013
1014           return;
1015         }
1016     }
1017
1018   /* This is the first section with this name.  Record it.  Allocate
1019      the memory from the same obstack as the hash table is kept in.  */
1020
1021   l = ((struct already_linked *)
1022        bfd_hash_allocate (&already_linked_table, sizeof *l));
1023
1024   l->sec = sec;
1025   l->next = already_linked_list->entry;
1026   already_linked_list->entry = l;
1027 }
1028
1029 /* Support routines for the hash table used by section_already_linked,
1030    initialize the table, fill in an entry and remove the table.  */
1031
1032 static struct bfd_hash_entry *
1033 already_linked_newfunc (entry, table, string)
1034      struct bfd_hash_entry *entry ATTRIBUTE_UNUSED;
1035      struct bfd_hash_table *table;
1036      const char *string ATTRIBUTE_UNUSED;
1037 {
1038   struct already_linked_hash_entry *ret =
1039     bfd_hash_allocate (table, sizeof (struct already_linked_hash_entry));
1040
1041   ret->entry = NULL;
1042
1043   return (struct bfd_hash_entry *) ret;
1044 }
1045
1046 static void
1047 already_linked_table_init ()
1048 {
1049   if (! bfd_hash_table_init_n (&already_linked_table,
1050                                already_linked_newfunc,
1051                                42))
1052     einfo (_("%P%F: Failed to create hash table\n"));
1053 }
1054
1055 static void
1056 already_linked_table_free ()
1057 {
1058   bfd_hash_table_free (&already_linked_table);
1059 }
1060 \f
1061 /* The wild routines.
1062
1063    These expand statements like *(.text) and foo.o to a list of
1064    explicit actions, like foo.o(.text), bar.o(.text) and
1065    foo.o(.text, .data).  */
1066
1067 /* Return true if the PATTERN argument is a wildcard pattern.
1068    Although backslashes are treated specially if a pattern contains
1069    wildcards, we do not consider the mere presence of a backslash to
1070    be enough to cause the the pattern to be treated as a wildcard.
1071    That lets us handle DOS filenames more naturally.  */
1072
1073 static boolean
1074 wildcardp (pattern)
1075      const char *pattern;
1076 {
1077   const char *s;
1078
1079   for (s = pattern; *s != '\0'; ++s)
1080     if (*s == '?'
1081         || *s == '*'
1082         || *s == '[')
1083       return true;
1084   return false;
1085 }
1086
1087 /* Add SECTION to the output section OUTPUT.  Do this by creating a
1088    lang_input_section statement which is placed at PTR.  FILE is the
1089    input file which holds SECTION.  */
1090
1091 void
1092 wild_doit (ptr, section, output, file)
1093      lang_statement_list_type *ptr;
1094      asection *section;
1095      lang_output_section_statement_type *output;
1096      lang_input_statement_type *file;
1097 {
1098   flagword flags;
1099   boolean discard;
1100
1101   flags = bfd_get_section_flags (section->owner, section);
1102
1103   discard = false;
1104
1105   /* If we are doing a final link, discard sections marked with
1106      SEC_EXCLUDE.  */
1107   if (! link_info.relocateable
1108       && (flags & SEC_EXCLUDE) != 0)
1109     discard = true;
1110
1111   /* Discard input sections which are assigned to a section named
1112      DISCARD_SECTION_NAME.  */
1113   if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1114     discard = true;
1115
1116   /* Discard debugging sections if we are stripping debugging
1117      information.  */
1118   if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1119       && (flags & SEC_DEBUGGING) != 0)
1120     discard = true;
1121
1122   if (discard)
1123     {
1124       if (section->output_section == NULL)
1125         {
1126           /* This prevents future calls from assigning this section.  */
1127           section->output_section = bfd_abs_section_ptr;
1128         }
1129       return;
1130     }
1131
1132   if (section->output_section == NULL)
1133     {
1134       boolean first;
1135       lang_input_section_type *new;
1136       flagword flags;
1137
1138       if (output->bfd_section == NULL)
1139         {
1140           init_os (output);
1141           first = true;
1142         }
1143       else
1144         first = false;
1145
1146       /* Add a section reference to the list.  */
1147       new = new_stat (lang_input_section, ptr);
1148
1149       new->section = section;
1150       new->ifile = file;
1151       section->output_section = output->bfd_section;
1152
1153       flags = section->flags;
1154
1155       /* We don't copy the SEC_NEVER_LOAD flag from an input section
1156          to an output section, because we want to be able to include a
1157          SEC_NEVER_LOAD section in the middle of an otherwise loaded
1158          section (I don't know why we want to do this, but we do).
1159          build_link_order in ldwrite.c handles this case by turning
1160          the embedded SEC_NEVER_LOAD section into a fill.  */
1161
1162       flags &= ~ SEC_NEVER_LOAD;
1163
1164       /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1165          already been processed.  One reason to do this is that on pe
1166          format targets, .text$foo sections go into .text and it's odd
1167          to see .text with SEC_LINK_ONCE set.  */
1168
1169       if (! link_info.relocateable)
1170         flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1171
1172       /* If this is not the first input section, and the SEC_READONLY
1173          flag is not currently set, then don't set it just because the
1174          input section has it set.  */
1175
1176       if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1177         flags &= ~ SEC_READONLY;
1178
1179       /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
1180       if (! first
1181           && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS))
1182               != (flags & (SEC_MERGE | SEC_STRINGS))
1183               || ((flags & SEC_MERGE)
1184                   && section->output_section->entsize != section->entsize)))
1185         {
1186           section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1187           flags &= ~ (SEC_MERGE | SEC_STRINGS);
1188         }
1189
1190       section->output_section->flags |= flags;
1191
1192       if (flags & SEC_MERGE)
1193         section->output_section->entsize = section->entsize;
1194
1195       /* If SEC_READONLY is not set in the input section, then clear
1196          it from the output section.  */
1197       if ((section->flags & SEC_READONLY) == 0)
1198         section->output_section->flags &= ~SEC_READONLY;
1199
1200       switch (output->sectype)
1201         {
1202         case normal_section:
1203           break;
1204         case dsect_section:
1205         case copy_section:
1206         case info_section:
1207         case overlay_section:
1208           output->bfd_section->flags &= ~SEC_ALLOC;
1209           break;
1210         case noload_section:
1211           output->bfd_section->flags &= ~SEC_LOAD;
1212           output->bfd_section->flags |= SEC_NEVER_LOAD;
1213           break;
1214         }
1215
1216       /* Copy over SEC_SMALL_DATA.  */
1217       if (section->flags & SEC_SMALL_DATA)
1218         section->output_section->flags |= SEC_SMALL_DATA;
1219
1220       if (section->alignment_power > output->bfd_section->alignment_power)
1221         output->bfd_section->alignment_power = section->alignment_power;
1222
1223       /* If supplied an aligment, then force it.  */
1224       if (output->section_alignment != -1)
1225         output->bfd_section->alignment_power = output->section_alignment;
1226
1227       if (section->flags & SEC_BLOCK)
1228         {
1229           section->output_section->flags |= SEC_BLOCK;
1230           /* FIXME: This value should really be obtained from the bfd...  */
1231           output->block_value = 128;
1232         }
1233     }
1234 }
1235
1236 /* Handle wildcard sorting.  This returns the lang_input_section which
1237    should follow the one we are going to create for SECTION and FILE,
1238    based on the sorting requirements of WILD.  It returns NULL if the
1239    new section should just go at the end of the current list.  */
1240
1241 static lang_statement_union_type *
1242 wild_sort (wild, file, section)
1243      lang_wild_statement_type *wild;
1244      lang_input_statement_type *file;
1245      asection *section;
1246 {
1247   const char *section_name;
1248   lang_statement_union_type *l;
1249
1250   if (! wild->filenames_sorted && ! wild->sections_sorted)
1251     return NULL;
1252
1253   section_name = bfd_get_section_name (file->the_bfd, section);
1254   for (l = wild->children.head; l != NULL; l = l->next)
1255     {
1256       lang_input_section_type *ls;
1257
1258       if (l->header.type != lang_input_section_enum)
1259         continue;
1260       ls = &l->input_section;
1261
1262       /* Sorting by filename takes precedence over sorting by section
1263          name.  */
1264
1265       if (wild->filenames_sorted)
1266         {
1267           const char *fn, *ln;
1268           boolean fa, la;
1269           int i;
1270
1271           /* The PE support for the .idata section as generated by
1272              dlltool assumes that files will be sorted by the name of
1273              the archive and then the name of the file within the
1274              archive.  */
1275
1276           if (file->the_bfd != NULL
1277               && bfd_my_archive (file->the_bfd) != NULL)
1278             {
1279               fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1280               fa = true;
1281             }
1282           else
1283             {
1284               fn = file->filename;
1285               fa = false;
1286             }
1287
1288           if (ls->ifile->the_bfd != NULL
1289               && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1290             {
1291               ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1292               la = true;
1293             }
1294           else
1295             {
1296               ln = ls->ifile->filename;
1297               la = false;
1298             }
1299
1300           i = strcmp (fn, ln);
1301           if (i > 0)
1302             continue;
1303           else if (i < 0)
1304             break;
1305
1306           if (fa || la)
1307             {
1308               if (fa)
1309                 fn = file->filename;
1310               if (la)
1311                 ln = ls->ifile->filename;
1312
1313               i = strcmp (fn, ln);
1314               if (i > 0)
1315                 continue;
1316               else if (i < 0)
1317                 break;
1318             }
1319         }
1320
1321       /* Here either the files are not sorted by name, or we are
1322          looking at the sections for this file.  */
1323
1324       if (wild->sections_sorted)
1325         {
1326           if (strcmp (section_name,
1327                       bfd_get_section_name (ls->ifile->the_bfd,
1328                                             ls->section))
1329               < 0)
1330             break;
1331         }
1332     }
1333
1334   return l;
1335 }
1336
1337 /* Expand a wild statement for a particular FILE.  SECTION may be
1338    NULL, in which case it is a wild card.  */
1339
1340 static void
1341 output_section_callback (ptr, section, file, output)
1342      lang_wild_statement_type *ptr;
1343      asection *section;
1344      lang_input_statement_type *file;
1345      PTR output;
1346 {
1347   lang_statement_union_type *before;
1348
1349   /* If the wild pattern was marked KEEP, the member sections
1350      should be as well.  */
1351   if (ptr->keep_sections)
1352     section->flags |= SEC_KEEP;
1353
1354   before = wild_sort (ptr, file, section);
1355
1356   /* Here BEFORE points to the lang_input_section which
1357      should follow the one we are about to add.  If BEFORE
1358      is NULL, then the section should just go at the end
1359      of the current list.  */
1360
1361   if (before == NULL)
1362     wild_doit (&ptr->children, section,
1363                (lang_output_section_statement_type *) output,
1364                file);
1365   else
1366     {
1367       lang_statement_list_type list;
1368       lang_statement_union_type **pp;
1369
1370       lang_list_init (&list);
1371       wild_doit (&list, section,
1372                  (lang_output_section_statement_type *) output,
1373                  file);
1374
1375       /* If we are discarding the section, LIST.HEAD will
1376          be NULL.  */
1377       if (list.head != NULL)
1378         {
1379           ASSERT (list.head->next == NULL);
1380
1381           for (pp = &ptr->children.head;
1382                *pp != before;
1383                pp = &(*pp)->next)
1384             ASSERT (*pp != NULL);
1385
1386           list.head->next = *pp;
1387           *pp = list.head;
1388         }
1389     }
1390 }
1391
1392 /* This is passed a file name which must have been seen already and
1393    added to the statement tree.  We will see if it has been opened
1394    already and had its symbols read.  If not then we'll read it.  */
1395
1396 static lang_input_statement_type *
1397 lookup_name (name)
1398      const char *name;
1399 {
1400   lang_input_statement_type *search;
1401
1402   for (search = (lang_input_statement_type *) input_file_chain.head;
1403        search != (lang_input_statement_type *) NULL;
1404        search = (lang_input_statement_type *) search->next_real_file)
1405     {
1406       if (search->filename == (char *) NULL && name == (char *) NULL)
1407         return search;
1408       if (search->filename != (char *) NULL
1409           && name != (char *) NULL
1410           && strcmp (search->filename, name) == 0)
1411         break;
1412     }
1413
1414   if (search == (lang_input_statement_type *) NULL)
1415     search = new_afile (name, lang_input_file_is_file_enum, default_target,
1416                         false);
1417
1418   /* If we have already added this file, or this file is not real
1419      (FIXME: can that ever actually happen?) or the name is NULL
1420      (FIXME: can that ever actually happen?) don't add this file.  */
1421   if (search->loaded
1422       || ! search->real
1423       || search->filename == (const char *) NULL)
1424     return search;
1425
1426   load_symbols (search, (lang_statement_list_type *) NULL);
1427
1428   return search;
1429 }
1430
1431 /* Get the symbols for an input file.  */
1432
1433 static void
1434 load_symbols (entry, place)
1435      lang_input_statement_type *entry;
1436      lang_statement_list_type *place;
1437 {
1438   char **matching;
1439
1440   if (entry->loaded)
1441     return;
1442
1443   ldfile_open_file (entry);
1444
1445   if (! bfd_check_format (entry->the_bfd, bfd_archive)
1446       && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1447     {
1448       bfd_error_type err;
1449       lang_statement_list_type *hold;
1450
1451       err = bfd_get_error ();
1452
1453       /* See if the emulation has some special knowledge.  */
1454       if (ldemul_unrecognized_file (entry))
1455         return;
1456
1457       if (err == bfd_error_file_ambiguously_recognized)
1458         {
1459           char **p;
1460
1461           einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1462           einfo (_("%B: matching formats:"), entry->the_bfd);
1463           for (p = matching; *p != NULL; p++)
1464             einfo (" %s", *p);
1465           einfo ("%F\n");
1466         }
1467       else if (err != bfd_error_file_not_recognized
1468                || place == NULL)
1469         einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1470
1471       bfd_close (entry->the_bfd);
1472       entry->the_bfd = NULL;
1473
1474       /* Try to interpret the file as a linker script.  */
1475       ldfile_open_command_file (entry->filename);
1476
1477       hold = stat_ptr;
1478       stat_ptr = place;
1479
1480       ldfile_assumed_script = true;
1481       parser_input = input_script;
1482       yyparse ();
1483       ldfile_assumed_script = false;
1484
1485       stat_ptr = hold;
1486
1487       return;
1488     }
1489
1490   if (ldemul_recognized_file (entry))
1491     return;
1492
1493   /* We don't call ldlang_add_file for an archive.  Instead, the
1494      add_symbols entry point will call ldlang_add_file, via the
1495      add_archive_element callback, for each element of the archive
1496      which is used.  */
1497   switch (bfd_get_format (entry->the_bfd))
1498     {
1499     default:
1500       break;
1501
1502     case bfd_object:
1503       ldlang_add_file (entry);
1504       if (trace_files || trace_file_tries)
1505         info_msg ("%I\n", entry);
1506       break;
1507
1508     case bfd_archive:
1509       if (entry->whole_archive)
1510         {
1511           bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
1512                                                       (bfd *) NULL);
1513           while (member != NULL)
1514             {
1515               if (! bfd_check_format (member, bfd_object))
1516                 einfo (_("%F%B: object %B in archive is not object\n"),
1517                        entry->the_bfd, member);
1518               if (! ((*link_info.callbacks->add_archive_element)
1519                      (&link_info, member, "--whole-archive")))
1520                 abort ();
1521               if (! bfd_link_add_symbols (member, &link_info))
1522                 einfo (_("%F%B: could not read symbols: %E\n"), member);
1523               member = bfd_openr_next_archived_file (entry->the_bfd,
1524                                                      member);
1525             }
1526
1527           entry->loaded = true;
1528
1529           return;
1530         }
1531     }
1532
1533   if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
1534     einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1535
1536   entry->loaded = true;
1537 }
1538
1539 /* Handle a wild statement.  SECTION or FILE or both may be NULL,
1540    indicating that it is a wildcard.  Separate lang_input_section
1541    statements are created for each part of the expansion; they are
1542    added after the wild statement S.  OUTPUT is the output section.  */
1543
1544 static void
1545 wild (s, section, file, target, output)
1546      lang_wild_statement_type *s;
1547      const char *section;
1548      const char *file;
1549      const char *target ATTRIBUTE_UNUSED;
1550      lang_output_section_statement_type *output;
1551 {
1552   walk_wild (s, section, file, output_section_callback, (PTR) output);
1553
1554   if (section != (char *) NULL
1555       && strcmp (section, "COMMON") == 0
1556       && default_common_section == NULL)
1557     {
1558       /* Remember the section that common is going to in case we later
1559          get something which doesn't know where to put it.  */
1560       default_common_section = output;
1561     }
1562 }
1563
1564 /* Return true iff target is the sought target.  */
1565
1566 static int
1567 get_target (target, data)
1568      const bfd_target *target;
1569      PTR data;
1570 {
1571   const char *sought = (const char *) data;
1572
1573   return strcmp (target->name, sought) == 0;
1574 }
1575
1576 /* Like strcpy() but convert to lower case as well.  */
1577
1578 static void
1579 stricpy (dest, src)
1580      char *dest;
1581      char *src;
1582 {
1583   char c;
1584
1585   while ((c = *src++) != 0)
1586     {
1587       if (isupper ((unsigned char) c))
1588         c = tolower (c);
1589
1590       *dest++ = c;
1591     }
1592
1593   *dest = 0;
1594 }
1595
1596 /* Remove the first occurance of needle (if any) in haystack
1597    from haystack.  */
1598
1599 static void
1600 strcut (haystack, needle)
1601      char *haystack;
1602      char *needle;
1603 {
1604   haystack = strstr (haystack, needle);
1605
1606   if (haystack)
1607     {
1608       char *src;
1609
1610       for (src = haystack + strlen (needle); *src;)
1611         *haystack++ = *src++;
1612
1613       *haystack = 0;
1614     }
1615 }
1616
1617 /* Compare two target format name strings.
1618    Return a value indicating how "similar" they are.  */
1619
1620 static int
1621 name_compare (first, second)
1622      char *first;
1623      char *second;
1624 {
1625   char *copy1;
1626   char *copy2;
1627   int result;
1628
1629   copy1 = xmalloc (strlen (first) + 1);
1630   copy2 = xmalloc (strlen (second) + 1);
1631
1632   /* Convert the names to lower case.  */
1633   stricpy (copy1, first);
1634   stricpy (copy2, second);
1635
1636   /* Remove and endian strings from the name.  */
1637   strcut (copy1, "big");
1638   strcut (copy1, "little");
1639   strcut (copy2, "big");
1640   strcut (copy2, "little");
1641
1642   /* Return a value based on how many characters match,
1643      starting from the beginning.   If both strings are
1644      the same then return 10 * their length.  */
1645   for (result = 0; copy1[result] == copy2[result]; result++)
1646     if (copy1[result] == 0)
1647       {
1648         result *= 10;
1649         break;
1650       }
1651
1652   free (copy1);
1653   free (copy2);
1654
1655   return result;
1656 }
1657
1658 /* Set by closest_target_match() below.  */
1659 static const bfd_target *winner;
1660
1661 /* Scan all the valid bfd targets looking for one that has the endianness
1662    requirement that was specified on the command line, and is the nearest
1663    match to the original output target.  */
1664
1665 static int
1666 closest_target_match (target, data)
1667      const bfd_target *target;
1668      PTR data;
1669 {
1670   const bfd_target *original = (const bfd_target *) data;
1671
1672   if (command_line.endian == ENDIAN_BIG
1673       && target->byteorder != BFD_ENDIAN_BIG)
1674     return 0;
1675
1676   if (command_line.endian == ENDIAN_LITTLE
1677       && target->byteorder != BFD_ENDIAN_LITTLE)
1678     return 0;
1679
1680   /* Must be the same flavour.  */
1681   if (target->flavour != original->flavour)
1682     return 0;
1683
1684   /* If we have not found a potential winner yet, then record this one.  */
1685   if (winner == NULL)
1686     {
1687       winner = target;
1688       return 0;
1689     }
1690
1691   /* Oh dear, we now have two potential candidates for a successful match.
1692      Compare their names and choose the better one.  */
1693   if (name_compare (target->name, original->name) > name_compare (winner->name, original->name))
1694     winner = target;
1695
1696   /* Keep on searching until wqe have checked them all.  */
1697   return 0;
1698 }
1699
1700 /* Return the BFD target format of the first input file.  */
1701
1702 static char *
1703 get_first_input_target ()
1704 {
1705   char *target = NULL;
1706
1707   LANG_FOR_EACH_INPUT_STATEMENT (s)
1708     {
1709       if (s->header.type == lang_input_statement_enum
1710           && s->real)
1711         {
1712           ldfile_open_file (s);
1713
1714           if (s->the_bfd != NULL
1715               && bfd_check_format (s->the_bfd, bfd_object))
1716             {
1717               target = bfd_get_target (s->the_bfd);
1718
1719               if (target != NULL)
1720                 break;
1721             }
1722         }
1723     }
1724
1725   return target;
1726 }
1727
1728 /* Open the output file.  */
1729
1730 static bfd *
1731 open_output (name)
1732      const char *name;
1733 {
1734   bfd *output;
1735
1736   /* Has the user told us which output format to use?  */
1737   if (output_target == (char *) NULL)
1738     {
1739       /* No - has the current target been set to something other than
1740          the default?  */
1741       if (current_target != default_target)
1742         output_target = current_target;
1743
1744       /* No - can we determine the format of the first input file?  */
1745       else
1746         {
1747           output_target = get_first_input_target ();
1748
1749           /* Failed - use the default output target.  */
1750           if (output_target == NULL)
1751             output_target = default_target;
1752         }
1753     }
1754
1755   /* Has the user requested a particular endianness on the command
1756      line?  */
1757   if (command_line.endian != ENDIAN_UNSET)
1758     {
1759       const bfd_target *target;
1760       enum bfd_endian desired_endian;
1761
1762       /* Get the chosen target.  */
1763       target = bfd_search_for_target (get_target, (PTR) output_target);
1764
1765       /* If the target is not supported, we cannot do anything.  */
1766       if (target != NULL)
1767         {
1768           if (command_line.endian == ENDIAN_BIG)
1769             desired_endian = BFD_ENDIAN_BIG;
1770           else
1771             desired_endian = BFD_ENDIAN_LITTLE;
1772
1773           /* See if the target has the wrong endianness.  This should
1774              not happen if the linker script has provided big and
1775              little endian alternatives, but some scrips don't do
1776              this.  */
1777           if (target->byteorder != desired_endian)
1778             {
1779               /* If it does, then see if the target provides
1780                  an alternative with the correct endianness.  */
1781               if (target->alternative_target != NULL
1782                   && (target->alternative_target->byteorder == desired_endian))
1783                 output_target = target->alternative_target->name;
1784               else
1785                 {
1786                   /* Try to find a target as similar as possible to
1787                      the default target, but which has the desired
1788                      endian characteristic.  */
1789                   (void) bfd_search_for_target (closest_target_match, (PTR) target);
1790
1791                   /* Oh dear - we could not find any targets that
1792                      satisfy our requirements.  */
1793                   if (winner == NULL)
1794                     einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1795                   else
1796                     output_target = winner->name;
1797                 }
1798             }
1799         }
1800     }
1801
1802   output = bfd_openw (name, output_target);
1803
1804   if (output == (bfd *) NULL)
1805     {
1806       if (bfd_get_error () == bfd_error_invalid_target)
1807         einfo (_("%P%F: target %s not found\n"), output_target);
1808
1809       einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1810     }
1811
1812   delete_output_file_on_failure = true;
1813
1814 #if 0
1815   output->flags |= D_PAGED;
1816 #endif
1817
1818   if (! bfd_set_format (output, bfd_object))
1819     einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1820   if (! bfd_set_arch_mach (output,
1821                            ldfile_output_architecture,
1822                            ldfile_output_machine))
1823     einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1824
1825   link_info.hash = bfd_link_hash_table_create (output);
1826   if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1827     einfo (_("%P%F: can not create link hash table: %E\n"));
1828
1829   bfd_set_gp_size (output, g_switch_value);
1830   return output;
1831 }
1832
1833 static void
1834 ldlang_open_output (statement)
1835      lang_statement_union_type *statement;
1836 {
1837   switch (statement->header.type)
1838     {
1839     case lang_output_statement_enum:
1840       ASSERT (output_bfd == (bfd *) NULL);
1841       output_bfd = open_output (statement->output_statement.name);
1842       ldemul_set_output_arch ();
1843       if (config.magic_demand_paged && !link_info.relocateable)
1844         output_bfd->flags |= D_PAGED;
1845       else
1846         output_bfd->flags &= ~D_PAGED;
1847       if (config.text_read_only)
1848         output_bfd->flags |= WP_TEXT;
1849       else
1850         output_bfd->flags &= ~WP_TEXT;
1851       if (link_info.traditional_format)
1852         output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1853       else
1854         output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1855       break;
1856
1857     case lang_target_statement_enum:
1858       current_target = statement->target_statement.target;
1859       break;
1860     default:
1861       break;
1862     }
1863 }
1864
1865 /* Open all the input files.  */
1866
1867 static void
1868 open_input_bfds (s, force)
1869      lang_statement_union_type *s;
1870      boolean force;
1871 {
1872   for (; s != (lang_statement_union_type *) NULL; s = s->next)
1873     {
1874       switch (s->header.type)
1875         {
1876         case lang_constructors_statement_enum:
1877           open_input_bfds (constructor_list.head, force);
1878           break;
1879         case lang_output_section_statement_enum:
1880           open_input_bfds (s->output_section_statement.children.head, force);
1881           break;
1882         case lang_wild_statement_enum:
1883           /* Maybe we should load the file's symbols.  */
1884           if (s->wild_statement.filename
1885               && ! wildcardp (s->wild_statement.filename))
1886             (void) lookup_name (s->wild_statement.filename);
1887           open_input_bfds (s->wild_statement.children.head, force);
1888           break;
1889         case lang_group_statement_enum:
1890           {
1891             struct bfd_link_hash_entry *undefs;
1892
1893             /* We must continually search the entries in the group
1894                until no new symbols are added to the list of undefined
1895                symbols.  */
1896
1897             do
1898               {
1899                 undefs = link_info.hash->undefs_tail;
1900                 open_input_bfds (s->group_statement.children.head, true);
1901               }
1902             while (undefs != link_info.hash->undefs_tail);
1903           }
1904           break;
1905         case lang_target_statement_enum:
1906           current_target = s->target_statement.target;
1907           break;
1908         case lang_input_statement_enum:
1909           if (s->input_statement.real)
1910             {
1911               lang_statement_list_type add;
1912               bfd_error_handler_type pfn;
1913
1914               s->input_statement.target = current_target;
1915
1916               /* If we are being called from within a group, and this
1917                  is an archive which has already been searched, then
1918                  force it to be researched unless the whole archive
1919                  has been loaded already.  */
1920               if (force
1921                   && !s->input_statement.whole_archive
1922                   && s->input_statement.loaded
1923                   && bfd_check_format (s->input_statement.the_bfd,
1924                                        bfd_archive))
1925                 s->input_statement.loaded = false;
1926
1927               lang_list_init (& add);
1928
1929               /* We need to know if an error occurs whilst loading the
1930                  symbols, since this means that a valid executable can
1931                  not be produced.  */
1932               pfn = bfd_set_error_handler (record_bfd_errors);
1933
1934               load_symbols (&s->input_statement, &add);
1935
1936               bfd_set_error_handler (pfn);
1937
1938               if (add.head != NULL)
1939                 {
1940                   *add.tail = s->next;
1941                   s->next = add.head;
1942                 }
1943             }
1944           break;
1945         default:
1946           break;
1947         }
1948     }
1949 }
1950
1951 /* If there are [COMMONS] statements, put a wild one into the bss
1952    section.  */
1953
1954 static void
1955 lang_reasonable_defaults ()
1956 {
1957 #if 0
1958   lang_output_section_statement_lookup (".text");
1959   lang_output_section_statement_lookup (".data");
1960
1961   default_common_section = lang_output_section_statement_lookup (".bss");
1962
1963   if (placed_commons == false)
1964     {
1965       lang_wild_statement_type *new =
1966       new_stat (lang_wild_statement,
1967                 &default_common_section->children);
1968
1969       new->section_name = "COMMON";
1970       new->filename = (char *) NULL;
1971       lang_list_init (&new->children);
1972     }
1973 #endif
1974 }
1975
1976 /* Add the supplied name to the symbol table as an undefined reference.
1977    Remove items from the chain as we open input bfds.  */
1978 typedef struct ldlang_undef_chain_list
1979 {
1980   struct ldlang_undef_chain_list *next;
1981   char *name;
1982 }                       ldlang_undef_chain_list_type;
1983
1984 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1985
1986 void
1987 ldlang_add_undef (name)
1988      const char *const name;
1989 {
1990   ldlang_undef_chain_list_type *new =
1991     ((ldlang_undef_chain_list_type *)
1992      stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1993
1994   new->next = ldlang_undef_chain_list_head;
1995   ldlang_undef_chain_list_head = new;
1996
1997   new->name = xstrdup (name);
1998 }
1999
2000 /* Run through the list of undefineds created above and place them
2001    into the linker hash table as undefined symbols belonging to the
2002    script file.  */
2003
2004 static void
2005 lang_place_undefineds ()
2006 {
2007   ldlang_undef_chain_list_type *ptr;
2008
2009   for (ptr = ldlang_undef_chain_list_head;
2010        ptr != (ldlang_undef_chain_list_type *) NULL;
2011        ptr = ptr->next)
2012     {
2013       struct bfd_link_hash_entry *h;
2014
2015       h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
2016       if (h == (struct bfd_link_hash_entry *) NULL)
2017         einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2018       if (h->type == bfd_link_hash_new)
2019         {
2020           h->type = bfd_link_hash_undefined;
2021           h->u.undef.abfd = NULL;
2022           bfd_link_add_undef (link_info.hash, h);
2023         }
2024     }
2025 }
2026
2027 /* Open input files and attatch to output sections.  */
2028
2029 static void
2030 map_input_to_output_sections (s, target, output_section_statement)
2031      lang_statement_union_type *s;
2032      const char *target;
2033      lang_output_section_statement_type *output_section_statement;
2034 {
2035   for (; s != (lang_statement_union_type *) NULL; s = s->next)
2036     {
2037       switch (s->header.type)
2038         {
2039
2040         case lang_wild_statement_enum:
2041           wild (&s->wild_statement, s->wild_statement.section_name,
2042                 s->wild_statement.filename, target,
2043                 output_section_statement);
2044
2045           break;
2046         case lang_constructors_statement_enum:
2047           map_input_to_output_sections (constructor_list.head,
2048                                         target,
2049                                         output_section_statement);
2050           break;
2051         case lang_output_section_statement_enum:
2052           map_input_to_output_sections (s->output_section_statement.children.head,
2053                                         target,
2054                                         &s->output_section_statement);
2055           break;
2056         case lang_output_statement_enum:
2057           break;
2058         case lang_target_statement_enum:
2059           target = s->target_statement.target;
2060           break;
2061         case lang_group_statement_enum:
2062           map_input_to_output_sections (s->group_statement.children.head,
2063                                         target,
2064                                         output_section_statement);
2065           break;
2066         case lang_fill_statement_enum:
2067         case lang_input_section_enum:
2068         case lang_object_symbols_statement_enum:
2069         case lang_data_statement_enum:
2070         case lang_reloc_statement_enum:
2071         case lang_padding_statement_enum:
2072         case lang_input_statement_enum:
2073           if (output_section_statement != NULL
2074               && output_section_statement->bfd_section == NULL)
2075             init_os (output_section_statement);
2076           break;
2077         case lang_assignment_statement_enum:
2078           if (output_section_statement != NULL
2079               && output_section_statement->bfd_section == NULL)
2080             init_os (output_section_statement);
2081
2082           /* Make sure that any sections mentioned in the assignment
2083              are initialized.  */
2084           exp_init_os (s->assignment_statement.exp);
2085           break;
2086         case lang_afile_asection_pair_statement_enum:
2087           FAIL ();
2088           break;
2089         case lang_address_statement_enum:
2090           /* Mark the specified section with the supplied address.  */
2091           {
2092             lang_output_section_statement_type *os =
2093               lang_output_section_statement_lookup
2094                 (s->address_statement.section_name);
2095
2096             if (os->bfd_section == NULL)
2097               init_os (os);
2098             os->addr_tree = s->address_statement.address;
2099           }
2100           break;
2101         }
2102     }
2103 }
2104
2105 static void
2106 print_output_section_statement (output_section_statement)
2107      lang_output_section_statement_type *output_section_statement;
2108 {
2109   asection *section = output_section_statement->bfd_section;
2110   int len;
2111
2112   if (output_section_statement != abs_output_section)
2113     {
2114       minfo ("\n%s", output_section_statement->name);
2115
2116       if (section != NULL)
2117         {
2118           print_dot = section->vma;
2119
2120           len = strlen (output_section_statement->name);
2121           if (len >= SECTION_NAME_MAP_LENGTH - 1)
2122             {
2123               print_nl ();
2124               len = 0;
2125             }
2126           while (len < SECTION_NAME_MAP_LENGTH)
2127             {
2128               print_space ();
2129               ++len;
2130             }
2131
2132           minfo ("0x%V %W", section->vma, section->_raw_size);
2133
2134           if (output_section_statement->load_base != NULL)
2135             {
2136               bfd_vma addr;
2137
2138               addr = exp_get_abs_int (output_section_statement->load_base, 0,
2139                                       "load base", lang_final_phase_enum);
2140               minfo (_(" load address 0x%V"), addr);
2141             }
2142         }
2143
2144       print_nl ();
2145     }
2146
2147   print_statement_list (output_section_statement->children.head,
2148                         output_section_statement);
2149 }
2150
2151 static void
2152 print_assignment (assignment, output_section)
2153      lang_assignment_statement_type *assignment;
2154      lang_output_section_statement_type *output_section;
2155 {
2156   int i;
2157   etree_value_type result;
2158
2159   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2160     print_space ();
2161
2162   result = exp_fold_tree (assignment->exp->assign.src, output_section,
2163                           lang_final_phase_enum, print_dot, &print_dot);
2164   if (result.valid_p)
2165     minfo ("0x%V", result.value + result.section->bfd_section->vma);
2166   else
2167     {
2168       minfo ("*undef*   ");
2169 #ifdef BFD64
2170       minfo ("        ");
2171 #endif
2172     }
2173
2174   minfo ("                ");
2175
2176   exp_print_tree (assignment->exp);
2177
2178   print_nl ();
2179 }
2180
2181 static void
2182 print_input_statement (statm)
2183      lang_input_statement_type *statm;
2184 {
2185   if (statm->filename != (char *) NULL)
2186     {
2187       fprintf (config.map_file, "LOAD %s\n", statm->filename);
2188     }
2189 }
2190
2191 /* Print all symbols defined in a particular section.  This is called
2192    via bfd_link_hash_traverse.  */
2193
2194 static boolean
2195 print_one_symbol (hash_entry, ptr)
2196      struct bfd_link_hash_entry *hash_entry;
2197      PTR ptr;
2198 {
2199   asection *sec = (asection *) ptr;
2200
2201   if ((hash_entry->type == bfd_link_hash_defined
2202        || hash_entry->type == bfd_link_hash_defweak)
2203       && sec == hash_entry->u.def.section)
2204     {
2205       int i;
2206
2207       for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2208         print_space ();
2209       minfo ("0x%V   ",
2210              (hash_entry->u.def.value
2211               + hash_entry->u.def.section->output_offset
2212               + hash_entry->u.def.section->output_section->vma));
2213
2214       minfo ("             %T\n", hash_entry->root.string);
2215     }
2216
2217   return true;
2218 }
2219
2220 /* Print information about an input section to the map file.  */
2221
2222 static void
2223 print_input_section (in)
2224      lang_input_section_type *in;
2225 {
2226   asection *i = in->section;
2227   bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2228   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2229                                                 ldfile_output_machine);
2230   if (size != 0)
2231     {
2232       print_space ();
2233
2234       minfo ("%s", i->name);
2235
2236       if (i->output_section != NULL)
2237         {
2238           int len;
2239
2240           len = 1 + strlen (i->name);
2241           if (len >= SECTION_NAME_MAP_LENGTH - 1)
2242             {
2243               print_nl ();
2244               len = 0;
2245             }
2246           while (len < SECTION_NAME_MAP_LENGTH)
2247             {
2248               print_space ();
2249               ++len;
2250             }
2251
2252           minfo ("0x%V %W %B\n",
2253                  i->output_section->vma + i->output_offset, size / opb,
2254                  i->owner);
2255
2256           if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2257             {
2258               len = SECTION_NAME_MAP_LENGTH + 3;
2259 #ifdef BFD64
2260               len += 16;
2261 #else
2262               len += 8;
2263 #endif
2264               while (len > 0)
2265                 {
2266                   print_space ();
2267                   --len;
2268                 }
2269
2270               minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2271             }
2272
2273           bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2274
2275           print_dot = i->output_section->vma + i->output_offset + size / opb;
2276         }
2277     }
2278 }
2279
2280 static void
2281 print_fill_statement (fill)
2282      lang_fill_statement_type *fill;
2283 {
2284   fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
2285 }
2286
2287 static void
2288 print_data_statement (data)
2289      lang_data_statement_type *data;
2290 {
2291   int i;
2292   bfd_vma addr;
2293   bfd_size_type size;
2294   const char *name;
2295   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2296                                                 ldfile_output_machine);
2297
2298   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2299     print_space ();
2300
2301   addr = data->output_vma;
2302   if (data->output_section != NULL)
2303     addr += data->output_section->vma;
2304
2305   switch (data->type)
2306     {
2307     default:
2308       abort ();
2309     case BYTE:
2310       size = BYTE_SIZE;
2311       name = "BYTE";
2312       break;
2313     case SHORT:
2314       size = SHORT_SIZE;
2315       name = "SHORT";
2316       break;
2317     case LONG:
2318       size = LONG_SIZE;
2319       name = "LONG";
2320       break;
2321     case QUAD:
2322       size = QUAD_SIZE;
2323       name = "QUAD";
2324       break;
2325     case SQUAD:
2326       size = QUAD_SIZE;
2327       name = "SQUAD";
2328       break;
2329     }
2330
2331   minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2332
2333   if (data->exp->type.node_class != etree_value)
2334     {
2335       print_space ();
2336       exp_print_tree (data->exp);
2337     }
2338
2339   print_nl ();
2340
2341   print_dot = addr + size / opb;
2342
2343 }
2344
2345 /* Print an address statement.  These are generated by options like
2346    -Ttext.  */
2347
2348 static void
2349 print_address_statement (address)
2350      lang_address_statement_type *address;
2351 {
2352   minfo (_("Address of section %s set to "), address->section_name);
2353   exp_print_tree (address->address);
2354   print_nl ();
2355 }
2356
2357 /* Print a reloc statement.  */
2358
2359 static void
2360 print_reloc_statement (reloc)
2361      lang_reloc_statement_type *reloc;
2362 {
2363   int i;
2364   bfd_vma addr;
2365   bfd_size_type size;
2366   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2367                                                 ldfile_output_machine);
2368
2369   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2370     print_space ();
2371
2372   addr = reloc->output_vma;
2373   if (reloc->output_section != NULL)
2374     addr += reloc->output_section->vma;
2375
2376   size = bfd_get_reloc_size (reloc->howto);
2377
2378   minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2379
2380   if (reloc->name != NULL)
2381     minfo ("%s+", reloc->name);
2382   else
2383     minfo ("%s+", reloc->section->name);
2384
2385   exp_print_tree (reloc->addend_exp);
2386
2387   print_nl ();
2388
2389   print_dot = addr + size / opb;
2390 }
2391
2392 static void
2393 print_padding_statement (s)
2394      lang_padding_statement_type *s;
2395 {
2396   int len;
2397   bfd_vma addr;
2398   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2399                                                 ldfile_output_machine);
2400
2401   minfo (" *fill*");
2402
2403   len = sizeof " *fill*" - 1;
2404   while (len < SECTION_NAME_MAP_LENGTH)
2405     {
2406       print_space ();
2407       ++len;
2408     }
2409
2410   addr = s->output_offset;
2411   if (s->output_section != NULL)
2412     addr += s->output_section->vma;
2413   minfo ("0x%V %W", addr, s->size);
2414
2415   if (s->fill != 0)
2416     minfo (" %u", s->fill);
2417
2418   print_nl ();
2419
2420   print_dot = addr + s->size / opb;
2421 }
2422
2423 static void
2424 print_wild_statement (w, os)
2425      lang_wild_statement_type *w;
2426      lang_output_section_statement_type *os;
2427 {
2428   print_space ();
2429
2430   if (w->filenames_sorted)
2431     minfo ("SORT(");
2432   if (w->exclude_filename_list != NULL)
2433     {
2434       name_list *tmp;
2435       minfo ("EXCLUDE_FILE ( %s", w->exclude_filename_list->name);
2436       for (tmp = w->exclude_filename_list->next; tmp; tmp = tmp->next)
2437         minfo (", %s", tmp->name);
2438       minfo (")");
2439     }
2440   if (w->filename != NULL)
2441     minfo ("%s", w->filename);
2442   else
2443     minfo ("*");
2444   if (w->filenames_sorted)
2445     minfo (")");
2446
2447   minfo ("(");
2448   if (w->sections_sorted)
2449     minfo ("SORT(");
2450   if (w->section_name != NULL)
2451     minfo ("%s", w->section_name);
2452   else
2453     minfo ("*");
2454   if (w->sections_sorted)
2455     minfo (")");
2456   minfo (")");
2457
2458   print_nl ();
2459
2460   print_statement_list (w->children.head, os);
2461 }
2462
2463 /* Print a group statement.  */
2464
2465 static void
2466 print_group (s, os)
2467      lang_group_statement_type *s;
2468      lang_output_section_statement_type *os;
2469 {
2470   fprintf (config.map_file, "START GROUP\n");
2471   print_statement_list (s->children.head, os);
2472   fprintf (config.map_file, "END GROUP\n");
2473 }
2474
2475 /* Print the list of statements in S.
2476    This can be called for any statement type.  */
2477
2478 static void
2479 print_statement_list (s, os)
2480      lang_statement_union_type *s;
2481      lang_output_section_statement_type *os;
2482 {
2483   while (s != NULL)
2484     {
2485       print_statement (s, os);
2486       s = s->next;
2487     }
2488 }
2489
2490 /* Print the first statement in statement list S.
2491    This can be called for any statement type.  */
2492
2493 static void
2494 print_statement (s, os)
2495      lang_statement_union_type *s;
2496      lang_output_section_statement_type *os;
2497 {
2498   switch (s->header.type)
2499     {
2500     default:
2501       fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2502       FAIL ();
2503       break;
2504     case lang_constructors_statement_enum:
2505       if (constructor_list.head != NULL)
2506         {
2507           if (constructors_sorted)
2508             minfo (" SORT (CONSTRUCTORS)\n");
2509           else
2510             minfo (" CONSTRUCTORS\n");
2511           print_statement_list (constructor_list.head, os);
2512         }
2513       break;
2514     case lang_wild_statement_enum:
2515       print_wild_statement (&s->wild_statement, os);
2516       break;
2517     case lang_address_statement_enum:
2518       print_address_statement (&s->address_statement);
2519       break;
2520     case lang_object_symbols_statement_enum:
2521       minfo (" CREATE_OBJECT_SYMBOLS\n");
2522       break;
2523     case lang_fill_statement_enum:
2524       print_fill_statement (&s->fill_statement);
2525       break;
2526     case lang_data_statement_enum:
2527       print_data_statement (&s->data_statement);
2528       break;
2529     case lang_reloc_statement_enum:
2530       print_reloc_statement (&s->reloc_statement);
2531       break;
2532     case lang_input_section_enum:
2533       print_input_section (&s->input_section);
2534       break;
2535     case lang_padding_statement_enum:
2536       print_padding_statement (&s->padding_statement);
2537       break;
2538     case lang_output_section_statement_enum:
2539       print_output_section_statement (&s->output_section_statement);
2540       break;
2541     case lang_assignment_statement_enum:
2542       print_assignment (&s->assignment_statement, os);
2543       break;
2544     case lang_target_statement_enum:
2545       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2546       break;
2547     case lang_output_statement_enum:
2548       minfo ("OUTPUT(%s", s->output_statement.name);
2549       if (output_target != NULL)
2550         minfo (" %s", output_target);
2551       minfo (")\n");
2552       break;
2553     case lang_input_statement_enum:
2554       print_input_statement (&s->input_statement);
2555       break;
2556     case lang_group_statement_enum:
2557       print_group (&s->group_statement, os);
2558       break;
2559     case lang_afile_asection_pair_statement_enum:
2560       FAIL ();
2561       break;
2562     }
2563 }
2564
2565 static void
2566 print_statements ()
2567 {
2568   print_statement_list (statement_list.head, abs_output_section);
2569 }
2570
2571 /* Print the first N statements in statement list S to STDERR.
2572    If N == 0, nothing is printed.
2573    If N < 0, the entire list is printed.
2574    Intended to be called from GDB.  */
2575
2576 void
2577 dprint_statement (s, n)
2578      lang_statement_union_type *s;
2579      int n;
2580 {
2581   FILE *map_save = config.map_file;
2582
2583   config.map_file = stderr;
2584
2585   if (n < 0)
2586     print_statement_list (s, abs_output_section);
2587   else
2588     {
2589       while (s && --n >= 0)
2590         {
2591           print_statement (s, abs_output_section);
2592           s = s->next;
2593         }
2594     }
2595
2596   config.map_file = map_save;
2597 }
2598
2599 static bfd_vma
2600 insert_pad (this_ptr, fill, power, output_section_statement, dot)
2601      lang_statement_union_type **this_ptr;
2602      fill_type fill;
2603      unsigned int power;
2604      asection *output_section_statement;
2605      bfd_vma dot;
2606 {
2607   /* Align this section first to the
2608      input sections requirement, then
2609      to the output section's requirement.
2610      If this alignment is > than any seen before,
2611      then record it too. Perform the alignment by
2612      inserting a magic 'padding' statement.  */
2613
2614   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2615                                                 ldfile_output_machine);
2616   unsigned int alignment_needed = align_power (dot, power) - dot;
2617
2618   if (alignment_needed != 0)
2619     {
2620       lang_statement_union_type *new =
2621         ((lang_statement_union_type *)
2622          stat_alloc (sizeof (lang_padding_statement_type)));
2623
2624       /* Link into existing chain.  */
2625       new->header.next = *this_ptr;
2626       *this_ptr = new;
2627       new->header.type = lang_padding_statement_enum;
2628       new->padding_statement.output_section = output_section_statement;
2629       new->padding_statement.output_offset =
2630         dot - output_section_statement->vma;
2631       new->padding_statement.fill = fill;
2632       new->padding_statement.size = alignment_needed * opb;
2633     }
2634
2635   /* Remember the most restrictive alignment.  */
2636   if (power > output_section_statement->alignment_power)
2637     {
2638       output_section_statement->alignment_power = power;
2639     }
2640   output_section_statement->_raw_size += alignment_needed * opb;
2641
2642   return dot + alignment_needed;
2643 }
2644
2645 /* Work out how much this section will move the dot point.  */
2646
2647 static bfd_vma
2648 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2649      lang_statement_union_type **this_ptr;
2650      lang_output_section_statement_type *output_section_statement;
2651      fill_type fill;
2652      bfd_vma dot;
2653      boolean relax ATTRIBUTE_UNUSED;
2654 {
2655   lang_input_section_type *is = &((*this_ptr)->input_section);
2656   asection *i = is->section;
2657   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2658                                                 ldfile_output_machine);
2659
2660   if (is->ifile->just_syms_flag == false)
2661     {
2662       if (output_section_statement->subsection_alignment != -1)
2663        i->alignment_power =
2664         output_section_statement->subsection_alignment;
2665
2666       dot = insert_pad (this_ptr, fill, i->alignment_power,
2667                         output_section_statement->bfd_section, dot);
2668
2669       /* Remember where in the output section this input section goes.  */
2670
2671       i->output_offset = dot - output_section_statement->bfd_section->vma;
2672
2673       /* Mark how big the output section must be to contain this now.  */
2674       if (i->_cooked_size != 0)
2675         dot += i->_cooked_size / opb;
2676       else
2677         dot += i->_raw_size / opb;
2678       output_section_statement->bfd_section->_raw_size =
2679         (dot - output_section_statement->bfd_section->vma) * opb;
2680     }
2681   else
2682     {
2683       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2684     }
2685
2686   return dot;
2687 }
2688
2689 #define IGNORE_SECTION(bfd, s) \
2690   (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) != (SEC_ALLOC | SEC_LOAD)) \
2691    || bfd_section_size (bfd, s) == 0)
2692 /* Check to see if any allocated sections overlap with other allocated
2693    sections.  This can happen when the linker script specifically specifies
2694    the output section addresses of the two sections.  */
2695
2696 static void
2697 lang_check_section_addresses ()
2698 {
2699   asection *s;
2700   unsigned opb = bfd_octets_per_byte (output_bfd);
2701
2702
2703   /* Scan all sections in the output list.  */
2704   for (s = output_bfd->sections; s != NULL; s = s->next)
2705     {
2706       asection *os;
2707
2708       /* Ignore sections which are not loaded or which have no contents.  */
2709       if (IGNORE_SECTION (output_bfd, s))
2710         continue;
2711
2712       /* Once we reach section 's' stop our seach.  This prevents two
2713          warning messages from being produced, one for 'section A overlaps
2714          section B' and one for 'section B overlaps section A'.  */
2715       for (os = output_bfd->sections; os != s; os = os->next)
2716         {
2717           bfd_vma s_start;
2718           bfd_vma s_end;
2719           bfd_vma os_start;
2720           bfd_vma os_end;
2721
2722           /* Only consider loadable sections with real contents.  */
2723           if (IGNORE_SECTION (output_bfd, os))
2724             continue;
2725
2726           /* We must check the sections' LMA addresses not their
2727              VMA addresses because overlay sections can have
2728              overlapping VMAs but they must have distinct LMAs.  */
2729           s_start  = bfd_section_lma (output_bfd, s);
2730           os_start = bfd_section_lma (output_bfd, os);
2731           s_end    = s_start  + bfd_section_size (output_bfd, s) / opb - 1;
2732           os_end   = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2733
2734           /* Look for an overlap.  */
2735           if ((s_end < os_start) || (s_start > os_end))
2736             continue;
2737
2738           einfo (
2739 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2740                  s->name, s_start, s_end, os->name, os_start, os_end);
2741
2742           /* Once we have found one overlap for this section,
2743              stop looking for others.  */
2744           break;
2745         }
2746     }
2747 }
2748
2749 /* This variable indicates whether bfd_relax_section should be called
2750    again.  */
2751
2752 static boolean relax_again;
2753
2754 /* Make sure the new address is within the region.  We explicitly permit the
2755    current address to be at the exact end of the region when the address is
2756    non-zero, in case the region is at the end of addressable memory and the
2757    calculation wraps around.  */
2758
2759 static void
2760 os_region_check (os, region, tree, base)
2761      lang_output_section_statement_type *os;
2762      struct memory_region_struct *region;
2763      etree_type *tree;
2764      bfd_vma base;
2765 {
2766   if ((region->current < region->origin
2767        || (region->current - region->origin > region->length))
2768       && ((region->current != region->origin + region->length)
2769            || base == 0))
2770     {
2771       if (tree != (etree_type *) NULL)
2772         {
2773           einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2774                  region->current,
2775                  os->bfd_section->owner,
2776                  os->bfd_section->name,
2777                  region->name);
2778         }
2779       else
2780         {
2781           einfo (_("%X%P: region %s is full (%B section %s)\n"),
2782                  region->name,
2783                  os->bfd_section->owner,
2784                  os->bfd_section->name);
2785         }
2786       /* Reset the region pointer.  */
2787       region->current = region->origin;
2788     }
2789 }
2790
2791 /* Set the sizes for all the output sections.  */
2792
2793 bfd_vma
2794 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2795      lang_statement_union_type *s;
2796      lang_output_section_statement_type *output_section_statement;
2797      lang_statement_union_type **prev;
2798      fill_type fill;
2799      bfd_vma dot;
2800      boolean relax;
2801 {
2802   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2803                                                 ldfile_output_machine);
2804
2805   /* Size up the sections from their constituent parts.  */
2806   for (; s != (lang_statement_union_type *) NULL; s = s->next)
2807     {
2808       switch (s->header.type)
2809         {
2810         case lang_output_section_statement_enum:
2811           {
2812             bfd_vma after;
2813             lang_output_section_statement_type *os = &s->output_section_statement;
2814
2815             if (os->bfd_section == NULL)
2816               /* This section was never actually created.  */
2817               break;
2818
2819             /* If this is a COFF shared library section, use the size and
2820                address from the input section.  FIXME: This is COFF
2821                specific; it would be cleaner if there were some other way
2822                to do this, but nothing simple comes to mind.  */
2823             if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2824               {
2825                 asection *input;
2826
2827                 if (os->children.head == NULL
2828                     || os->children.head->next != NULL
2829                     || os->children.head->header.type != lang_input_section_enum)
2830                   einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2831                          os->name);
2832
2833                 input = os->children.head->input_section.section;
2834                 bfd_set_section_vma (os->bfd_section->owner,
2835                                      os->bfd_section,
2836                                      bfd_section_vma (input->owner, input));
2837                 os->bfd_section->_raw_size = input->_raw_size;
2838                 break;
2839               }
2840
2841             if (bfd_is_abs_section (os->bfd_section))
2842               {
2843                 /* No matter what happens, an abs section starts at zero.  */
2844                 ASSERT (os->bfd_section->vma == 0);
2845               }
2846             else
2847               {
2848                 if (os->addr_tree == (etree_type *) NULL)
2849                   {
2850                     /* No address specified for this section, get one
2851                        from the region specification.  */
2852                     if (os->region == (lang_memory_region_type *) NULL
2853                         || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2854                               & (SEC_ALLOC | SEC_LOAD)) != 0)
2855                             && os->region->name[0] == '*'
2856                             && strcmp (os->region->name, "*default*") == 0))
2857                       {
2858                         os->region = lang_memory_default (os->bfd_section);
2859                       }
2860
2861                     /* If a loadable section is using the default memory
2862                        region, and some non default memory regions were
2863                        defined, issue a warning.  */
2864                     if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2865                          & (SEC_ALLOC | SEC_LOAD)) != 0
2866                         && ! link_info.relocateable
2867                         && strcmp (os->region->name, "*default*") == 0
2868                         && lang_memory_region_list != NULL
2869                         && (strcmp (lang_memory_region_list->name, "*default*") != 0
2870                             || lang_memory_region_list->next != NULL))
2871                       einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2872                              bfd_get_section_name (output_bfd, os->bfd_section));
2873
2874                     dot = os->region->current;
2875
2876                     if (os->section_alignment == -1)
2877                       {
2878                         bfd_vma olddot;
2879
2880                         olddot = dot;
2881                         dot = align_power (dot, os->bfd_section->alignment_power);
2882
2883                         if (dot != olddot && config.warn_section_align)
2884                           einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2885                                  os->name, (unsigned int) (dot - olddot));
2886                       }
2887                   }
2888                 else
2889                   {
2890                     etree_value_type r;
2891
2892                     r = exp_fold_tree (os->addr_tree,
2893                                        abs_output_section,
2894                                        lang_allocating_phase_enum,
2895                                        dot, &dot);
2896                     if (r.valid_p == false)
2897                       {
2898                         einfo (_("%F%S: non constant address expression for section %s\n"),
2899                                os->name);
2900                       }
2901                     dot = r.value + r.section->bfd_section->vma;
2902                   }
2903
2904                 /* The section starts here.
2905                    First, align to what the section needs.  */
2906
2907                 if (os->section_alignment != -1)
2908                   dot = align_power (dot, os->section_alignment);
2909
2910                 bfd_set_section_vma (0, os->bfd_section, dot);
2911
2912                 os->bfd_section->output_offset = 0;
2913               }
2914
2915             (void) lang_size_sections (os->children.head, os,
2916                                        &os->children.head,
2917                                        os->fill, dot, relax);
2918
2919             /* Put the section within the requested block size, or
2920                align at the block boundary.  */
2921             after = ALIGN_N (os->bfd_section->vma
2922                              + os->bfd_section->_raw_size / opb,
2923                              /* The coercion here is important, see ld.h.  */
2924                              (bfd_vma) os->block_value);
2925
2926             if (bfd_is_abs_section (os->bfd_section))
2927               ASSERT (after == os->bfd_section->vma);
2928             else
2929               os->bfd_section->_raw_size =
2930                 (after - os->bfd_section->vma) * opb;
2931             dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
2932             os->processed = true;
2933
2934             /* Update dot in the region ?
2935                We only do this if the section is going to be allocated,
2936                since unallocated sections do not contribute to the region's
2937                overall size in memory.
2938
2939                If the SEC_NEVER_LOAD bit is not set, it will affect the
2940                addresses of sections after it. We have to update
2941                dot.  */
2942             if (os->region != (lang_memory_region_type *) NULL
2943                 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
2944                      & SEC_NEVER_LOAD) == 0
2945                     || (bfd_get_section_flags (output_bfd, os->bfd_section)
2946                         & (SEC_ALLOC | SEC_LOAD))))
2947               {
2948                 os->region->current = dot;
2949
2950                 /* Make sure the new address is within the region.  */
2951                 os_region_check (os, os->region, os->addr_tree,
2952                                  os->bfd_section->vma);
2953
2954                 /* If there's no load address specified, use the run
2955                    region as the load region.  */
2956                 if (os->lma_region == NULL && os->load_base == NULL)
2957                   os->lma_region = os->region;
2958
2959                 if (os->lma_region != NULL)
2960                   {
2961                     if (os->load_base != NULL)
2962                       {
2963                         einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2964                       }
2965                     else
2966                       {
2967                         /* Don't allocate twice.  */
2968                         if (os->lma_region != os->region)
2969                           {
2970                             /* Set load_base, which will be handled later.  */
2971                             os->load_base =
2972                               exp_intop (os->lma_region->current);
2973                             os->lma_region->current +=
2974                               os->bfd_section->_raw_size / opb;
2975                             os_region_check (os, os->lma_region, NULL,
2976                                              os->bfd_section->lma);
2977                           }
2978                       }
2979                   }
2980               }
2981           }
2982           break;
2983
2984         case lang_constructors_statement_enum:
2985           dot = lang_size_sections (constructor_list.head,
2986                                     output_section_statement,
2987                                     &s->wild_statement.children.head,
2988                                     fill,
2989                                     dot, relax);
2990           break;
2991
2992         case lang_data_statement_enum:
2993           {
2994             unsigned int size = 0;
2995
2996             s->data_statement.output_vma =
2997               dot - output_section_statement->bfd_section->vma;
2998             s->data_statement.output_section =
2999               output_section_statement->bfd_section;
3000
3001             switch (s->data_statement.type)
3002               {
3003               default:
3004                 abort ();
3005               case QUAD:
3006               case SQUAD:
3007                 size = QUAD_SIZE;
3008                 break;
3009               case LONG:
3010                 size = LONG_SIZE;
3011                 break;
3012               case SHORT:
3013                 size = SHORT_SIZE;
3014                 break;
3015               case BYTE:
3016                 size = BYTE_SIZE;
3017                 break;
3018               }
3019             if (size < opb)
3020               size = opb;
3021             dot += size / opb;
3022             output_section_statement->bfd_section->_raw_size += size;
3023             /* The output section gets contents, and then we inspect for
3024                any flags set in the input script which override any ALLOC.  */
3025             output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3026             if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3027               {
3028                 output_section_statement->bfd_section->flags |=
3029                   SEC_ALLOC | SEC_LOAD;
3030               }
3031           }
3032           break;
3033
3034         case lang_reloc_statement_enum:
3035           {
3036             int size;
3037
3038             s->reloc_statement.output_vma =
3039               dot - output_section_statement->bfd_section->vma;
3040             s->reloc_statement.output_section =
3041               output_section_statement->bfd_section;
3042             size = bfd_get_reloc_size (s->reloc_statement.howto);
3043             dot += size / opb;
3044             output_section_statement->bfd_section->_raw_size += size;
3045           }
3046           break;
3047
3048         case lang_wild_statement_enum:
3049
3050           dot = lang_size_sections (s->wild_statement.children.head,
3051                                     output_section_statement,
3052                                     &s->wild_statement.children.head,
3053                                     fill, dot, relax);
3054
3055           break;
3056
3057         case lang_object_symbols_statement_enum:
3058           link_info.create_object_symbols_section =
3059             output_section_statement->bfd_section;
3060           break;
3061         case lang_output_statement_enum:
3062         case lang_target_statement_enum:
3063           break;
3064         case lang_input_section_enum:
3065           {
3066             asection *i;
3067
3068             i = (*prev)->input_section.section;
3069             if (! relax)
3070               {
3071                 if (i->_cooked_size == 0)
3072                   i->_cooked_size = i->_raw_size;
3073               }
3074             else
3075               {
3076                 boolean again;
3077
3078                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3079                   einfo (_("%P%F: can't relax section: %E\n"));
3080                 if (again)
3081                   relax_again = true;
3082               }
3083             dot = size_input_section (prev,
3084                                       output_section_statement,
3085                                       output_section_statement->fill,
3086                                       dot, relax);
3087           }
3088           break;
3089         case lang_input_statement_enum:
3090           break;
3091         case lang_fill_statement_enum:
3092           s->fill_statement.output_section =
3093             output_section_statement->bfd_section;
3094
3095           fill = s->fill_statement.fill;
3096           break;
3097         case lang_assignment_statement_enum:
3098           {
3099             bfd_vma newdot = dot;
3100
3101             exp_fold_tree (s->assignment_statement.exp,
3102                            output_section_statement,
3103                            lang_allocating_phase_enum,
3104                            dot,
3105                            &newdot);
3106
3107             if (newdot != dot)
3108               {
3109                 /* The assignment changed dot.  Insert a pad.  */
3110                 if (output_section_statement == abs_output_section)
3111                   {
3112                     /* If we don't have an output section, then just adjust
3113                        the default memory address.  */
3114                     lang_memory_region_lookup ("*default*")->current = newdot;
3115                   }
3116                 else if (!relax)
3117                   {
3118                     lang_statement_union_type *new =
3119                       ((lang_statement_union_type *)
3120                        stat_alloc (sizeof (lang_padding_statement_type)));
3121
3122                     /* Link into existing chain.  */
3123                     new->header.next = *prev;
3124                     *prev = new;
3125                     new->header.type = lang_padding_statement_enum;
3126                     new->padding_statement.output_section =
3127                       output_section_statement->bfd_section;
3128                     new->padding_statement.output_offset =
3129                       dot - output_section_statement->bfd_section->vma;
3130                     new->padding_statement.fill = fill;
3131                     new->padding_statement.size = (newdot - dot) * opb;
3132                     output_section_statement->bfd_section->_raw_size +=
3133                       new->padding_statement.size;
3134                   }
3135
3136                 dot = newdot;
3137               }
3138           }
3139           break;
3140
3141         case lang_padding_statement_enum:
3142           /* If we are relaxing, and this is not the first pass, some
3143              padding statements may have been inserted during previous
3144              passes.  We may have to move the padding statement to a new
3145              location if dot has a different value at this point in this
3146              pass than it did at this point in the previous pass.  */
3147           s->padding_statement.output_offset =
3148             dot - output_section_statement->bfd_section->vma;
3149           dot += s->padding_statement.size / opb;
3150           output_section_statement->bfd_section->_raw_size +=
3151             s->padding_statement.size;
3152           break;
3153
3154         case lang_group_statement_enum:
3155           dot = lang_size_sections (s->group_statement.children.head,
3156                                     output_section_statement,
3157                                     &s->group_statement.children.head,
3158                                     fill, dot, relax);
3159           break;
3160
3161         default:
3162           FAIL ();
3163           break;
3164
3165           /* This can only get here when relaxing is turned on.  */
3166
3167         case lang_address_statement_enum:
3168           break;
3169         }
3170       prev = &s->header.next;
3171     }
3172   return dot;
3173 }
3174
3175 bfd_vma
3176 lang_do_assignments (s, output_section_statement, fill, dot)
3177      lang_statement_union_type *s;
3178      lang_output_section_statement_type *output_section_statement;
3179      fill_type fill;
3180      bfd_vma dot;
3181 {
3182   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3183                                                 ldfile_output_machine);
3184
3185   for (; s != (lang_statement_union_type *) NULL; s = s->next)
3186     {
3187       switch (s->header.type)
3188         {
3189         case lang_constructors_statement_enum:
3190           dot = lang_do_assignments (constructor_list.head,
3191                                      output_section_statement,
3192                                      fill,
3193                                      dot);
3194           break;
3195
3196         case lang_output_section_statement_enum:
3197           {
3198             lang_output_section_statement_type *os =
3199               &(s->output_section_statement);
3200
3201             if (os->bfd_section != NULL)
3202               {
3203                 dot = os->bfd_section->vma;
3204                 (void) lang_do_assignments (os->children.head, os,
3205                                             os->fill, dot);
3206                 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3207
3208               }
3209             if (os->load_base)
3210               {
3211                 /* If nothing has been placed into the output section then
3212                    it won't have a bfd_section.  */
3213                 if (os->bfd_section)
3214                   {
3215                     os->bfd_section->lma
3216                       = exp_get_abs_int (os->load_base, 0, "load base",
3217                                          lang_final_phase_enum);
3218                   }
3219               }
3220           }
3221           break;
3222         case lang_wild_statement_enum:
3223
3224           dot = lang_do_assignments (s->wild_statement.children.head,
3225                                      output_section_statement,
3226                                      fill, dot);
3227
3228           break;
3229
3230         case lang_object_symbols_statement_enum:
3231         case lang_output_statement_enum:
3232         case lang_target_statement_enum:
3233 #if 0
3234         case lang_common_statement_enum:
3235 #endif
3236           break;
3237         case lang_data_statement_enum:
3238           {
3239             etree_value_type value;
3240
3241             value = exp_fold_tree (s->data_statement.exp,
3242                                    abs_output_section,
3243                                    lang_final_phase_enum, dot, &dot);
3244             s->data_statement.value = value.value;
3245             if (value.valid_p == false)
3246               einfo (_("%F%P: invalid data statement\n"));
3247           }
3248           {
3249             unsigned int size;
3250             switch (s->data_statement.type)
3251               {
3252               default:
3253                 abort ();
3254               case QUAD:
3255               case SQUAD:
3256                 size = QUAD_SIZE;
3257                 break;
3258               case LONG:
3259                 size = LONG_SIZE;
3260                 break;
3261               case SHORT:
3262                 size = SHORT_SIZE;
3263                 break;
3264               case BYTE:
3265                 size = BYTE_SIZE;
3266                 break;
3267               }
3268             if (size < opb)
3269               size = opb;
3270             dot += size / opb;
3271           }
3272           break;
3273
3274         case lang_reloc_statement_enum:
3275           {
3276             etree_value_type value;
3277
3278             value = exp_fold_tree (s->reloc_statement.addend_exp,
3279                                    abs_output_section,
3280                                    lang_final_phase_enum, dot, &dot);
3281             s->reloc_statement.addend_value = value.value;
3282             if (value.valid_p == false)
3283               einfo (_("%F%P: invalid reloc statement\n"));
3284           }
3285           dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3286           break;
3287
3288         case lang_input_section_enum:
3289           {
3290             asection *in = s->input_section.section;
3291
3292             if (in->_cooked_size != 0)
3293               dot += in->_cooked_size / opb;
3294             else
3295               dot += in->_raw_size / opb;
3296           }
3297           break;
3298
3299         case lang_input_statement_enum:
3300           break;
3301         case lang_fill_statement_enum:
3302           fill = s->fill_statement.fill;
3303           break;
3304         case lang_assignment_statement_enum:
3305           {
3306             exp_fold_tree (s->assignment_statement.exp,
3307                            output_section_statement,
3308                            lang_final_phase_enum,
3309                            dot,
3310                            &dot);
3311           }
3312
3313           break;
3314         case lang_padding_statement_enum:
3315           dot += s->padding_statement.size / opb;
3316           break;
3317
3318         case lang_group_statement_enum:
3319           dot = lang_do_assignments (s->group_statement.children.head,
3320                                      output_section_statement,
3321                                      fill, dot);
3322
3323           break;
3324
3325         default:
3326           FAIL ();
3327           break;
3328         case lang_address_statement_enum:
3329           break;
3330         }
3331
3332     }
3333   return dot;
3334 }
3335
3336 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
3337    operator .startof. (section_name), it produces an undefined symbol
3338    .startof.section_name.  Similarly, when it sees
3339    .sizeof. (section_name), it produces an undefined symbol
3340    .sizeof.section_name.  For all the output sections, we look for
3341    such symbols, and set them to the correct value.  */
3342
3343 static void
3344 lang_set_startof ()
3345 {
3346   asection *s;
3347
3348   if (link_info.relocateable)
3349     return;
3350
3351   for (s = output_bfd->sections; s != NULL; s = s->next)
3352     {
3353       const char *secname;
3354       char *buf;
3355       struct bfd_link_hash_entry *h;
3356
3357       secname = bfd_get_section_name (output_bfd, s);
3358       buf = xmalloc (10 + strlen (secname));
3359
3360       sprintf (buf, ".startof.%s", secname);
3361       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3362       if (h != NULL && h->type == bfd_link_hash_undefined)
3363         {
3364           h->type = bfd_link_hash_defined;
3365           h->u.def.value = bfd_get_section_vma (output_bfd, s);
3366           h->u.def.section = bfd_abs_section_ptr;
3367         }
3368
3369       sprintf (buf, ".sizeof.%s", secname);
3370       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3371       if (h != NULL && h->type == bfd_link_hash_undefined)
3372         {
3373           unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3374                                                         ldfile_output_machine);
3375           h->type = bfd_link_hash_defined;
3376           if (s->_cooked_size != 0)
3377             h->u.def.value = s->_cooked_size / opb;
3378           else
3379             h->u.def.value = s->_raw_size / opb;
3380           h->u.def.section = bfd_abs_section_ptr;
3381         }
3382
3383       free (buf);
3384     }
3385 }
3386
3387 static void
3388 lang_finish ()
3389 {
3390   struct bfd_link_hash_entry *h;
3391   boolean warn;
3392
3393   if (link_info.relocateable || link_info.shared)
3394     warn = false;
3395   else
3396     warn = true;
3397
3398   if (entry_symbol == (char *) NULL)
3399     {
3400       /* No entry has been specified.  Look for start, but don't warn
3401          if we don't find it.  */
3402       entry_symbol = "start";
3403       warn = false;
3404     }
3405
3406   h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3407   if (h != (struct bfd_link_hash_entry *) NULL
3408       && (h->type == bfd_link_hash_defined
3409           || h->type == bfd_link_hash_defweak)
3410       && h->u.def.section->output_section != NULL)
3411     {
3412       bfd_vma val;
3413
3414       val = (h->u.def.value
3415              + bfd_get_section_vma (output_bfd,
3416                                     h->u.def.section->output_section)
3417              + h->u.def.section->output_offset);
3418       if (! bfd_set_start_address (output_bfd, val))
3419         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3420     }
3421   else
3422     {
3423       bfd_vma val;
3424       const char *send;
3425
3426       /* We couldn't find the entry symbol.  Try parsing it as a
3427          number.  */
3428       val = bfd_scan_vma (entry_symbol, &send, 0);
3429       if (*send == '\0')
3430         {
3431           if (! bfd_set_start_address (output_bfd, val))
3432             einfo (_("%P%F: can't set start address\n"));
3433         }
3434       else
3435         {
3436           asection *ts;
3437
3438           /* Can't find the entry symbol, and it's not a number.  Use
3439              the first address in the text section.  */
3440           ts = bfd_get_section_by_name (output_bfd, ".text");
3441           if (ts != (asection *) NULL)
3442             {
3443               if (warn)
3444                 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3445                        entry_symbol, bfd_get_section_vma (output_bfd, ts));
3446               if (! bfd_set_start_address (output_bfd,
3447                                            bfd_get_section_vma (output_bfd,
3448                                                                 ts)))
3449                 einfo (_("%P%F: can't set start address\n"));
3450             }
3451           else
3452             {
3453               if (warn)
3454                 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3455                        entry_symbol);
3456             }
3457         }
3458     }
3459 }
3460
3461
3462 /* This is the routine to handle BFD error messages.  */
3463
3464 #ifdef ANSI_PROTOTYPES
3465
3466 static void
3467 record_bfd_errors (const char *s, ...)
3468 {
3469   va_list p;
3470
3471   einfo ("%P: ");
3472
3473   va_start (p, s);
3474
3475   vfprintf (stderr, s, p);
3476
3477   va_end (p);
3478
3479   fprintf (stderr, "\n");
3480
3481   einfo ("%X");
3482 }
3483
3484 #else /* ! defined (ANSI_PROTOTYPES) */
3485
3486 static void
3487 record_bfd_errors (va_alist)
3488      va_dcl
3489 {
3490   va_list p;
3491   const char *s;
3492
3493   einfo ("%P: ");
3494
3495   va_start (p);
3496
3497   s = va_arg (p, const char *);
3498   vfprintf (stderr, s, p);
3499
3500   va_end (p);
3501
3502   fprintf (stderr, "\n");
3503
3504   einfo ("%X");
3505 }
3506
3507 #endif /* ! defined (ANSI_PROTOTYPES) */
3508 /* This is a small function used when we want to ignore errors from
3509    BFD.  */
3510
3511 static void
3512 #ifdef ANSI_PROTOTYPES
3513 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3514 #else
3515 ignore_bfd_errors (s)
3516      const char *s ATTRIBUTE_UNUSED;
3517 #endif
3518 {
3519   /* Don't do anything.  */
3520 }
3521
3522 /* Check that the architecture of all the input files is compatible
3523    with the output file.  Also call the backend to let it do any
3524    other checking that is needed.  */
3525
3526 static void
3527 lang_check ()
3528 {
3529   lang_statement_union_type *file;
3530   bfd *input_bfd;
3531   const bfd_arch_info_type *compatible;
3532
3533   for (file = file_chain.head;
3534        file != (lang_statement_union_type *) NULL;
3535        file = file->input_statement.next)
3536     {
3537       input_bfd = file->input_statement.the_bfd;
3538       compatible = bfd_arch_get_compatible (input_bfd,
3539                                             output_bfd);
3540       if (compatible == NULL)
3541         {
3542           if (command_line.warn_mismatch)
3543             einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3544                    bfd_printable_name (input_bfd), input_bfd,
3545                    bfd_printable_name (output_bfd));
3546         }
3547       else if (bfd_count_sections (input_bfd))
3548         {
3549           /* If the input bfd has no contents, it shouldn't set the
3550              private data of the output bfd. */
3551
3552           bfd_error_handler_type pfn = NULL;
3553
3554           /* If we aren't supposed to warn about mismatched input
3555              files, temporarily set the BFD error handler to a
3556              function which will do nothing.  We still want to call
3557              bfd_merge_private_bfd_data, since it may set up
3558              information which is needed in the output file.  */
3559           if (! command_line.warn_mismatch)
3560             pfn = bfd_set_error_handler (ignore_bfd_errors);
3561           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3562             {
3563               if (command_line.warn_mismatch)
3564                 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3565                        input_bfd);
3566             }
3567           if (! command_line.warn_mismatch)
3568             bfd_set_error_handler (pfn);
3569         }
3570     }
3571 }
3572
3573 /* Look through all the global common symbols and attach them to the
3574    correct section.  The -sort-common command line switch may be used
3575    to roughly sort the entries by size.  */
3576
3577 static void
3578 lang_common ()
3579 {
3580   if (link_info.relocateable
3581       && ! command_line.force_common_definition)
3582     return;
3583
3584   if (! config.sort_common)
3585     bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3586   else
3587     {
3588       int power;
3589
3590       for (power = 4; power >= 0; power--)
3591         bfd_link_hash_traverse (link_info.hash, lang_one_common,
3592                                 (PTR) &power);
3593     }
3594 }
3595
3596 /* Place one common symbol in the correct section.  */
3597
3598 static boolean
3599 lang_one_common (h, info)
3600      struct bfd_link_hash_entry *h;
3601      PTR info;
3602 {
3603   unsigned int power_of_two;
3604   bfd_vma size;
3605   asection *section;
3606   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3607                                                 ldfile_output_machine);
3608
3609   if (h->type != bfd_link_hash_common)
3610     return true;
3611
3612   size = h->u.c.size;
3613   power_of_two = h->u.c.p->alignment_power;
3614
3615   if (config.sort_common
3616       && power_of_two < (unsigned int) *(int *) info)
3617     return true;
3618
3619   section = h->u.c.p->section;
3620
3621   /* Increase the size of the section.  */
3622   section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3623                                    (bfd_size_type) (1 << power_of_two)) * opb;
3624
3625   /* Adjust the alignment if necessary.  */
3626   if (power_of_two > section->alignment_power)
3627     section->alignment_power = power_of_two;
3628
3629   /* Change the symbol from common to defined.  */
3630   h->type = bfd_link_hash_defined;
3631   h->u.def.section = section;
3632   h->u.def.value = section->_cooked_size;
3633
3634   /* Increase the size of the section.  */
3635   section->_cooked_size += size;
3636
3637   /* Make sure the section is allocated in memory, and make sure that
3638      it is no longer a common section.  */
3639   section->flags |= SEC_ALLOC;
3640   section->flags &= ~SEC_IS_COMMON;
3641
3642   if (config.map_file != NULL)
3643     {
3644       static boolean header_printed;
3645       int len;
3646       char *name;
3647       char buf[50];
3648
3649       if (! header_printed)
3650         {
3651           minfo (_("\nAllocating common symbols\n"));
3652           minfo (_("Common symbol       size              file\n\n"));
3653           header_printed = true;
3654         }
3655
3656       name = demangle (h->root.string);
3657       minfo ("%s", name);
3658       len = strlen (name);
3659       free (name);
3660
3661       if (len >= 19)
3662         {
3663           print_nl ();
3664           len = 0;
3665         }
3666       while (len < 20)
3667         {
3668           print_space ();
3669           ++len;
3670         }
3671
3672       minfo ("0x");
3673       if (size <= 0xffffffff)
3674         sprintf (buf, "%lx", (unsigned long) size);
3675       else
3676         sprintf_vma (buf, size);
3677       minfo ("%s", buf);
3678       len = strlen (buf);
3679
3680       while (len < 16)
3681         {
3682           print_space ();
3683           ++len;
3684         }
3685
3686       minfo ("%B\n", section->owner);
3687     }
3688
3689   return true;
3690 }
3691
3692 /* Run through the input files and ensure that every input section has
3693    somewhere to go.  If one is found without a destination then create
3694    an input request and place it into the statement tree.  */
3695
3696 static void
3697 lang_place_orphans ()
3698 {
3699   LANG_FOR_EACH_INPUT_STATEMENT (file)
3700     {
3701       asection *s;
3702
3703       for (s = file->the_bfd->sections;
3704            s != (asection *) NULL;
3705            s = s->next)
3706         {
3707           if (s->output_section == (asection *) NULL)
3708             {
3709               /* This section of the file is not attatched, root
3710                  around for a sensible place for it to go.  */
3711
3712               if (file->just_syms_flag)
3713                 {
3714                   /* We are only retrieving symbol values from this
3715                      file.  We want the symbols to act as though the
3716                      values in the file are absolute.  */
3717                   s->output_section = bfd_abs_section_ptr;
3718                   s->output_offset = s->vma;
3719                 }
3720               else if (strcmp (s->name, "COMMON") == 0)
3721                 {
3722                   /* This is a lonely common section which must have
3723                      come from an archive.  We attach to the section
3724                      with the wildcard.  */
3725                   if (! link_info.relocateable
3726                       || command_line.force_common_definition)
3727                     {
3728                       if (default_common_section == NULL)
3729                         {
3730 #if 0
3731                           /* This message happens when using the
3732                              svr3.ifile linker script, so I have
3733                              disabled it.  */
3734                           info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3735 #endif
3736                           default_common_section =
3737                             lang_output_section_statement_lookup (".bss");
3738
3739                         }
3740                       wild_doit (&default_common_section->children, s,
3741                                  default_common_section, file);
3742                     }
3743                 }
3744               else if (ldemul_place_orphan (file, s))
3745                 ;
3746               else
3747                 {
3748                   lang_output_section_statement_type *os =
3749                   lang_output_section_statement_lookup (s->name);
3750
3751                   wild_doit (&os->children, s, os, file);
3752                 }
3753             }
3754         }
3755     }
3756 }
3757
3758 void
3759 lang_set_flags (ptr, flags, invert)
3760      lang_memory_region_type *ptr;
3761      const char *flags;
3762      int invert;
3763 {
3764   flagword *ptr_flags;
3765
3766   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3767   while (*flags)
3768     {
3769       switch (*flags)
3770         {
3771         case 'A': case 'a':
3772           *ptr_flags |= SEC_ALLOC;
3773           break;
3774
3775         case 'R': case 'r':
3776           *ptr_flags |= SEC_READONLY;
3777           break;
3778
3779         case 'W': case 'w':
3780           *ptr_flags |= SEC_DATA;
3781           break;
3782
3783         case 'X': case 'x':
3784           *ptr_flags |= SEC_CODE;
3785           break;
3786
3787         case 'L': case 'l':
3788         case 'I': case 'i':
3789           *ptr_flags |= SEC_LOAD;
3790           break;
3791
3792         default:
3793           einfo (_("%P%F: invalid syntax in flags\n"));
3794           break;
3795         }
3796       flags++;
3797     }
3798 }
3799
3800 /* Call a function on each input file.  This function will be called
3801    on an archive, but not on the elements.  */
3802
3803 void
3804 lang_for_each_input_file (func)
3805      void (*func) PARAMS ((lang_input_statement_type *));
3806 {
3807   lang_input_statement_type *f;
3808
3809   for (f = (lang_input_statement_type *) input_file_chain.head;
3810        f != NULL;
3811        f = (lang_input_statement_type *) f->next_real_file)
3812     func (f);
3813 }
3814
3815 /* Call a function on each file.  The function will be called on all
3816    the elements of an archive which are included in the link, but will
3817    not be called on the archive file itself.  */
3818
3819 void
3820 lang_for_each_file (func)
3821      void (*func) PARAMS ((lang_input_statement_type *));
3822 {
3823   LANG_FOR_EACH_INPUT_STATEMENT (f)
3824     {
3825       func (f);
3826     }
3827 }
3828
3829 #if 0
3830
3831 /* Not used.  */
3832
3833 void
3834 lang_for_each_input_section (func)
3835      void (*func) PARAMS ((bfd *ab, asection *as));
3836 {
3837   LANG_FOR_EACH_INPUT_STATEMENT (f)
3838     {
3839       asection *s;
3840
3841       for (s = f->the_bfd->sections;
3842            s != (asection *) NULL;
3843            s = s->next)
3844         {
3845           func (f->the_bfd, s);
3846         }
3847     }
3848 }
3849
3850 #endif
3851
3852 void
3853 ldlang_add_file (entry)
3854      lang_input_statement_type *entry;
3855 {
3856   bfd **pp;
3857
3858   lang_statement_append (&file_chain,
3859                          (lang_statement_union_type *) entry,
3860                          &entry->next);
3861
3862   /* The BFD linker needs to have a list of all input BFDs involved in
3863      a link.  */
3864   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3865   ASSERT (entry->the_bfd != output_bfd);
3866   for (pp = &link_info.input_bfds;
3867        *pp != (bfd *) NULL;
3868        pp = &(*pp)->link_next)
3869     ;
3870   *pp = entry->the_bfd;
3871   entry->the_bfd->usrdata = (PTR) entry;
3872   bfd_set_gp_size (entry->the_bfd, g_switch_value);
3873
3874   /* Look through the sections and check for any which should not be
3875      included in the link.  We need to do this now, so that we can
3876      notice when the backend linker tries to report multiple
3877      definition errors for symbols which are in sections we aren't
3878      going to link.  FIXME: It might be better to entirely ignore
3879      symbols which are defined in sections which are going to be
3880      discarded.  This would require modifying the backend linker for
3881      each backend which might set the SEC_LINK_ONCE flag.  If we do
3882      this, we should probably handle SEC_EXCLUDE in the same way.  */
3883
3884   bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3885 }
3886
3887 void
3888 lang_add_output (name, from_script)
3889      const char *name;
3890      int from_script;
3891 {
3892   /* Make -o on command line override OUTPUT in script.  */
3893   if (had_output_filename == false || !from_script)
3894     {
3895       output_filename = name;
3896       had_output_filename = true;
3897     }
3898 }
3899
3900 static lang_output_section_statement_type *current_section;
3901
3902 static int
3903 topower (x)
3904      int x;
3905 {
3906   unsigned int i = 1;
3907   int l;
3908
3909   if (x < 0)
3910     return -1;
3911
3912   for (l = 0; l < 32; l++)
3913     {
3914       if (i >= (unsigned int) x)
3915         return l;
3916       i <<= 1;
3917     }
3918
3919   return 0;
3920 }
3921
3922 lang_output_section_statement_type *
3923 lang_enter_output_section_statement (output_section_statement_name,
3924                                      address_exp, sectype, block_value,
3925                                      align, subalign, ebase)
3926      const char *output_section_statement_name;
3927      etree_type *address_exp;
3928      enum section_type sectype;
3929      bfd_vma block_value;
3930      etree_type *align;
3931      etree_type *subalign;
3932      etree_type *ebase;
3933 {
3934   lang_output_section_statement_type *os;
3935
3936   current_section =
3937    os =
3938     lang_output_section_statement_lookup (output_section_statement_name);
3939
3940   /* Add this statement to tree.  */
3941 #if 0
3942   add_statement (lang_output_section_statement_enum,
3943                  output_section_statement);
3944 #endif
3945   /* Make next things chain into subchain of this.  */
3946
3947   if (os->addr_tree == (etree_type *) NULL)
3948     {
3949       os->addr_tree = address_exp;
3950     }
3951   os->sectype = sectype;
3952   if (sectype != noload_section)
3953     os->flags = SEC_NO_FLAGS;
3954   else
3955     os->flags = SEC_NEVER_LOAD;
3956   os->block_value = block_value ? block_value : 1;
3957   stat_ptr = &os->children;
3958
3959   os->subsection_alignment =
3960     topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
3961   os->section_alignment =
3962     topower (exp_get_value_int (align, -1, "section alignment", 0));
3963
3964   os->load_base = ebase;
3965   return os;
3966 }
3967
3968 void
3969 lang_final ()
3970 {
3971   lang_output_statement_type *new =
3972     new_stat (lang_output_statement, stat_ptr);
3973
3974   new->name = output_filename;
3975 }
3976
3977 /* Reset the current counters in the regions.  */
3978
3979 static void
3980 reset_memory_regions ()
3981 {
3982   lang_memory_region_type *p = lang_memory_region_list;
3983
3984   for (p = lang_memory_region_list;
3985        p != (lang_memory_region_type *) NULL;
3986        p = p->next)
3987     {
3988       p->old_length = (bfd_size_type) (p->current - p->origin);
3989       p->current = p->origin;
3990     }
3991 }
3992
3993 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3994    as needed.  SECTION may be NULL, in which case it is a wild card.  */
3995
3996 static void
3997 gc_section_callback (ptr, section, file, data)
3998      lang_wild_statement_type *ptr;
3999      asection *section;
4000      lang_input_statement_type *file ATTRIBUTE_UNUSED;
4001      PTR data ATTRIBUTE_UNUSED;
4002 {
4003   /* If the wild pattern was marked KEEP, the member sections
4004      should be as well.  */
4005   if (ptr->keep_sections)
4006     section->flags |= SEC_KEEP;
4007 }
4008
4009 /* Handle a wild statement, marking it against GC.  SECTION or FILE or both
4010    may be NULL, indicating that it is a wildcard.  */
4011
4012 static void
4013 lang_gc_wild (s, section, file)
4014      lang_wild_statement_type *s;
4015      const char *section;
4016      const char *file;
4017 {
4018   walk_wild (s, section, file, gc_section_callback, NULL);
4019 }
4020
4021 /* Iterate over sections marking them against GC.  */
4022
4023 static void
4024 lang_gc_sections_1 (s)
4025      lang_statement_union_type *s;
4026 {
4027   for (; s != (lang_statement_union_type *) NULL; s = s->next)
4028     {
4029       switch (s->header.type)
4030         {
4031         case lang_wild_statement_enum:
4032           lang_gc_wild (&s->wild_statement,
4033                         s->wild_statement.section_name,
4034                         s->wild_statement.filename);
4035           break;
4036         case lang_constructors_statement_enum:
4037           lang_gc_sections_1 (constructor_list.head);
4038           break;
4039         case lang_output_section_statement_enum:
4040           lang_gc_sections_1 (s->output_section_statement.children.head);
4041           break;
4042         case lang_group_statement_enum:
4043           lang_gc_sections_1 (s->group_statement.children.head);
4044           break;
4045         default:
4046           break;
4047         }
4048     }
4049 }
4050
4051 static void
4052 lang_gc_sections ()
4053 {
4054   struct bfd_link_hash_entry *h;
4055   ldlang_undef_chain_list_type *ulist, fake_list_start;
4056
4057   /* Keep all sections so marked in the link script.  */
4058
4059   lang_gc_sections_1 (statement_list.head);
4060
4061   /* Keep all sections containing symbols undefined on the command-line.
4062      Handle the entry symbol at the same time.  */
4063
4064   if (entry_symbol != NULL)
4065     {
4066       fake_list_start.next = ldlang_undef_chain_list_head;
4067       fake_list_start.name = (char *) entry_symbol;
4068       ulist = &fake_list_start;
4069     }
4070   else
4071     ulist = ldlang_undef_chain_list_head;
4072
4073   for (; ulist; ulist = ulist->next)
4074     {
4075       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4076                                 false, false, false);
4077
4078       if (h != (struct bfd_link_hash_entry *) NULL
4079           && (h->type == bfd_link_hash_defined
4080               || h->type == bfd_link_hash_defweak)
4081           && ! bfd_is_abs_section (h->u.def.section))
4082         {
4083           h->u.def.section->flags |= SEC_KEEP;
4084         }
4085     }
4086
4087   bfd_gc_sections (output_bfd, &link_info);
4088 }
4089
4090 void
4091 lang_process ()
4092 {
4093   lang_reasonable_defaults ();
4094   current_target = default_target;
4095
4096   /* Open the output file.  */
4097   lang_for_each_statement (ldlang_open_output);
4098
4099   ldemul_create_output_section_statements ();
4100
4101   /* Add to the hash table all undefineds on the command line.  */
4102   lang_place_undefineds ();
4103
4104   already_linked_table_init ();
4105
4106   /* Create a bfd for each input file.  */
4107   current_target = default_target;
4108   open_input_bfds (statement_list.head, false);
4109
4110   ldemul_after_open ();
4111
4112   already_linked_table_free ();
4113
4114   /* Make sure that we're not mixing architectures.  We call this
4115      after all the input files have been opened, but before we do any
4116      other processing, so that any operations merge_private_bfd_data
4117      does on the output file will be known during the rest of the
4118      link.  */
4119   lang_check ();
4120
4121   /* Handle .exports instead of a version script if we're told to do so.  */
4122   if (command_line.version_exports_section)
4123     lang_do_version_exports_section ();
4124
4125   /* Build all sets based on the information gathered from the input
4126      files.  */
4127   ldctor_build_sets ();
4128
4129   /* Remove unreferenced sections if asked to.  */
4130   if (command_line.gc_sections)
4131     lang_gc_sections ();
4132
4133   /* If there were any SEC_MERGE sections, finish their merging, so that
4134      section sizes can be computed.  This has to be done after GC of sections,
4135      so that GCed sections are not merged, but before assigning output
4136      sections, since removing whole input sections is hard then.  */
4137   bfd_merge_sections (output_bfd, &link_info);
4138
4139   /* Size up the common data.  */
4140   lang_common ();
4141
4142   /* Run through the contours of the script and attach input sections
4143      to the correct output sections.  */
4144   map_input_to_output_sections (statement_list.head, (char *) NULL,
4145                                 (lang_output_section_statement_type *) NULL);
4146
4147   /* Find any sections not attached explicitly and handle them.  */
4148   lang_place_orphans ();
4149
4150   ldemul_before_allocation ();
4151
4152   /* We must record the program headers before we try to fix the
4153      section positions, since they will affect SIZEOF_HEADERS.  */
4154   lang_record_phdrs ();
4155
4156   /* Now run around and relax if we can.  */
4157   if (command_line.relax)
4158     {
4159       /* First time round is a trial run to get the 'worst case'
4160          addresses of the objects if there was no relaxing.  */
4161       lang_size_sections (statement_list.head,
4162                           abs_output_section,
4163                           &(statement_list.head), 0, (bfd_vma) 0, false);
4164
4165       /* Keep relaxing until bfd_relax_section gives up.  */
4166       do
4167         {
4168           reset_memory_regions ();
4169
4170           relax_again = false;
4171
4172           /* Note: pe-dll.c does something like this also.  If you find
4173              you need to change this code, you probably need to change
4174              pe-dll.c also.  DJ  */
4175
4176           /* Do all the assignments with our current guesses as to
4177              section sizes.  */
4178           lang_do_assignments (statement_list.head,
4179                                abs_output_section,
4180                                (fill_type) 0, (bfd_vma) 0);
4181
4182           /* Perform another relax pass - this time we know where the
4183              globals are, so can make better guess.  */
4184           lang_size_sections (statement_list.head,
4185                               abs_output_section,
4186                               &(statement_list.head), 0, (bfd_vma) 0, true);
4187         }
4188       while (relax_again);
4189     }
4190   else
4191     {
4192       /* Size up the sections.  */
4193       lang_size_sections (statement_list.head,
4194                           abs_output_section,
4195                           &(statement_list.head), 0, (bfd_vma) 0, false);
4196     }
4197
4198   /* See if anything special should be done now we know how big
4199      everything is.  */
4200   ldemul_after_allocation ();
4201
4202   /* Fix any .startof. or .sizeof. symbols.  */
4203   lang_set_startof ();
4204
4205   /* Do all the assignments, now that we know the final resting places
4206      of all the symbols.  */
4207
4208   lang_do_assignments (statement_list.head,
4209                        abs_output_section,
4210                        (fill_type) 0, (bfd_vma) 0);
4211
4212   /* Make sure that the section addresses make sense.  */
4213   if (! link_info.relocateable
4214       && command_line.check_section_addresses)
4215     lang_check_section_addresses ();
4216
4217   /* Final stuffs.  */
4218
4219   ldemul_finish ();
4220   lang_finish ();
4221 }
4222
4223 /* EXPORTED TO YACC */
4224
4225 void
4226 lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
4227                keep_sections, exclude_filename_list)
4228      const char *const section_name;
4229      boolean sections_sorted;
4230      const char *const filename;
4231      boolean filenames_sorted;
4232      boolean keep_sections;
4233      struct name_list *exclude_filename_list;
4234 {
4235   lang_wild_statement_type *new = new_stat (lang_wild_statement,
4236                                             stat_ptr);
4237
4238   if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
4239     {
4240       placed_commons = true;
4241     }
4242   if (filename != NULL && ! wildcardp (filename))
4243     {
4244       lang_has_input_file = true;
4245     }
4246   new->section_name = section_name;
4247   new->sections_sorted = sections_sorted;
4248   new->filename = filename;
4249   new->filenames_sorted = filenames_sorted;
4250   new->keep_sections = keep_sections;
4251   new->exclude_filename_list = exclude_filename_list;
4252   lang_list_init (&new->children);
4253 }
4254
4255 void
4256 lang_section_start (name, address)
4257      const char *name;
4258      etree_type *address;
4259 {
4260   lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
4261
4262   ad->section_name = name;
4263   ad->address = address;
4264 }
4265
4266 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
4267    because of a -e argument on the command line, or zero if this is
4268    called by ENTRY in a linker script.  Command line arguments take
4269    precedence.  */
4270
4271 void
4272 lang_add_entry (name, cmdline)
4273      const char *name;
4274      boolean cmdline;
4275 {
4276   if (entry_symbol == NULL
4277       || cmdline
4278       || ! entry_from_cmdline)
4279     {
4280       entry_symbol = name;
4281       entry_from_cmdline = cmdline;
4282     }
4283 }
4284
4285 void
4286 lang_add_target (name)
4287      const char *name;
4288 {
4289   lang_target_statement_type *new = new_stat (lang_target_statement,
4290                                               stat_ptr);
4291
4292   new->target = name;
4293
4294 }
4295
4296 void
4297 lang_add_map (name)
4298      const char *name;
4299 {
4300   while (*name)
4301     {
4302       switch (*name)
4303         {
4304         case 'F':
4305           map_option_f = true;
4306           break;
4307         }
4308       name++;
4309     }
4310 }
4311
4312 void
4313 lang_add_fill (exp)
4314      int exp;
4315 {
4316   lang_fill_statement_type *new = new_stat (lang_fill_statement,
4317                                             stat_ptr);
4318
4319   new->fill = exp;
4320 }
4321
4322 void
4323 lang_add_data (type, exp)
4324      int type;
4325      union etree_union *exp;
4326 {
4327
4328   lang_data_statement_type *new = new_stat (lang_data_statement,
4329                                             stat_ptr);
4330
4331   new->exp = exp;
4332   new->type = type;
4333
4334 }
4335
4336 /* Create a new reloc statement.  RELOC is the BFD relocation type to
4337    generate.  HOWTO is the corresponding howto structure (we could
4338    look this up, but the caller has already done so).  SECTION is the
4339    section to generate a reloc against, or NAME is the name of the
4340    symbol to generate a reloc against.  Exactly one of SECTION and
4341    NAME must be NULL.  ADDEND is an expression for the addend.  */
4342
4343 void
4344 lang_add_reloc (reloc, howto, section, name, addend)
4345      bfd_reloc_code_real_type reloc;
4346      reloc_howto_type *howto;
4347      asection *section;
4348      const char *name;
4349      union etree_union *addend;
4350 {
4351   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4352
4353   p->reloc = reloc;
4354   p->howto = howto;
4355   p->section = section;
4356   p->name = name;
4357   p->addend_exp = addend;
4358
4359   p->addend_value = 0;
4360   p->output_section = NULL;
4361   p->output_vma = 0;
4362 }
4363
4364 lang_assignment_statement_type *
4365 lang_add_assignment (exp)
4366      etree_type *exp;
4367 {
4368   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4369                                                   stat_ptr);
4370
4371   new->exp = exp;
4372   return new;
4373 }
4374
4375 void
4376 lang_add_attribute (attribute)
4377      enum statement_enum attribute;
4378 {
4379   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4380 }
4381
4382 void
4383 lang_startup (name)
4384      const char *name;
4385 {
4386   if (startup_file != (char *) NULL)
4387     {
4388       einfo (_("%P%Fmultiple STARTUP files\n"));
4389     }
4390   first_file->filename = name;
4391   first_file->local_sym_name = name;
4392   first_file->real = true;
4393
4394   startup_file = name;
4395 }
4396
4397 void
4398 lang_float (maybe)
4399      boolean maybe;
4400 {
4401   lang_float_flag = maybe;
4402 }
4403
4404 void
4405 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4406      bfd_vma fill;
4407      const char *memspec;
4408      struct lang_output_section_phdr_list *phdrs;
4409      const char *lma_memspec;
4410 {
4411   current_section->fill = fill;
4412   current_section->region = lang_memory_region_lookup (memspec);
4413   if (strcmp (lma_memspec, "*default*") != 0)
4414     {
4415       current_section->lma_region = lang_memory_region_lookup (lma_memspec);
4416       /* If no runtime region has been given, but the load region has
4417          been, use the load region.  */
4418       if (strcmp (memspec, "*default*") == 0)
4419         current_section->region = lang_memory_region_lookup (lma_memspec);
4420     }
4421   current_section->phdrs = phdrs;
4422   stat_ptr = &statement_list;
4423 }
4424
4425 /* Create an absolute symbol with the given name with the value of the
4426    address of first byte of the section named.
4427
4428    If the symbol already exists, then do nothing.  */
4429
4430 void
4431 lang_abs_symbol_at_beginning_of (secname, name)
4432      const char *secname;
4433      const char *name;
4434 {
4435   struct bfd_link_hash_entry *h;
4436
4437   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4438   if (h == (struct bfd_link_hash_entry *) NULL)
4439     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4440
4441   if (h->type == bfd_link_hash_new
4442       || h->type == bfd_link_hash_undefined)
4443     {
4444       asection *sec;
4445
4446       h->type = bfd_link_hash_defined;
4447
4448       sec = bfd_get_section_by_name (output_bfd, secname);
4449       if (sec == (asection *) NULL)
4450         h->u.def.value = 0;
4451       else
4452         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4453
4454       h->u.def.section = bfd_abs_section_ptr;
4455     }
4456 }
4457
4458 /* Create an absolute symbol with the given name with the value of the
4459    address of the first byte after the end of the section named.
4460
4461    If the symbol already exists, then do nothing.  */
4462
4463 void
4464 lang_abs_symbol_at_end_of (secname, name)
4465      const char *secname;
4466      const char *name;
4467 {
4468   struct bfd_link_hash_entry *h;
4469
4470   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4471   if (h == (struct bfd_link_hash_entry *) NULL)
4472     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4473
4474   if (h->type == bfd_link_hash_new
4475       || h->type == bfd_link_hash_undefined)
4476     {
4477       asection *sec;
4478
4479       h->type = bfd_link_hash_defined;
4480
4481       sec = bfd_get_section_by_name (output_bfd, secname);
4482       if (sec == (asection *) NULL)
4483         h->u.def.value = 0;
4484       else
4485         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4486                           + bfd_section_size (output_bfd, sec) /
4487                           bfd_octets_per_byte (output_bfd));
4488
4489       h->u.def.section = bfd_abs_section_ptr;
4490     }
4491 }
4492
4493 void
4494 lang_statement_append (list, element, field)
4495      lang_statement_list_type *list;
4496      lang_statement_union_type *element;
4497      lang_statement_union_type **field;
4498 {
4499   *(list->tail) = element;
4500   list->tail = field;
4501 }
4502
4503 /* Set the output format type.  -oformat overrides scripts.  */
4504
4505 void
4506 lang_add_output_format (format, big, little, from_script)
4507      const char *format;
4508      const char *big;
4509      const char *little;
4510      int from_script;
4511 {
4512   if (output_target == NULL || !from_script)
4513     {
4514       if (command_line.endian == ENDIAN_BIG
4515           && big != NULL)
4516         format = big;
4517       else if (command_line.endian == ENDIAN_LITTLE
4518                && little != NULL)
4519         format = little;
4520
4521       output_target = format;
4522     }
4523 }
4524
4525 /* Enter a group.  This creates a new lang_group_statement, and sets
4526    stat_ptr to build new statements within the group.  */
4527
4528 void
4529 lang_enter_group ()
4530 {
4531   lang_group_statement_type *g;
4532
4533   g = new_stat (lang_group_statement, stat_ptr);
4534   lang_list_init (&g->children);
4535   stat_ptr = &g->children;
4536 }
4537
4538 /* Leave a group.  This just resets stat_ptr to start writing to the
4539    regular list of statements again.  Note that this will not work if
4540    groups can occur inside anything else which can adjust stat_ptr,
4541    but currently they can't.  */
4542
4543 void
4544 lang_leave_group ()
4545 {
4546   stat_ptr = &statement_list;
4547 }
4548
4549 /* Add a new program header.  This is called for each entry in a PHDRS
4550    command in a linker script.  */
4551
4552 void
4553 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4554      const char *name;
4555      etree_type *type;
4556      boolean filehdr;
4557      boolean phdrs;
4558      etree_type *at;
4559      etree_type *flags;
4560 {
4561   struct lang_phdr *n, **pp;
4562
4563   n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4564   n->next = NULL;
4565   n->name = name;
4566   n->type = exp_get_value_int (type, 0, "program header type",
4567                                lang_final_phase_enum);
4568   n->filehdr = filehdr;
4569   n->phdrs = phdrs;
4570   n->at = at;
4571   n->flags = flags;
4572
4573   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4574     ;
4575   *pp = n;
4576 }
4577
4578 /* Record the program header information in the output BFD.  FIXME: We
4579    should not be calling an ELF specific function here.  */
4580
4581 static void
4582 lang_record_phdrs ()
4583 {
4584   unsigned int alc;
4585   asection **secs;
4586   struct lang_output_section_phdr_list *last;
4587   struct lang_phdr *l;
4588   lang_statement_union_type *u;
4589
4590   alc = 10;
4591   secs = (asection **) xmalloc (alc * sizeof (asection *));
4592   last = NULL;
4593   for (l = lang_phdr_list; l != NULL; l = l->next)
4594     {
4595       unsigned int c;
4596       flagword flags;
4597       bfd_vma at;
4598
4599       c = 0;
4600       for (u = lang_output_section_statement.head;
4601            u != NULL;
4602            u = u->output_section_statement.next)
4603         {
4604           lang_output_section_statement_type *os;
4605           struct lang_output_section_phdr_list *pl;
4606
4607           os = &u->output_section_statement;
4608
4609           pl = os->phdrs;
4610           if (pl != NULL)
4611             last = pl;
4612           else
4613             {
4614               if (os->sectype == noload_section
4615                   || os->bfd_section == NULL
4616                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
4617                 continue;
4618               pl = last;
4619             }
4620
4621           if (os->bfd_section == NULL)
4622             continue;
4623
4624           for (; pl != NULL; pl = pl->next)
4625             {
4626               if (strcmp (pl->name, l->name) == 0)
4627                 {
4628                   if (c >= alc)
4629                     {
4630                       alc *= 2;
4631                       secs = ((asection **)
4632                               xrealloc (secs, alc * sizeof (asection *)));
4633                     }
4634                   secs[c] = os->bfd_section;
4635                   ++c;
4636                   pl->used = true;
4637                 }
4638             }
4639         }
4640
4641       if (l->flags == NULL)
4642         flags = 0;
4643       else
4644         flags = exp_get_vma (l->flags, 0, "phdr flags",
4645                              lang_final_phase_enum);
4646
4647       if (l->at == NULL)
4648         at = 0;
4649       else
4650         at = exp_get_vma (l->at, 0, "phdr load address",
4651                           lang_final_phase_enum);
4652
4653       if (! bfd_record_phdr (output_bfd, l->type,
4654                              l->flags == NULL ? false : true,
4655                              flags,
4656                              l->at == NULL ? false : true,
4657                              at, l->filehdr, l->phdrs, c, secs))
4658         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4659     }
4660
4661   free (secs);
4662
4663   /* Make sure all the phdr assignments succeeded.  */
4664   for (u = lang_output_section_statement.head;
4665        u != NULL;
4666        u = u->output_section_statement.next)
4667     {
4668       struct lang_output_section_phdr_list *pl;
4669
4670       if (u->output_section_statement.bfd_section == NULL)
4671         continue;
4672
4673       for (pl = u->output_section_statement.phdrs;
4674            pl != NULL;
4675            pl = pl->next)
4676         if (! pl->used && strcmp (pl->name, "NONE") != 0)
4677           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4678                  u->output_section_statement.name, pl->name);
4679     }
4680 }
4681
4682 /* Record a list of sections which may not be cross referenced.  */
4683
4684 void
4685 lang_add_nocrossref (l)
4686      struct lang_nocrossref *l;
4687 {
4688   struct lang_nocrossrefs *n;
4689
4690   n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4691   n->next = nocrossref_list;
4692   n->list = l;
4693   nocrossref_list = n;
4694
4695   /* Set notice_all so that we get informed about all symbols.  */
4696   link_info.notice_all = true;
4697 }
4698 \f
4699 /* Overlay handling.  We handle overlays with some static variables.  */
4700
4701 /* The overlay virtual address.  */
4702 static etree_type *overlay_vma;
4703
4704 /* The overlay load address.  */
4705 static etree_type *overlay_lma;
4706
4707 /* Whether nocrossrefs is set for this overlay.  */
4708 static int overlay_nocrossrefs;
4709
4710 /* An expression for the maximum section size seen so far.  */
4711 static etree_type *overlay_max;
4712
4713 /* A list of all the sections in this overlay.  */
4714
4715 struct overlay_list {
4716   struct overlay_list *next;
4717   lang_output_section_statement_type *os;
4718 };
4719
4720 static struct overlay_list *overlay_list;
4721
4722 /* Start handling an overlay.  */
4723
4724 void
4725 lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4726      etree_type *vma_expr;
4727      etree_type *lma_expr;
4728      int nocrossrefs;
4729 {
4730   /* The grammar should prevent nested overlays from occurring.  */
4731   ASSERT (overlay_vma == NULL
4732           && overlay_lma == NULL
4733           && overlay_list == NULL
4734           && overlay_max == NULL);
4735
4736   overlay_vma = vma_expr;
4737   overlay_lma = lma_expr;
4738   overlay_nocrossrefs = nocrossrefs;
4739 }
4740
4741 /* Start a section in an overlay.  We handle this by calling
4742    lang_enter_output_section_statement with the correct VMA and LMA.  */
4743
4744 void
4745 lang_enter_overlay_section (name)
4746      const char *name;
4747 {
4748   struct overlay_list *n;
4749   etree_type *size;
4750
4751   lang_enter_output_section_statement (name, overlay_vma, normal_section,
4752                                        0, 0, 0, overlay_lma);
4753
4754   /* If this is the first section, then base the VMA and LMA of future
4755      sections on this one.  This will work correctly even if `.' is
4756      used in the addresses.  */
4757   if (overlay_list == NULL)
4758     {
4759       overlay_vma = exp_nameop (ADDR, name);
4760       overlay_lma = exp_nameop (LOADADDR, name);
4761     }
4762
4763   /* Remember the section.  */
4764   n = (struct overlay_list *) xmalloc (sizeof *n);
4765   n->os = current_section;
4766   n->next = overlay_list;
4767   overlay_list = n;
4768
4769   size = exp_nameop (SIZEOF, name);
4770
4771   /* Adjust the LMA for the next section.  */
4772   overlay_lma = exp_binop ('+', overlay_lma, size);
4773
4774   /* Arrange to work out the maximum section end address.  */
4775   if (overlay_max == NULL)
4776     overlay_max = size;
4777   else
4778     overlay_max = exp_binop (MAX_K, overlay_max, size);
4779 }
4780
4781 /* Finish a section in an overlay.  There isn't any special to do
4782    here.  */
4783
4784 void
4785 lang_leave_overlay_section (fill, phdrs)
4786      bfd_vma fill;
4787      struct lang_output_section_phdr_list *phdrs;
4788 {
4789   const char *name;
4790   char *clean, *s2;
4791   const char *s1;
4792   char *buf;
4793
4794   name = current_section->name;
4795
4796   lang_leave_output_section_statement (fill, "*default*",
4797                                        phdrs, "*default*");
4798
4799   /* Define the magic symbols.  */
4800
4801   clean = xmalloc (strlen (name) + 1);
4802   s2 = clean;
4803   for (s1 = name; *s1 != '\0'; s1++)
4804     if (isalnum ((unsigned char) *s1) || *s1 == '_')
4805       *s2++ = *s1;
4806   *s2 = '\0';
4807
4808   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4809   sprintf (buf, "__load_start_%s", clean);
4810   lang_add_assignment (exp_assop ('=', buf,
4811                                   exp_nameop (LOADADDR, name)));
4812
4813   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4814   sprintf (buf, "__load_stop_%s", clean);
4815   lang_add_assignment (exp_assop ('=', buf,
4816                                   exp_binop ('+',
4817                                              exp_nameop (LOADADDR, name),
4818                                              exp_nameop (SIZEOF, name))));
4819
4820   free (clean);
4821 }
4822
4823 /* Finish an overlay.  If there are any overlay wide settings, this
4824    looks through all the sections in the overlay and sets them.  */
4825
4826 void
4827 lang_leave_overlay (fill, memspec, phdrs, lma_memspec)
4828      bfd_vma fill;
4829      const char *memspec;
4830      struct lang_output_section_phdr_list *phdrs;
4831      const char *lma_memspec;
4832 {
4833   lang_memory_region_type *region;
4834   lang_memory_region_type *lma_region;
4835   struct overlay_list *l;
4836   struct lang_nocrossref *nocrossref;
4837
4838   if (memspec == NULL)
4839     region = NULL;
4840   else
4841     region = lang_memory_region_lookup (memspec);
4842
4843   if (lma_memspec == NULL)
4844     lma_region = NULL;
4845   else
4846     lma_region = lang_memory_region_lookup (lma_memspec);
4847
4848   nocrossref = NULL;
4849
4850   l = overlay_list;
4851   while (l != NULL)
4852     {
4853       struct overlay_list *next;
4854
4855       if (fill != 0 && l->os->fill == 0)
4856         l->os->fill = fill;
4857       if (region != NULL && l->os->region == NULL)
4858         l->os->region = region;
4859       /* We only set lma_region for the first overlay section, as
4860          subsequent overlay sections will have load_base set relative
4861          to the first section.  Also, don't set lma_region if
4862          load_base is specified.  FIXME:  There should really be a test
4863          that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4864          rather than letting LDADDR simply override LMA_REGION.  */
4865       if (lma_region != NULL && l->os->lma_region == NULL
4866           && l->next == NULL && l->os->load_base == NULL)
4867         l->os->lma_region = lma_region;
4868       if (phdrs != NULL && l->os->phdrs == NULL)
4869         l->os->phdrs = phdrs;
4870
4871       if (overlay_nocrossrefs)
4872         {
4873           struct lang_nocrossref *nc;
4874
4875           nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4876           nc->name = l->os->name;
4877           nc->next = nocrossref;
4878           nocrossref = nc;
4879         }
4880
4881       next = l->next;
4882       free (l);
4883       l = next;
4884     }
4885
4886   if (nocrossref != NULL)
4887     lang_add_nocrossref (nocrossref);
4888
4889   /* Update . for the end of the overlay.  */
4890   lang_add_assignment (exp_assop ('=', ".",
4891                                   exp_binop ('+', overlay_vma, overlay_max)));
4892
4893   overlay_vma = NULL;
4894   overlay_lma = NULL;
4895   overlay_nocrossrefs = 0;
4896   overlay_list = NULL;
4897   overlay_max = NULL;
4898 }
4899 \f
4900 /* Version handling.  This is only useful for ELF.  */
4901
4902 /* This global variable holds the version tree that we build.  */
4903
4904 struct bfd_elf_version_tree *lang_elf_version_info;
4905
4906 static int
4907 lang_vers_match_lang_c (expr, sym)
4908      struct bfd_elf_version_expr *expr;
4909      const char *sym;
4910 {
4911   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4912     return 1;
4913   return fnmatch (expr->pattern, sym, 0) == 0;
4914 }
4915
4916 static int
4917 lang_vers_match_lang_cplusplus (expr, sym)
4918      struct bfd_elf_version_expr *expr;
4919      const char *sym;
4920 {
4921   char *alt_sym;
4922   int result;
4923
4924   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4925     return 1;
4926
4927   alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
4928   if (!alt_sym)
4929     {
4930       /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4931          Should we early out false in this case?  */
4932       result = fnmatch (expr->pattern, sym, 0) == 0;
4933     }
4934   else
4935     {
4936       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4937       free (alt_sym);
4938     }
4939
4940   return result;
4941 }
4942
4943 static int
4944 lang_vers_match_lang_java (expr, sym)
4945      struct bfd_elf_version_expr *expr;
4946      const char *sym;
4947 {
4948   char *alt_sym;
4949   int result;
4950
4951   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4952     return 1;
4953
4954   alt_sym = cplus_demangle (sym, DMGL_JAVA);
4955   if (!alt_sym)
4956     {
4957       /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4958          Should we early out false in this case?  */
4959       result = fnmatch (expr->pattern, sym, 0) == 0;
4960     }
4961   else
4962     {
4963       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4964       free (alt_sym);
4965     }
4966
4967   return result;
4968 }
4969
4970 /* This is called for each variable name or match expression.  */
4971
4972 struct bfd_elf_version_expr *
4973 lang_new_vers_regex (orig, new, lang)
4974      struct bfd_elf_version_expr *orig;
4975      const char *new;
4976      const char *lang;
4977 {
4978   struct bfd_elf_version_expr *ret;
4979
4980   ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4981   ret->next = orig;
4982   ret->pattern = new;
4983
4984   if (lang == NULL || strcasecmp (lang, "C") == 0)
4985     ret->match = lang_vers_match_lang_c;
4986   else if (strcasecmp (lang, "C++") == 0)
4987     ret->match = lang_vers_match_lang_cplusplus;
4988   else if (strcasecmp (lang, "Java") == 0)
4989     ret->match = lang_vers_match_lang_java;
4990   else
4991     {
4992       einfo (_("%X%P: unknown language `%s' in version information\n"),
4993              lang);
4994       ret->match = lang_vers_match_lang_c;
4995     }
4996
4997   return ret;
4998 }
4999
5000 /* This is called for each set of variable names and match
5001    expressions.  */
5002
5003 struct bfd_elf_version_tree *
5004 lang_new_vers_node (globals, locals)
5005      struct bfd_elf_version_expr *globals;
5006      struct bfd_elf_version_expr *locals;
5007 {
5008   struct bfd_elf_version_tree *ret;
5009
5010   ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5011   ret->next = NULL;
5012   ret->name = NULL;
5013   ret->vernum = 0;
5014   ret->globals = globals;
5015   ret->locals = locals;
5016   ret->deps = NULL;
5017   ret->name_indx = (unsigned int) -1;
5018   ret->used = 0;
5019   return ret;
5020 }
5021
5022 /* This static variable keeps track of version indices.  */
5023
5024 static int version_index;
5025
5026 /* This is called when we know the name and dependencies of the
5027    version.  */
5028
5029 void
5030 lang_register_vers_node (name, version, deps)
5031      const char *name;
5032      struct bfd_elf_version_tree *version;
5033      struct bfd_elf_version_deps *deps;
5034 {
5035   struct bfd_elf_version_tree *t, **pp;
5036   struct bfd_elf_version_expr *e1;
5037
5038   /* Make sure this node has a unique name.  */
5039   for (t = lang_elf_version_info; t != NULL; t = t->next)
5040     if (strcmp (t->name, name) == 0)
5041       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5042
5043   /* Check the global and local match names, and make sure there
5044      aren't any duplicates.  */
5045
5046   for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5047     {
5048       for (t = lang_elf_version_info; t != NULL; t = t->next)
5049         {
5050           struct bfd_elf_version_expr *e2;
5051
5052           for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5053             if (strcmp (e1->pattern, e2->pattern) == 0)
5054               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5055                      e1->pattern);
5056         }
5057     }
5058
5059   for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5060     {
5061       for (t = lang_elf_version_info; t != NULL; t = t->next)
5062         {
5063           struct bfd_elf_version_expr *e2;
5064
5065           for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5066             if (strcmp (e1->pattern, e2->pattern) == 0)
5067               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5068                      e1->pattern);
5069         }
5070     }
5071
5072   version->deps = deps;
5073   version->name = name;
5074   ++version_index;
5075   version->vernum = version_index;
5076
5077   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5078     ;
5079   *pp = version;
5080 }
5081
5082 /* This is called when we see a version dependency.  */
5083
5084 struct bfd_elf_version_deps *
5085 lang_add_vers_depend (list, name)
5086      struct bfd_elf_version_deps *list;
5087      const char *name;
5088 {
5089   struct bfd_elf_version_deps *ret;
5090   struct bfd_elf_version_tree *t;
5091
5092   ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5093   ret->next = list;
5094
5095   for (t = lang_elf_version_info; t != NULL; t = t->next)
5096     {
5097       if (strcmp (t->name, name) == 0)
5098         {
5099           ret->version_needed = t;
5100           return ret;
5101         }
5102     }
5103
5104   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5105
5106   return ret;
5107 }
5108
5109 static void
5110 lang_do_version_exports_section ()
5111 {
5112   struct bfd_elf_version_expr *greg = NULL, *lreg;
5113
5114   LANG_FOR_EACH_INPUT_STATEMENT (is)
5115     {
5116       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5117       char *contents, *p;
5118       bfd_size_type len;
5119
5120       if (sec == NULL)
5121         continue;
5122
5123       len = bfd_section_size (is->the_bfd, sec);
5124       contents = xmalloc (len);
5125       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5126         einfo (_("%X%P: unable to read .exports section contents"), sec);
5127
5128       p = contents;
5129       while (p < contents + len)
5130         {
5131           greg = lang_new_vers_regex (greg, p, NULL);
5132           p = strchr (p, '\0') + 1;
5133         }
5134
5135       /* Do not free the contents, as we used them creating the regex.  */
5136
5137       /* Do not include this section in the link.  */
5138       bfd_set_section_flags (is->the_bfd, sec,
5139         bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5140     }
5141
5142   lreg = lang_new_vers_regex (NULL, "*", NULL);
5143   lang_register_vers_node (command_line.version_exports_section,
5144                            lang_new_vers_node (greg, lreg), NULL);
5145 }
5146
5147 void
5148 lang_add_unique (name)
5149      const char *name;
5150 {
5151   struct unique_sections *ent;
5152
5153   for (ent = unique_section_list; ent; ent = ent->next)
5154     if (strcmp (ent->name, name) == 0)
5155       return;
5156
5157   ent = (struct unique_sections *) xmalloc (sizeof *ent);
5158   ent->name = xstrdup (name);
5159   ent->next = unique_section_list;
5160   unique_section_list = ent;
5161 }