ld/ldlang.c

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