ld/ldlang.c

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