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