ld/ldlang.c

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