ld/ldlang.c

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