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