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