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   int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2172                                            ldfile_output_machine);
2173   if (size != 0)
2174     {
2175       print_space ();
2176
2177       minfo ("%s", i->name);
2178
2179       if (i->output_section != NULL)
2180         {
2181           int len;
2182
2183           len = 1 + strlen (i->name);
2184           if (len >= SECTION_NAME_MAP_LENGTH - 1)
2185             {
2186               print_nl ();
2187               len = 0;
2188             }
2189           while (len < SECTION_NAME_MAP_LENGTH)
2190             {
2191               print_space ();
2192               ++len;
2193             }
2194
2195           minfo ("0x%V %W %B\n",
2196                  i->output_section->vma + i->output_offset, size / opb,
2197                  i->owner);
2198
2199           if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2200             {
2201               len = SECTION_NAME_MAP_LENGTH + 3;
2202 #ifdef BFD64
2203               len += 16;
2204 #else
2205               len += 8;
2206 #endif
2207               while (len > 0)
2208                 {
2209                   print_space ();
2210                   --len;
2211                 }
2212
2213               minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2214             }
2215
2216           bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2217
2218           print_dot = i->output_section->vma + i->output_offset + size / opb;
2219         }
2220     }
2221 }
2222
2223 static void
2224 print_fill_statement (fill)
2225      lang_fill_statement_type * fill;
2226 {
2227   fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
2228 }
2229
2230 static void
2231 print_data_statement (data)
2232      lang_data_statement_type * data;
2233 {
2234   int i;
2235   bfd_vma addr;
2236   bfd_size_type size;
2237   const char *name;
2238   int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2239                                            ldfile_output_machine);
2240
2241   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2242     print_space ();
2243
2244   addr = data->output_vma;
2245   if (data->output_section != NULL)
2246     addr += data->output_section->vma;
2247
2248   switch (data->type)
2249     {
2250     default:
2251       abort ();
2252     case BYTE:
2253       size = BYTE_SIZE;
2254       name = "BYTE";
2255       break;
2256     case SHORT:
2257       size = SHORT_SIZE;
2258       name = "SHORT";
2259       break;
2260     case LONG:
2261       size = LONG_SIZE;
2262       name = "LONG";
2263       break;
2264     case QUAD:
2265       size = QUAD_SIZE;
2266       name = "QUAD";
2267       break;
2268     case SQUAD:
2269       size = QUAD_SIZE;
2270       name = "SQUAD";
2271       break;
2272     }
2273
2274   minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2275
2276   if (data->exp->type.node_class != etree_value)
2277     {
2278       print_space ();
2279       exp_print_tree (data->exp);
2280     }
2281
2282   print_nl ();
2283
2284   print_dot = addr + size / opb;
2285
2286 }
2287
2288 /* Print an address statement.  These are generated by options like
2289    -Ttext.  */
2290
2291 static void
2292 print_address_statement (address)
2293      lang_address_statement_type *address;
2294 {
2295   minfo (_("Address of section %s set to "), address->section_name);
2296   exp_print_tree (address->address);
2297   print_nl ();
2298 }
2299
2300 /* Print a reloc statement.  */
2301
2302 static void
2303 print_reloc_statement (reloc)
2304      lang_reloc_statement_type *reloc;
2305 {
2306   int i;
2307   bfd_vma addr;
2308   bfd_size_type size;
2309   int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2310                                            ldfile_output_machine);
2311
2312   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2313     print_space ();
2314
2315   addr = reloc->output_vma;
2316   if (reloc->output_section != NULL)
2317     addr += reloc->output_section->vma;
2318
2319   size = bfd_get_reloc_size (reloc->howto);
2320
2321   minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2322
2323   if (reloc->name != NULL)
2324     minfo ("%s+", reloc->name);
2325   else
2326     minfo ("%s+", reloc->section->name);
2327
2328   exp_print_tree (reloc->addend_exp);
2329
2330   print_nl ();
2331
2332   print_dot = addr + size / opb;
2333 }
2334
2335 static void
2336 print_padding_statement (s)
2337      lang_padding_statement_type *s;
2338 {
2339   int len;
2340   bfd_vma addr;
2341   int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2342                                            ldfile_output_machine);
2343
2344   minfo (" *fill*");
2345
2346   len = sizeof " *fill*" - 1;
2347   while (len < SECTION_NAME_MAP_LENGTH)
2348     {
2349       print_space ();
2350       ++len;
2351     }
2352
2353   addr = s->output_offset;
2354   if (s->output_section != NULL)
2355     addr += s->output_section->vma;
2356   minfo ("0x%V %W", addr, s->size);
2357
2358   if (s->fill != 0)
2359     minfo (" %u", s->fill);
2360
2361   print_nl ();
2362
2363   print_dot = addr + s->size / opb;
2364 }
2365
2366 static void
2367 print_wild_statement (w, os)
2368      lang_wild_statement_type * w;
2369      lang_output_section_statement_type * os;
2370 {
2371   print_space ();
2372
2373   if (w->filenames_sorted)
2374     minfo ("SORT(");
2375   if (w->exclude_filename_list != NULL)
2376     {
2377       name_list *tmp;
2378       minfo ("EXCLUDE_FILE ( %s", w->exclude_filename_list->name);
2379       for (tmp=w->exclude_filename_list->next; tmp; tmp = tmp->next)
2380         minfo (", %s", tmp->name);
2381       minfo (")");
2382      }
2383    if (w->filename != NULL)
2384     minfo ("%s", w->filename);
2385   else
2386     minfo ("*");
2387   if (w->filenames_sorted)
2388     minfo (")");
2389
2390   minfo ("(");
2391   if (w->sections_sorted)
2392     minfo ("SORT(");
2393   if (w->section_name != NULL)
2394     minfo ("%s", w->section_name);
2395   else
2396     minfo ("*");
2397   if (w->sections_sorted)
2398     minfo (")");
2399   minfo (")");
2400
2401   print_nl ();
2402
2403   print_statement_list (w->children.head, os);
2404 }
2405
2406 /* Print a group statement.  */
2407
2408 static void
2409 print_group (s, os)
2410      lang_group_statement_type *s;
2411      lang_output_section_statement_type *os;
2412 {
2413   fprintf (config.map_file, "START GROUP\n");
2414   print_statement_list (s->children.head, os);
2415   fprintf (config.map_file, "END GROUP\n");
2416 }
2417
2418 /* Print the list of statements in S.
2419    This can be called for any statement type.  */
2420
2421 static void
2422 print_statement_list (s, os)
2423      lang_statement_union_type *s;
2424      lang_output_section_statement_type *os;
2425 {
2426   while (s != NULL)
2427     {
2428       print_statement (s, os);
2429       s = s->next;
2430     }
2431 }
2432
2433 /* Print the first statement in statement list S.
2434    This can be called for any statement type.  */
2435
2436 static void
2437 print_statement (s, os)
2438      lang_statement_union_type *s;
2439      lang_output_section_statement_type *os;
2440 {
2441   switch (s->header.type)
2442     {
2443     default:
2444       fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2445       FAIL ();
2446       break;
2447     case lang_constructors_statement_enum:
2448       if (constructor_list.head != NULL)
2449         {
2450           if (constructors_sorted)
2451             minfo (" SORT (CONSTRUCTORS)\n");
2452           else
2453             minfo (" CONSTRUCTORS\n");
2454           print_statement_list (constructor_list.head, os);
2455         }
2456       break;
2457     case lang_wild_statement_enum:
2458       print_wild_statement (&s->wild_statement, os);
2459       break;
2460     case lang_address_statement_enum:
2461       print_address_statement (&s->address_statement);
2462       break;
2463     case lang_object_symbols_statement_enum:
2464       minfo (" CREATE_OBJECT_SYMBOLS\n");
2465       break;
2466     case lang_fill_statement_enum:
2467       print_fill_statement (&s->fill_statement);
2468       break;
2469     case lang_data_statement_enum:
2470       print_data_statement (&s->data_statement);
2471       break;
2472     case lang_reloc_statement_enum:
2473       print_reloc_statement (&s->reloc_statement);
2474       break;
2475     case lang_input_section_enum:
2476       print_input_section (&s->input_section);
2477       break;
2478     case lang_padding_statement_enum:
2479       print_padding_statement (&s->padding_statement);
2480       break;
2481     case lang_output_section_statement_enum:
2482       print_output_section_statement (&s->output_section_statement);
2483       break;
2484     case lang_assignment_statement_enum:
2485       print_assignment (&s->assignment_statement, os);
2486       break;
2487     case lang_target_statement_enum:
2488       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2489       break;
2490     case lang_output_statement_enum:
2491       minfo ("OUTPUT(%s", s->output_statement.name);
2492       if (output_target != NULL)
2493         minfo (" %s", output_target);
2494       minfo (")\n");
2495       break;
2496     case lang_input_statement_enum:
2497       print_input_statement (&s->input_statement);
2498       break;
2499     case lang_group_statement_enum:
2500       print_group (&s->group_statement, os);
2501       break;
2502     case lang_afile_asection_pair_statement_enum:
2503       FAIL ();
2504       break;
2505     }
2506 }
2507
2508 static void
2509 print_statements ()
2510 {
2511   print_statement_list (statement_list.head, abs_output_section);
2512 }
2513
2514 /* Print the first N statements in statement list S to STDERR.
2515    If N == 0, nothing is printed.
2516    If N < 0, the entire list is printed.
2517    Intended to be called from GDB.  */
2518
2519 void
2520 dprint_statement (s, n)
2521      lang_statement_union_type * s;
2522      int n;
2523 {
2524   FILE *map_save = config.map_file;
2525
2526   config.map_file = stderr;
2527
2528   if (n < 0)
2529     print_statement_list (s, abs_output_section);
2530   else
2531     {
2532       while (s && --n >= 0)
2533         {
2534           print_statement (s, abs_output_section);
2535           s = s->next;
2536         }
2537     }
2538
2539   config.map_file = map_save;
2540 }
2541
2542 static bfd_vma
2543 insert_pad (this_ptr, fill, power, output_section_statement, dot)
2544      lang_statement_union_type ** this_ptr;
2545      fill_type fill;
2546      unsigned int power;
2547      asection * output_section_statement;
2548      bfd_vma dot;
2549 {
2550   /* Align this section first to the
2551      input sections requirement, then
2552      to the output section's requirement.
2553      If this alignment is > than any seen before,
2554      then record it too. Perform the alignment by
2555      inserting a magic 'padding' statement.
2556      */
2557
2558   int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2559                                            ldfile_output_machine);
2560   unsigned int alignment_needed = align_power (dot, power) - dot;
2561
2562   if (alignment_needed != 0)
2563     {
2564       lang_statement_union_type *new =
2565         ((lang_statement_union_type *)
2566          stat_alloc (sizeof (lang_padding_statement_type)));
2567
2568       /* Link into existing chain */
2569       new->header.next = *this_ptr;
2570       *this_ptr = new;
2571       new->header.type = lang_padding_statement_enum;
2572       new->padding_statement.output_section = output_section_statement;
2573       new->padding_statement.output_offset =
2574         dot - output_section_statement->vma;
2575       new->padding_statement.fill = fill;
2576       new->padding_statement.size = alignment_needed * opb;
2577     }
2578
2579
2580   /* Remember the most restrictive alignment */
2581   if (power > output_section_statement->alignment_power)
2582     {
2583       output_section_statement->alignment_power = power;
2584     }
2585   output_section_statement->_raw_size += alignment_needed * opb;
2586
2587   return dot + alignment_needed;
2588 }
2589
2590 /* Work out how much this section will move the dot point */
2591 static bfd_vma
2592 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2593      lang_statement_union_type ** this_ptr;
2594      lang_output_section_statement_type * output_section_statement;
2595      fill_type fill;
2596      bfd_vma dot;
2597      boolean relax ATTRIBUTE_UNUSED;
2598 {
2599   lang_input_section_type *is = &((*this_ptr)->input_section);
2600   asection *i = is->section;
2601   int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2602                                            ldfile_output_machine);
2603
2604   if (is->ifile->just_syms_flag == false)
2605     {
2606       if (output_section_statement->subsection_alignment != -1)
2607        i->alignment_power =
2608         output_section_statement->subsection_alignment;
2609
2610       dot = insert_pad (this_ptr, fill, i->alignment_power,
2611                         output_section_statement->bfd_section, dot);
2612
2613       /* Remember where in the output section this input section goes */
2614
2615       i->output_offset = dot - output_section_statement->bfd_section->vma;
2616
2617       /* Mark how big the output section must be to contain this now
2618          */
2619       if (i->_cooked_size != 0)
2620         dot += i->_cooked_size / opb;
2621       else
2622         dot += i->_raw_size / opb;
2623       output_section_statement->bfd_section->_raw_size =
2624         (dot - output_section_statement->bfd_section->vma) * opb;
2625     }
2626   else
2627     {
2628       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2629     }
2630
2631   return dot;
2632 }
2633
2634 #define IGNORE_SECTION(bfd, s) \
2635   (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) != (SEC_ALLOC | SEC_LOAD)) \
2636    || bfd_section_size (bfd, s) == 0)
2637
2638 /* Check to see if any allocated sections overlap with other allocated
2639    sections.  This can happen when the linker script specifically specifies
2640    the output section addresses of the two sections.  */
2641 static void
2642 lang_check_section_addresses ()
2643 {
2644   asection * s;
2645   int opb = bfd_octets_per_byte (output_bfd);
2646
2647   /* Scan all sections in the output list.  */
2648   for (s = output_bfd->sections; s != NULL; s = s->next)
2649     {
2650       asection * os;
2651
2652       /* Ignore sections which are not loaded or which have no contents.  */
2653       if (IGNORE_SECTION (output_bfd, s))
2654         continue;
2655
2656       /* Once we reach section 's' stop our seach.  This prevents two
2657          warning messages from being produced, one for 'section A overlaps
2658          section B' and one for 'section B overlaps section A'.  */
2659       for (os = output_bfd->sections; os != s; os = os->next)
2660         {
2661           bfd_vma s_start;
2662           bfd_vma s_end;
2663           bfd_vma os_start;
2664           bfd_vma os_end;
2665
2666           /* Only consider loadable sections with real contents.  */
2667           if (IGNORE_SECTION (output_bfd, os))
2668             continue;
2669
2670           /* We must check the sections' LMA addresses not their
2671              VMA addresses because overlay sections can have
2672              overlapping VMAs but they must have distinct LMAs.  */
2673           s_start  = bfd_section_lma (output_bfd, s);
2674           os_start = bfd_section_lma (output_bfd, os);
2675           s_end    = s_start  + bfd_section_size (output_bfd, s) - 1;
2676           os_end   = os_start + bfd_section_size (output_bfd, os) - 1;
2677
2678           /* Look for an overlap.  */
2679           if ((s_end < os_start) || (s_start > os_end))
2680             continue;
2681
2682           einfo (
2683 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2684                  s->name, s_start, s_end, os->name, os_start, os_end);
2685
2686           /* Once we have found one overlap for this section,
2687              stop looking for others.  */
2688           break;
2689         }
2690     }
2691 }
2692
2693 /* This variable indicates whether bfd_relax_section should be called
2694    again.  */
2695
2696 static boolean relax_again;
2697
2698 /* Set the sizes for all the output sections.  */
2699
2700 bfd_vma
2701 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2702      lang_statement_union_type * s;
2703      lang_output_section_statement_type * output_section_statement;
2704      lang_statement_union_type ** prev;
2705      fill_type fill;
2706      bfd_vma dot;
2707      boolean relax;
2708 {
2709   int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2710                                            ldfile_output_machine);
2711
2712   /* Size up the sections from their constituent parts.  */
2713   for (; s != (lang_statement_union_type *) NULL; s = s->next)
2714     {
2715       switch (s->header.type)
2716         {
2717         case lang_output_section_statement_enum:
2718           {
2719             bfd_vma after;
2720             lang_output_section_statement_type *os = &s->output_section_statement;
2721
2722             if (os->bfd_section == NULL)
2723               /* This section was never actually created.  */
2724               break;
2725
2726             /* If this is a COFF shared library section, use the size and
2727                address from the input section.  FIXME: This is COFF
2728                specific; it would be cleaner if there were some other way
2729                to do this, but nothing simple comes to mind.  */
2730             if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2731               {
2732                 asection * input;
2733
2734                 if (os->children.head == NULL
2735                     || os->children.head->next != NULL
2736                     || os->children.head->header.type != lang_input_section_enum)
2737                   einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2738                          os->name);
2739
2740                 input = os->children.head->input_section.section;
2741                 bfd_set_section_vma (os->bfd_section->owner,
2742                                      os->bfd_section,
2743                                      bfd_section_vma (input->owner, input));
2744                 os->bfd_section->_raw_size = input->_raw_size;
2745                 break;
2746               }
2747
2748             if (bfd_is_abs_section (os->bfd_section))
2749               {
2750                 /* No matter what happens, an abs section starts at zero.  */
2751                 ASSERT (os->bfd_section->vma == 0);
2752               }
2753             else
2754               {
2755                 if (os->addr_tree == (etree_type *) NULL)
2756                   {
2757                     /* No address specified for this section, get one
2758                        from the region specification.  */
2759                     if (os->region == (lang_memory_region_type *) NULL
2760                         || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2761                               & (SEC_ALLOC | SEC_LOAD)) != 0)
2762                             && os->region->name[0] == '*'
2763                             && strcmp (os->region->name, "*default*") == 0))
2764                       {
2765                         os->region = lang_memory_default (os->bfd_section);
2766                       }
2767
2768                     /* If a loadable section is using the default memory
2769                        region, and some non default memory regions were
2770                        defined, issue a warning.  */
2771                     if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2772                          & (SEC_ALLOC | SEC_LOAD)) != 0
2773                         && ! link_info.relocateable
2774                         && strcmp (os->region->name, "*default*") == 0
2775                         && lang_memory_region_list != NULL
2776                         && (strcmp (lang_memory_region_list->name, "*default*") != 0
2777                             || lang_memory_region_list->next != NULL))
2778                       einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2779                              bfd_get_section_name (output_bfd, os->bfd_section));
2780
2781                     dot = os->region->current;
2782
2783                     if (os->section_alignment == -1)
2784                       {
2785                         bfd_vma olddot;
2786
2787                         olddot = dot;
2788                         dot = align_power (dot, os->bfd_section->alignment_power);
2789
2790                         if (dot != olddot && config.warn_section_align)
2791                           einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2792                                  os->name, (unsigned int) (dot - olddot));
2793                       }
2794                   }
2795                 else
2796                   {
2797                     etree_value_type r;
2798
2799                     r = exp_fold_tree (os->addr_tree,
2800                                        abs_output_section,
2801                                        lang_allocating_phase_enum,
2802                                        dot, &dot);
2803                     if (r.valid_p == false)
2804                       {
2805                         einfo (_("%F%S: non constant address expression for section %s\n"),
2806                                os->name);
2807                       }
2808                     dot = r.value + r.section->bfd_section->vma;
2809                   }
2810
2811                 /* The section starts here.
2812                    First, align to what the section needs.  */
2813
2814                 if (os->section_alignment != -1)
2815                   dot = align_power (dot, os->section_alignment);
2816
2817                 bfd_set_section_vma (0, os->bfd_section, dot);
2818
2819                 os->bfd_section->output_offset = 0;
2820               }
2821
2822             (void) lang_size_sections (os->children.head, os, &os->children.head,
2823                                        os->fill, dot, relax);
2824
2825             /* put the section within the requested block size, or align at
2826                the block boundary */
2827             after = ALIGN_N (os->bfd_section->vma,
2828                              os->bfd_section->_raw_size / opb,
2829                              /* The coercion here is important, see ld.h.  */
2830                              (bfd_vma) os->block_value);
2831
2832             if (bfd_is_abs_section (os->bfd_section))
2833               ASSERT (after == os->bfd_section->vma);
2834             else
2835               os->bfd_section->_raw_size =
2836                 (after - os->bfd_section->vma) * opb;
2837             dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
2838             os->processed = true;
2839
2840             /* Update dot in the region ?
2841                We only do this if the section is going to be allocated,
2842                since unallocated sections do not contribute to the region's
2843                overall size in memory.
2844
2845                If the SEC_NEVER_LOAD bit is not set, it will affect the
2846                addresses of sections after it. We have to update
2847                dot.  */
2848             if (os->region != (lang_memory_region_type *) NULL
2849                 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
2850                      & SEC_NEVER_LOAD) == 0
2851                     || (bfd_get_section_flags (output_bfd, os->bfd_section)
2852                         & (SEC_ALLOC | SEC_LOAD))))
2853               {
2854                 os->region->current = dot;
2855
2856                 /* Make sure the new address is within the region.  We
2857                    explicitly permit the current address to be at the
2858                    exact end of the region when the VMA is non-zero,
2859                    in case the region is at the end of addressable
2860                    memory and the calculation wraps around.  */
2861                 if ((os->region->current < os->region->origin
2862                      || (os->region->current - os->region->origin
2863                          > os->region->length))
2864                     && ((os->region->current
2865                          != os->region->origin + os->region->length)
2866                         || os->bfd_section->vma == 0))
2867
2868                   {
2869                     if (os->addr_tree != (etree_type *) NULL)
2870                       {
2871                         einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2872                                os->region->current,
2873                                os->bfd_section->owner,
2874                                os->bfd_section->name,
2875                                os->region->name);
2876                       }
2877                     else
2878                       {
2879                         einfo (_("%X%P: region %s is full (%B section %s)\n"),
2880                                os->region->name,
2881                                os->bfd_section->owner,
2882                                os->bfd_section->name);
2883                       }
2884                     /* Reset the region pointer.  */
2885                     os->region->current = os->region->origin;
2886                   }
2887               }
2888           }
2889           break;
2890
2891         case lang_constructors_statement_enum:
2892           dot = lang_size_sections (constructor_list.head,
2893                                     output_section_statement,
2894                                     &s->wild_statement.children.head,
2895                                     fill,
2896                                     dot, relax);
2897           break;
2898
2899         case lang_data_statement_enum:
2900           {
2901             unsigned int size = 0;
2902
2903             s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
2904             s->data_statement.output_section =
2905               output_section_statement->bfd_section;
2906
2907             switch (s->data_statement.type)
2908               {
2909               case QUAD:
2910               case SQUAD:
2911                 size = QUAD_SIZE;
2912                 break;
2913               case LONG:
2914                 size = LONG_SIZE;
2915                 break;
2916               case SHORT:
2917                 size = SHORT_SIZE;
2918                 break;
2919               case BYTE:
2920                 size = BYTE_SIZE;
2921                 break;
2922               }
2923             if (size < opb)
2924               size = opb;
2925             dot += size / opb;
2926             output_section_statement->bfd_section->_raw_size += size;
2927             /* The output section gets contents, and then we inspect for
2928                any flags set in the input script which override any ALLOC.  */
2929             output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
2930             if (!(output_section_statement->flags & SEC_NEVER_LOAD)) {
2931               output_section_statement->bfd_section->flags |= SEC_ALLOC | SEC_LOAD;
2932             }
2933           }
2934           break;
2935
2936         case lang_reloc_statement_enum:
2937           {
2938             int size;
2939
2940             s->reloc_statement.output_vma =
2941               dot - output_section_statement->bfd_section->vma;
2942             s->reloc_statement.output_section =
2943               output_section_statement->bfd_section;
2944             size = bfd_get_reloc_size (s->reloc_statement.howto);
2945             dot += size / opb;
2946             output_section_statement->bfd_section->_raw_size += size;
2947           }
2948           break;
2949
2950         case lang_wild_statement_enum:
2951
2952           dot = lang_size_sections (s->wild_statement.children.head,
2953                                     output_section_statement,
2954                                     &s->wild_statement.children.head,
2955
2956                                     fill, dot, relax);
2957
2958           break;
2959
2960         case lang_object_symbols_statement_enum:
2961           link_info.create_object_symbols_section =
2962             output_section_statement->bfd_section;
2963           break;
2964         case lang_output_statement_enum:
2965         case lang_target_statement_enum:
2966           break;
2967         case lang_input_section_enum:
2968           {
2969             asection *i;
2970
2971             i = (*prev)->input_section.section;
2972             if (! relax)
2973               {
2974                 if (i->_cooked_size == 0)
2975                   i->_cooked_size = i->_raw_size;
2976               }
2977             else
2978               {
2979                 boolean again;
2980
2981                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
2982                   einfo (_("%P%F: can't relax section: %E\n"));
2983                 if (again)
2984                   relax_again = true;
2985               }
2986             dot = size_input_section (prev,
2987                                       output_section_statement,
2988                                       output_section_statement->fill,
2989                                       dot, relax);
2990           }
2991           break;
2992         case lang_input_statement_enum:
2993           break;
2994         case lang_fill_statement_enum:
2995           s->fill_statement.output_section = output_section_statement->bfd_section;
2996
2997           fill = s->fill_statement.fill;
2998           break;
2999         case lang_assignment_statement_enum:
3000           {
3001             bfd_vma newdot = dot;
3002
3003             exp_fold_tree (s->assignment_statement.exp,
3004                            output_section_statement,
3005                            lang_allocating_phase_enum,
3006                            dot,
3007                            &newdot);
3008
3009             if (newdot != dot)
3010               {
3011                 /* The assignment changed dot.  Insert a pad.  */
3012                 if (output_section_statement == abs_output_section)
3013                   {
3014                     /* If we don't have an output section, then just adjust
3015                        the default memory address.  */
3016                     lang_memory_region_lookup ("*default*")->current = newdot;
3017                   }
3018                 else if (!relax)
3019                   {
3020                     lang_statement_union_type *new =
3021                       ((lang_statement_union_type *)
3022                        stat_alloc (sizeof (lang_padding_statement_type)));
3023
3024                     /* Link into existing chain.  */
3025                     new->header.next = *prev;
3026                     *prev = new;
3027                     new->header.type = lang_padding_statement_enum;
3028                     new->padding_statement.output_section =
3029                       output_section_statement->bfd_section;
3030                     new->padding_statement.output_offset =
3031                       dot - output_section_statement->bfd_section->vma;
3032                     new->padding_statement.fill = fill;
3033                     new->padding_statement.size = (newdot - dot) * opb;
3034                     output_section_statement->bfd_section->_raw_size +=
3035                       new->padding_statement.size;
3036                   }
3037
3038                 dot = newdot;
3039               }
3040           }
3041           break;
3042
3043         case lang_padding_statement_enum:
3044           /* If we are relaxing, and this is not the first pass, some
3045              padding statements may have been inserted during previous
3046              passes.  We may have to move the padding statement to a new
3047              location if dot has a different value at this point in this
3048              pass than it did at this point in the previous pass.  */
3049           s->padding_statement.output_offset =
3050             dot - output_section_statement->bfd_section->vma;
3051           dot += s->padding_statement.size / opb;
3052           output_section_statement->bfd_section->_raw_size +=
3053             s->padding_statement.size;
3054           break;
3055
3056         case lang_group_statement_enum:
3057           dot = lang_size_sections (s->group_statement.children.head,
3058                                     output_section_statement,
3059                                     &s->group_statement.children.head,
3060                                     fill, dot, relax);
3061           break;
3062
3063         default:
3064           FAIL ();
3065           break;
3066
3067           /* This can only get here when relaxing is turned on.  */
3068
3069         case lang_address_statement_enum:
3070           break;
3071         }
3072       prev = &s->header.next;
3073     }
3074   return dot;
3075 }
3076
3077 bfd_vma
3078 lang_do_assignments (s, output_section_statement, fill, dot)
3079      lang_statement_union_type * s;
3080      lang_output_section_statement_type * output_section_statement;
3081      fill_type fill;
3082      bfd_vma dot;
3083 {
3084   int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3085                                            ldfile_output_machine);
3086
3087   for (; s != (lang_statement_union_type *) NULL; s = s->next)
3088     {
3089       switch (s->header.type)
3090         {
3091         case lang_constructors_statement_enum:
3092           dot = lang_do_assignments (constructor_list.head,
3093                                      output_section_statement,
3094                                      fill,
3095                                      dot);
3096           break;
3097
3098         case lang_output_section_statement_enum:
3099           {
3100             lang_output_section_statement_type *os =
3101               &(s->output_section_statement);
3102
3103             if (os->bfd_section != NULL)
3104               {
3105                 dot = os->bfd_section->vma;
3106                 (void) lang_do_assignments (os->children.head, os,
3107                                             os->fill, dot);
3108                 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3109
3110               }
3111             if (os->load_base)
3112               {
3113                 /* If nothing has been placed into the output section then
3114                    it won't have a bfd_section. */
3115                 if (os->bfd_section)
3116                   {
3117                     os->bfd_section->lma
3118                       = exp_get_abs_int(os->load_base, 0,"load base", lang_final_phase_enum);
3119                   }
3120               }
3121           }
3122           break;
3123         case lang_wild_statement_enum:
3124
3125           dot = lang_do_assignments (s->wild_statement.children.head,
3126                                      output_section_statement,
3127                                      fill, dot);
3128
3129           break;
3130
3131         case lang_object_symbols_statement_enum:
3132         case lang_output_statement_enum:
3133         case lang_target_statement_enum:
3134 #if 0
3135         case lang_common_statement_enum:
3136 #endif
3137           break;
3138         case lang_data_statement_enum:
3139           {
3140             etree_value_type value;
3141
3142             value = exp_fold_tree (s->data_statement.exp,
3143                                    abs_output_section,
3144                                    lang_final_phase_enum, dot, &dot);
3145             s->data_statement.value = value.value;
3146             if (value.valid_p == false)
3147               einfo (_("%F%P: invalid data statement\n"));
3148           }
3149           {
3150             int size;
3151             switch (s->data_statement.type)
3152               {
3153               case QUAD:
3154               case SQUAD:
3155                 size = QUAD_SIZE;
3156                 break;
3157               case LONG:
3158                 size = LONG_SIZE;
3159                 break;
3160               case SHORT:
3161                 size = SHORT_SIZE;
3162                 break;
3163               case BYTE:
3164                 size = BYTE_SIZE;
3165                 break;
3166               }
3167             if (size < opb)
3168               size = opb;
3169             dot += size / opb;
3170           }
3171           break;
3172
3173         case lang_reloc_statement_enum:
3174           {
3175             etree_value_type value;
3176
3177             value = exp_fold_tree (s->reloc_statement.addend_exp,
3178                                    abs_output_section,
3179                                    lang_final_phase_enum, dot, &dot);
3180             s->reloc_statement.addend_value = value.value;
3181             if (value.valid_p == false)
3182               einfo (_("%F%P: invalid reloc statement\n"));
3183           }
3184           dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3185           break;
3186
3187         case lang_input_section_enum:
3188           {
3189             asection *in = s->input_section.section;
3190
3191             if (in->_cooked_size != 0)
3192               dot += in->_cooked_size / opb;
3193             else
3194               dot += in->_raw_size / opb;
3195           }
3196           break;
3197
3198         case lang_input_statement_enum:
3199           break;
3200         case lang_fill_statement_enum:
3201           fill = s->fill_statement.fill;
3202           break;
3203         case lang_assignment_statement_enum:
3204           {
3205             exp_fold_tree (s->assignment_statement.exp,
3206                            output_section_statement,
3207                            lang_final_phase_enum,
3208                            dot,
3209                            &dot);
3210           }
3211
3212           break;
3213         case lang_padding_statement_enum:
3214           dot += s->padding_statement.size / opb;
3215           break;
3216
3217         case lang_group_statement_enum:
3218           dot = lang_do_assignments (s->group_statement.children.head,
3219                                      output_section_statement,
3220                                      fill, dot);
3221
3222           break;
3223
3224         default:
3225           FAIL ();
3226           break;
3227         case lang_address_statement_enum:
3228           break;
3229         }
3230
3231     }
3232   return dot;
3233 }
3234
3235 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
3236    operator .startof. (section_name), it produces an undefined symbol
3237    .startof.section_name.  Similarly, when it sees
3238    .sizeof. (section_name), it produces an undefined symbol
3239    .sizeof.section_name.  For all the output sections, we look for
3240    such symbols, and set them to the correct value.  */
3241
3242 static void
3243 lang_set_startof ()
3244 {
3245   asection *s;
3246
3247   if (link_info.relocateable)
3248     return;
3249
3250   for (s = output_bfd->sections; s != NULL; s = s->next)
3251     {
3252       const char *secname;
3253       char *buf;
3254       struct bfd_link_hash_entry *h;
3255
3256       secname = bfd_get_section_name (output_bfd, s);
3257       buf = xmalloc (10 + strlen (secname));
3258
3259       sprintf (buf, ".startof.%s", secname);
3260       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3261       if (h != NULL && h->type == bfd_link_hash_undefined)
3262         {
3263           h->type = bfd_link_hash_defined;
3264           h->u.def.value = bfd_get_section_vma (output_bfd, s);
3265           h->u.def.section = bfd_abs_section_ptr;
3266         }
3267
3268       sprintf (buf, ".sizeof.%s", secname);
3269       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3270       if (h != NULL && h->type == bfd_link_hash_undefined)
3271         {
3272           int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3273                                                    ldfile_output_machine);
3274           h->type = bfd_link_hash_defined;
3275           if (s->_cooked_size != 0)
3276             h->u.def.value = s->_cooked_size / opb;
3277           else
3278             h->u.def.value = s->_raw_size / opb;
3279           h->u.def.section = bfd_abs_section_ptr;
3280         }
3281
3282       free (buf);
3283     }
3284 }
3285
3286 static void
3287 lang_finish ()
3288 {
3289   struct bfd_link_hash_entry *h;
3290   boolean warn;
3291
3292   if (link_info.relocateable || link_info.shared)
3293     warn = false;
3294   else
3295     warn = true;
3296
3297   if (entry_symbol == (char *) NULL)
3298     {
3299       /* No entry has been specified.  Look for start, but don't warn
3300          if we don't find it.  */
3301       entry_symbol = "start";
3302       warn = false;
3303     }
3304
3305   h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3306   if (h != (struct bfd_link_hash_entry *) NULL
3307       && (h->type == bfd_link_hash_defined
3308           || h->type == bfd_link_hash_defweak)
3309       && h->u.def.section->output_section != NULL)
3310     {
3311       bfd_vma val;
3312
3313       val = (h->u.def.value
3314              + bfd_get_section_vma (output_bfd,
3315                                     h->u.def.section->output_section)
3316              + h->u.def.section->output_offset);
3317       if (! bfd_set_start_address (output_bfd, val))
3318         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3319     }
3320   else
3321     {
3322       bfd_vma val;
3323       CONST char *send;
3324
3325       /* We couldn't find the entry symbol.  Try parsing it as a
3326          number.  */
3327       val = bfd_scan_vma (entry_symbol, &send, 0);
3328       if (*send == '\0')
3329         {
3330           if (! bfd_set_start_address (output_bfd, val))
3331             einfo (_("%P%F: can't set start address\n"));
3332         }
3333       else
3334         {
3335           asection *ts;
3336
3337           /* Can't find the entry symbol, and it's not a number.  Use
3338              the first address in the text section.  */
3339           ts = bfd_get_section_by_name (output_bfd, ".text");
3340           if (ts != (asection *) NULL)
3341             {
3342               if (warn)
3343                 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3344                        entry_symbol, bfd_get_section_vma (output_bfd, ts));
3345               if (! bfd_set_start_address (output_bfd,
3346                                            bfd_get_section_vma (output_bfd,
3347                                                                 ts)))
3348                 einfo (_("%P%F: can't set start address\n"));
3349             }
3350           else
3351             {
3352               if (warn)
3353                 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3354                        entry_symbol);
3355             }
3356         }
3357     }
3358 }
3359
3360 /* This is a small function used when we want to ignore errors from
3361    BFD.  */
3362
3363 static void
3364 #ifdef ANSI_PROTOTYPES
3365 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3366 #else
3367 ignore_bfd_errors (s)
3368      const char *s ATTRIBUTE_UNUSED;
3369 #endif
3370 {
3371   /* Don't do anything.  */
3372 }
3373
3374 /* Check that the architecture of all the input files is compatible
3375    with the output file.  Also call the backend to let it do any
3376    other checking that is needed.  */
3377
3378 static void
3379 lang_check ()
3380 {
3381   lang_statement_union_type *file;
3382   bfd *input_bfd;
3383   CONST bfd_arch_info_type *compatible;
3384
3385   for (file = file_chain.head;
3386        file != (lang_statement_union_type *) NULL;
3387        file = file->input_statement.next)
3388     {
3389       input_bfd = file->input_statement.the_bfd;
3390       compatible = bfd_arch_get_compatible (input_bfd,
3391                                             output_bfd);
3392       if (compatible == NULL)
3393         {
3394           if (command_line.warn_mismatch)
3395             einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3396                    bfd_printable_name (input_bfd), input_bfd,
3397                    bfd_printable_name (output_bfd));
3398         }
3399       else
3400         {
3401           bfd_error_handler_type pfn = NULL;
3402
3403           /* If we aren't supposed to warn about mismatched input
3404              files, temporarily set the BFD error handler to a
3405              function which will do nothing.  We still want to call
3406              bfd_merge_private_bfd_data, since it may set up
3407              information which is needed in the output file.  */
3408           if (! command_line.warn_mismatch)
3409             pfn = bfd_set_error_handler (ignore_bfd_errors);
3410           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3411             {
3412               if (command_line.warn_mismatch)
3413                 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3414                        input_bfd);
3415             }
3416           if (! command_line.warn_mismatch)
3417             bfd_set_error_handler (pfn);
3418         }
3419     }
3420 }
3421
3422 /* Look through all the global common symbols and attach them to the
3423    correct section.  The -sort-common command line switch may be used
3424    to roughly sort the entries by size.  */
3425
3426 static void
3427 lang_common ()
3428 {
3429   if (link_info.relocateable
3430       && ! command_line.force_common_definition)
3431     return;
3432
3433   if (! config.sort_common)
3434     bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3435   else
3436     {
3437       int power;
3438
3439       for (power = 4; power >= 0; power--)
3440         bfd_link_hash_traverse (link_info.hash, lang_one_common,
3441                                 (PTR) &power);
3442     }
3443 }
3444
3445 /* Place one common symbol in the correct section.  */
3446
3447 static boolean
3448 lang_one_common (h, info)
3449      struct bfd_link_hash_entry *h;
3450      PTR info;
3451 {
3452   unsigned int power_of_two;
3453   bfd_vma size;
3454   asection *section;
3455   int opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3456                                            ldfile_output_machine);
3457
3458   if (h->type != bfd_link_hash_common)
3459     return true;
3460
3461   size = h->u.c.size;
3462   power_of_two = h->u.c.p->alignment_power;
3463
3464   if (config.sort_common
3465       && power_of_two < (unsigned int) *(int *) info)
3466     return true;
3467
3468   section = h->u.c.p->section;
3469
3470   /* Increase the size of the section.  */
3471   section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3472                                    (bfd_size_type) (1 << power_of_two)) * opb;
3473
3474   /* Adjust the alignment if necessary.  */
3475   if (power_of_two > section->alignment_power)
3476     section->alignment_power = power_of_two;
3477
3478   /* Change the symbol from common to defined.  */
3479   h->type = bfd_link_hash_defined;
3480   h->u.def.section = section;
3481   h->u.def.value = section->_cooked_size;
3482
3483   /* Increase the size of the section.  */
3484   section->_cooked_size += size;
3485
3486   /* Make sure the section is allocated in memory, and make sure that
3487      it is no longer a common section.  */
3488   section->flags |= SEC_ALLOC;
3489   section->flags &= ~ SEC_IS_COMMON;
3490
3491   if (config.map_file != NULL)
3492     {
3493       static boolean header_printed;
3494       int len;
3495       char *name;
3496       char buf[50];
3497
3498       if (! header_printed)
3499         {
3500           minfo (_("\nAllocating common symbols\n"));
3501           minfo (_("Common symbol       size              file\n\n"));
3502           header_printed = true;
3503         }
3504
3505       name = demangle (h->root.string);
3506       minfo ("%s", name);
3507       len = strlen (name);
3508       free (name);
3509
3510       if (len >= 19)
3511         {
3512           print_nl ();
3513           len = 0;
3514         }
3515       while (len < 20)
3516         {
3517           print_space ();
3518           ++len;
3519         }
3520
3521       minfo ("0x");
3522       if (size <= 0xffffffff)
3523         sprintf (buf, "%lx", (unsigned long) size);
3524       else
3525         sprintf_vma (buf, size);
3526       minfo ("%s", buf);
3527       len = strlen (buf);
3528
3529       while (len < 16)
3530         {
3531           print_space ();
3532           ++len;
3533         }
3534
3535       minfo ("%B\n", section->owner);
3536     }
3537
3538   return true;
3539 }
3540
3541 /*
3542 run through the input files and ensure that every input
3543 section has somewhere to go. If one is found without
3544 a destination then create an input request and place it
3545 into the statement tree.
3546 */
3547
3548 static void
3549 lang_place_orphans ()
3550 {
3551   LANG_FOR_EACH_INPUT_STATEMENT (file)
3552     {
3553       asection *s;
3554
3555       for (s = file->the_bfd->sections;
3556            s != (asection *) NULL;
3557            s = s->next)
3558         {
3559           if (s->output_section == (asection *) NULL)
3560             {
3561               /* This section of the file is not attatched, root
3562                  around for a sensible place for it to go */
3563
3564               if (file->just_syms_flag)
3565                 {
3566                   /* We are only retrieving symbol values from this
3567                      file.  We want the symbols to act as though the
3568                      values in the file are absolute.  */
3569                   s->output_section = bfd_abs_section_ptr;
3570                   s->output_offset = s->vma;
3571                 }
3572               else if (strcmp (s->name, "COMMON") == 0)
3573                 {
3574                   /* This is a lonely common section which must have
3575                      come from an archive.  We attach to the section
3576                      with the wildcard.  */
3577                   if (! link_info.relocateable
3578                       || command_line.force_common_definition)
3579                     {
3580                       if (default_common_section == NULL)
3581                         {
3582 #if 0
3583                           /* This message happens when using the
3584                              svr3.ifile linker script, so I have
3585                              disabled it.  */
3586                           info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3587 #endif
3588                           default_common_section =
3589                             lang_output_section_statement_lookup (".bss");
3590
3591                         }
3592                       wild_doit (&default_common_section->children, s,
3593                                  default_common_section, file);
3594                     }
3595                 }
3596               else if (ldemul_place_orphan (file, s))
3597                 ;
3598               else
3599                 {
3600                   lang_output_section_statement_type *os =
3601                   lang_output_section_statement_lookup (s->name);
3602
3603                   wild_doit (&os->children, s, os, file);
3604                 }
3605             }
3606         }
3607     }
3608 }
3609
3610
3611 void
3612 lang_set_flags (ptr, flags, invert)
3613      lang_memory_region_type *ptr;
3614      CONST char *flags;
3615      int invert;
3616 {
3617   flagword *ptr_flags;
3618
3619   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3620   while (*flags)
3621     {
3622       switch (*flags)
3623         {
3624         case 'A': case 'a':
3625           *ptr_flags |= SEC_ALLOC;
3626           break;
3627
3628         case 'R': case 'r':
3629           *ptr_flags |= SEC_READONLY;
3630           break;
3631
3632         case 'W': case 'w':
3633           *ptr_flags |= SEC_DATA;
3634           break;
3635
3636         case 'X': case 'x':
3637           *ptr_flags |= SEC_CODE;
3638           break;
3639
3640         case 'L': case 'l':
3641         case 'I': case 'i':
3642           *ptr_flags |= SEC_LOAD;
3643           break;
3644
3645         default:
3646           einfo (_("%P%F: invalid syntax in flags\n"));
3647           break;
3648         }
3649       flags++;
3650     }
3651 }
3652
3653 /* Call a function on each input file.  This function will be called
3654    on an archive, but not on the elements.  */
3655
3656 void
3657 lang_for_each_input_file (func)
3658      void (*func) PARAMS ((lang_input_statement_type *));
3659 {
3660   lang_input_statement_type *f;
3661
3662   for (f = (lang_input_statement_type *) input_file_chain.head;
3663        f != NULL;
3664        f = (lang_input_statement_type *) f->next_real_file)
3665     func (f);
3666 }
3667
3668 /* Call a function on each file.  The function will be called on all
3669    the elements of an archive which are included in the link, but will
3670    not be called on the archive file itself.  */
3671
3672 void
3673 lang_for_each_file (func)
3674      void (*func) PARAMS ((lang_input_statement_type *));
3675 {
3676   LANG_FOR_EACH_INPUT_STATEMENT (f)
3677     {
3678       func (f);
3679     }
3680 }
3681
3682 #if 0
3683
3684 /* Not used.  */
3685
3686 void
3687 lang_for_each_input_section (func)
3688      void (*func) PARAMS ((bfd * ab, asection * as));
3689 {
3690   LANG_FOR_EACH_INPUT_STATEMENT (f)
3691     {
3692       asection * s;
3693
3694       for (s = f->the_bfd->sections;
3695            s != (asection *) NULL;
3696            s = s->next)
3697         {
3698           func (f->the_bfd, s);
3699         }
3700     }
3701 }
3702
3703 #endif
3704
3705 void
3706 ldlang_add_file (entry)
3707      lang_input_statement_type * entry;
3708 {
3709   bfd **pp;
3710
3711   lang_statement_append (&file_chain,
3712                          (lang_statement_union_type *) entry,
3713                          &entry->next);
3714
3715   /* The BFD linker needs to have a list of all input BFDs involved in
3716      a link.  */
3717   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3718   ASSERT (entry->the_bfd != output_bfd);
3719   for (pp = &link_info.input_bfds;
3720        *pp != (bfd *) NULL;
3721        pp = &(*pp)->link_next)
3722     ;
3723   *pp = entry->the_bfd;
3724   entry->the_bfd->usrdata = (PTR) entry;
3725   bfd_set_gp_size (entry->the_bfd, g_switch_value);
3726
3727   /* Look through the sections and check for any which should not be
3728      included in the link.  We need to do this now, so that we can
3729      notice when the backend linker tries to report multiple
3730      definition errors for symbols which are in sections we aren't
3731      going to link.  FIXME: It might be better to entirely ignore
3732      symbols which are defined in sections which are going to be
3733      discarded.  This would require modifying the backend linker for
3734      each backend which might set the SEC_LINK_ONCE flag.  If we do
3735      this, we should probably handle SEC_EXCLUDE in the same way.  */
3736
3737   bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3738 }
3739
3740 void
3741 lang_add_output (name, from_script)
3742      CONST char *name;
3743      int from_script;
3744 {
3745   /* Make -o on command line override OUTPUT in script.  */
3746   if (had_output_filename == false || !from_script)
3747     {
3748       output_filename = name;
3749       had_output_filename = true;
3750     }
3751 }
3752
3753
3754 static lang_output_section_statement_type *current_section;
3755
3756 static int
3757 topower (x)
3758      int x;
3759 {
3760   unsigned int i = 1;
3761   int l;
3762
3763   if (x < 0)
3764     return -1;
3765
3766   for (l = 0; l < 32; l++)
3767     {
3768       if (i >= (unsigned int) x)
3769         return l;
3770       i <<= 1;
3771     }
3772
3773   return 0;
3774 }
3775
3776 void
3777 lang_enter_output_section_statement (output_section_statement_name,
3778                                      address_exp, sectype, block_value,
3779                                      align, subalign, ebase)
3780      const char *output_section_statement_name;
3781      etree_type * address_exp;
3782      enum section_type sectype;
3783      bfd_vma block_value;
3784      etree_type *align;
3785      etree_type *subalign;
3786      etree_type *ebase;
3787 {
3788   lang_output_section_statement_type *os;
3789
3790   current_section =
3791    os =
3792     lang_output_section_statement_lookup (output_section_statement_name);
3793
3794
3795
3796   /* Add this statement to tree */
3797   /*  add_statement(lang_output_section_statement_enum,
3798       output_section_statement);*/
3799   /* Make next things chain into subchain of this */
3800
3801   if (os->addr_tree ==
3802       (etree_type *) NULL)
3803   {
3804     os->addr_tree =
3805      address_exp;
3806   }
3807   os->sectype = sectype;
3808   if (sectype != noload_section)
3809     os->flags = SEC_NO_FLAGS;
3810   else
3811     os->flags = SEC_NEVER_LOAD;
3812   os->block_value = block_value ? block_value : 1;
3813   stat_ptr = &os->children;
3814
3815   os->subsection_alignment = topower(
3816    exp_get_value_int(subalign, -1,
3817                      "subsection alignment",
3818                      0));
3819   os->section_alignment = topower(
3820    exp_get_value_int(align, -1,
3821                      "section alignment", 0));
3822
3823   os->load_base = ebase;
3824 }
3825
3826
3827 void
3828 lang_final ()
3829 {
3830   lang_output_statement_type *new =
3831     new_stat (lang_output_statement, stat_ptr);
3832
3833   new->name = output_filename;
3834 }
3835
3836 /* Reset the current counters in the regions */
3837 static void
3838 reset_memory_regions ()
3839 {
3840   lang_memory_region_type *p = lang_memory_region_list;
3841
3842   for (p = lang_memory_region_list;
3843        p != (lang_memory_region_type *) NULL;
3844        p = p->next)
3845     {
3846       p->old_length = (bfd_size_type) (p->current - p->origin);
3847       p->current = p->origin;
3848     }
3849 }
3850
3851 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3852    as needed.  SECTION may be NULL, in which case it is a wild card.  */
3853
3854 static void
3855 gc_section_callback (ptr, section, file, data)
3856      lang_wild_statement_type *ptr;
3857      asection *section;
3858      lang_input_statement_type *file ATTRIBUTE_UNUSED;
3859      void *data ATTRIBUTE_UNUSED;
3860 {
3861   /* If the wild pattern was marked KEEP, the member sections
3862      should be as well.  */
3863   if (ptr->keep_sections)
3864     section->flags |= SEC_KEEP;
3865 }
3866
3867 /* Handle a wild statement, marking it against GC.  SECTION or FILE or both
3868    may be NULL, indicating that it is a wildcard.  */
3869
3870 static void
3871 lang_gc_wild (s, section, file)
3872      lang_wild_statement_type *s;
3873      const char *section;
3874      const char *file;
3875 {
3876   walk_wild (s, section, file, gc_section_callback, NULL);
3877 }
3878
3879 /* Iterate over sections marking them against GC.  */
3880
3881 static void
3882 lang_gc_sections_1 (s)
3883      lang_statement_union_type * s;
3884 {
3885   for (; s != (lang_statement_union_type *) NULL; s = s->next)
3886     {
3887       switch (s->header.type)
3888         {
3889         case lang_wild_statement_enum:
3890           lang_gc_wild (&s->wild_statement,
3891                         s->wild_statement.section_name,
3892                         s->wild_statement.filename);
3893           break;
3894         case lang_constructors_statement_enum:
3895           lang_gc_sections_1 (constructor_list.head);
3896           break;
3897         case lang_output_section_statement_enum:
3898           lang_gc_sections_1 (s->output_section_statement.children.head);
3899           break;
3900         case lang_group_statement_enum:
3901           lang_gc_sections_1 (s->group_statement.children.head);
3902           break;
3903         default:
3904           break;
3905         }
3906     }
3907 }
3908
3909 static void
3910 lang_gc_sections ()
3911 {
3912   struct bfd_link_hash_entry *h;
3913   ldlang_undef_chain_list_type *ulist, fake_list_start;
3914
3915   /* Keep all sections so marked in the link script.  */
3916
3917   lang_gc_sections_1 (statement_list.head);
3918
3919   /* Keep all sections containing symbols undefined on the command-line.
3920      Handle the entry symbol at the same time.  */
3921
3922   if (entry_symbol != NULL)
3923     {
3924       fake_list_start.next = ldlang_undef_chain_list_head;
3925       fake_list_start.name = (char *) entry_symbol;
3926       ulist = &fake_list_start;
3927     }
3928   else
3929     ulist = ldlang_undef_chain_list_head;
3930
3931   for (; ulist; ulist = ulist->next)
3932     {
3933       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
3934                                 false, false, false);
3935
3936       if (h != (struct bfd_link_hash_entry *) NULL
3937           && (h->type == bfd_link_hash_defined
3938               || h->type == bfd_link_hash_defweak)
3939           && ! bfd_is_abs_section (h->u.def.section))
3940         {
3941           h->u.def.section->flags |= SEC_KEEP;
3942         }
3943     }
3944
3945   bfd_gc_sections (output_bfd, &link_info);
3946 }
3947
3948 void
3949 lang_process ()
3950 {
3951   lang_reasonable_defaults ();
3952   current_target = default_target;
3953
3954   lang_for_each_statement (ldlang_open_output); /* Open the output file */
3955
3956   ldemul_create_output_section_statements ();
3957
3958   /* Add to the hash table all undefineds on the command line */
3959   lang_place_undefineds ();
3960
3961   already_linked_table_init ();
3962
3963   /* Create a bfd for each input file */
3964   current_target = default_target;
3965   open_input_bfds (statement_list.head, false);
3966
3967   ldemul_after_open ();
3968
3969   already_linked_table_free ();
3970
3971   /* Make sure that we're not mixing architectures.  We call this
3972      after all the input files have been opened, but before we do any
3973      other processing, so that any operations merge_private_bfd_data
3974      does on the output file will be known during the rest of the
3975      link.  */
3976   lang_check ();
3977
3978   /* Handle .exports instead of a version script if we're told to do so.  */
3979   if (command_line.version_exports_section)
3980     lang_do_version_exports_section ();
3981
3982   /* Build all sets based on the information gathered from the input
3983      files.  */
3984   ldctor_build_sets ();
3985
3986   /* Remove unreferenced sections if asked to.  */
3987   if (command_line.gc_sections)
3988     lang_gc_sections ();
3989
3990   /* Size up the common data */
3991   lang_common ();
3992
3993   /* Run through the contours of the script and attach input sections
3994      to the correct output sections
3995      */
3996   map_input_to_output_sections (statement_list.head, (char *) NULL,
3997                                 (lang_output_section_statement_type *) NULL);
3998
3999
4000   /* Find any sections not attached explicitly and handle them */
4001   lang_place_orphans ();
4002
4003   ldemul_before_allocation ();
4004
4005   /* We must record the program headers before we try to fix the
4006      section positions, since they will affect SIZEOF_HEADERS.  */
4007   lang_record_phdrs ();
4008
4009   /* Now run around and relax if we can */
4010   if (command_line.relax)
4011     {
4012       /* First time round is a trial run to get the 'worst case'
4013          addresses of the objects if there was no relaxing.  */
4014       lang_size_sections (statement_list.head,
4015                           abs_output_section,
4016                           &(statement_list.head), 0, (bfd_vma) 0, false);
4017
4018       /* Keep relaxing until bfd_relax_section gives up.  */
4019       do
4020         {
4021           reset_memory_regions ();
4022
4023           relax_again = false;
4024
4025           /* Note: pe-dll.c does something like this also.  If you find
4026              you need to change this code, you probably need to change
4027              pe-dll.c also.  DJ */
4028
4029           /* Do all the assignments with our current guesses as to
4030              section sizes.  */
4031           lang_do_assignments (statement_list.head,
4032                                abs_output_section,
4033                                (fill_type) 0, (bfd_vma) 0);
4034
4035           /* Perform another relax pass - this time we know where the
4036              globals are, so can make better guess.  */
4037           lang_size_sections (statement_list.head,
4038                               abs_output_section,
4039                               &(statement_list.head), 0, (bfd_vma) 0, true);
4040         }
4041       while (relax_again);
4042     }
4043   else
4044     {
4045       /* Size up the sections.  */
4046       lang_size_sections (statement_list.head,
4047                           abs_output_section,
4048                           &(statement_list.head), 0, (bfd_vma) 0, false);
4049     }
4050
4051   /* See if anything special should be done now we know how big
4052      everything is.  */
4053   ldemul_after_allocation ();
4054
4055   /* Fix any .startof. or .sizeof. symbols.  */
4056   lang_set_startof ();
4057
4058   /* Do all the assignments, now that we know the final restingplaces
4059      of all the symbols */
4060
4061   lang_do_assignments (statement_list.head,
4062                        abs_output_section,
4063                        (fill_type) 0, (bfd_vma) 0);
4064
4065   /* Make sure that the section addresses make sense.  */
4066   if (! link_info.relocateable
4067       && command_line.check_section_addresses)
4068     lang_check_section_addresses ();
4069
4070   /* Final stuffs */
4071
4072   ldemul_finish ();
4073   lang_finish ();
4074 }
4075
4076 /* EXPORTED TO YACC */
4077
4078 void
4079 lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
4080                keep_sections, exclude_filename_list)
4081      const char *const section_name;
4082      boolean sections_sorted;
4083      const char *const filename;
4084      boolean filenames_sorted;
4085      boolean keep_sections;
4086      struct name_list *exclude_filename_list;
4087 {
4088   lang_wild_statement_type *new = new_stat (lang_wild_statement,
4089                                             stat_ptr);
4090
4091   if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
4092     {
4093       placed_commons = true;
4094     }
4095   if (filename != NULL && ! wildcardp (filename))
4096     {
4097       lang_has_input_file = true;
4098     }
4099   new->section_name = section_name;
4100   new->sections_sorted = sections_sorted;
4101   new->filename = filename;
4102   new->filenames_sorted = filenames_sorted;
4103   new->keep_sections = keep_sections;
4104   new->exclude_filename_list = exclude_filename_list;
4105   lang_list_init (&new->children);
4106 }
4107
4108 void
4109 lang_section_start (name, address)
4110      CONST char *name;
4111      etree_type * address;
4112 {
4113   lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
4114
4115   ad->section_name = name;
4116   ad->address = address;
4117 }
4118
4119 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
4120    because of a -e argument on the command line, or zero if this is
4121    called by ENTRY in a linker script.  Command line arguments take
4122    precedence.  */
4123
4124 void
4125 lang_add_entry (name, cmdline)
4126      CONST char *name;
4127      boolean cmdline;
4128 {
4129   if (entry_symbol == NULL
4130       || cmdline
4131       || ! entry_from_cmdline)
4132     {
4133       entry_symbol = name;
4134       entry_from_cmdline = cmdline;
4135     }
4136 }
4137
4138 void
4139 lang_add_target (name)
4140      CONST char *name;
4141 {
4142   lang_target_statement_type *new = new_stat (lang_target_statement,
4143                                               stat_ptr);
4144
4145   new->target = name;
4146
4147 }
4148
4149 void
4150 lang_add_map (name)
4151      CONST char *name;
4152 {
4153   while (*name)
4154     {
4155       switch (*name)
4156         {
4157           case 'F':
4158           map_option_f = true;
4159           break;
4160         }
4161       name++;
4162     }
4163 }
4164
4165 void
4166 lang_add_fill (exp)
4167      int exp;
4168 {
4169   lang_fill_statement_type *new = new_stat (lang_fill_statement,
4170                                             stat_ptr);
4171
4172   new->fill = exp;
4173 }
4174
4175 void
4176 lang_add_data (type, exp)
4177      int type;
4178      union etree_union *exp;
4179 {
4180
4181   lang_data_statement_type *new = new_stat (lang_data_statement,
4182                                             stat_ptr);
4183
4184   new->exp = exp;
4185   new->type = type;
4186
4187 }
4188
4189 /* Create a new reloc statement.  RELOC is the BFD relocation type to
4190    generate.  HOWTO is the corresponding howto structure (we could
4191    look this up, but the caller has already done so).  SECTION is the
4192    section to generate a reloc against, or NAME is the name of the
4193    symbol to generate a reloc against.  Exactly one of SECTION and
4194    NAME must be NULL.  ADDEND is an expression for the addend.  */
4195
4196 void
4197 lang_add_reloc (reloc, howto, section, name, addend)
4198      bfd_reloc_code_real_type reloc;
4199      reloc_howto_type *howto;
4200      asection *section;
4201      const char *name;
4202      union etree_union *addend;
4203 {
4204   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4205
4206   p->reloc = reloc;
4207   p->howto = howto;
4208   p->section = section;
4209   p->name = name;
4210   p->addend_exp = addend;
4211
4212   p->addend_value = 0;
4213   p->output_section = NULL;
4214   p->output_vma = 0;
4215 }
4216
4217 lang_assignment_statement_type *
4218 lang_add_assignment (exp)
4219      etree_type * exp;
4220 {
4221   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4222                                                   stat_ptr);
4223
4224   new->exp = exp;
4225   return new;
4226 }
4227
4228 void
4229 lang_add_attribute (attribute)
4230      enum statement_enum attribute;
4231 {
4232   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4233 }
4234
4235 void
4236 lang_startup (name)
4237      CONST char *name;
4238 {
4239   if (startup_file != (char *) NULL)
4240     {
4241       einfo (_("%P%Fmultiple STARTUP files\n"));
4242     }
4243   first_file->filename = name;
4244   first_file->local_sym_name = name;
4245   first_file->real = true;
4246
4247   startup_file = name;
4248 }
4249
4250 void
4251 lang_float (maybe)
4252      boolean maybe;
4253 {
4254   lang_float_flag = maybe;
4255 }
4256
4257 void
4258 lang_leave_output_section_statement (fill, memspec, phdrs)
4259      bfd_vma fill;
4260      const char *memspec;
4261      struct lang_output_section_phdr_list *phdrs;
4262 {
4263   current_section->fill = fill;
4264   current_section->region = lang_memory_region_lookup (memspec);
4265   current_section->phdrs = phdrs;
4266   stat_ptr = &statement_list;
4267 }
4268
4269 /*
4270  Create an absolute symbol with the given name with the value of the
4271  address of first byte of the section named.
4272
4273  If the symbol already exists, then do nothing.
4274 */
4275 void
4276 lang_abs_symbol_at_beginning_of (secname, name)
4277      const char *secname;
4278      const char *name;
4279 {
4280   struct bfd_link_hash_entry *h;
4281
4282   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4283   if (h == (struct bfd_link_hash_entry *) NULL)
4284     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4285
4286   if (h->type == bfd_link_hash_new
4287       || h->type == bfd_link_hash_undefined)
4288     {
4289       asection *sec;
4290
4291       h->type = bfd_link_hash_defined;
4292
4293       sec = bfd_get_section_by_name (output_bfd, secname);
4294       if (sec == (asection *) NULL)
4295         h->u.def.value = 0;
4296       else
4297         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4298
4299       h->u.def.section = bfd_abs_section_ptr;
4300     }
4301 }
4302
4303 /*
4304  Create an absolute symbol with the given name with the value of the
4305  address of the first byte after the end of the section named.
4306
4307  If the symbol already exists, then do nothing.
4308 */
4309 void
4310 lang_abs_symbol_at_end_of (secname, name)
4311      const char *secname;
4312      const char *name;
4313 {
4314   struct bfd_link_hash_entry *h;
4315
4316   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4317   if (h == (struct bfd_link_hash_entry *) NULL)
4318     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4319
4320   if (h->type == bfd_link_hash_new
4321       || h->type == bfd_link_hash_undefined)
4322     {
4323       asection *sec;
4324
4325       h->type = bfd_link_hash_defined;
4326
4327       sec = bfd_get_section_by_name (output_bfd, secname);
4328       if (sec == (asection *) NULL)
4329         h->u.def.value = 0;
4330       else
4331         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4332                           + bfd_section_size (output_bfd, sec) /
4333                           bfd_octets_per_byte (output_bfd));
4334
4335       h->u.def.section = bfd_abs_section_ptr;
4336     }
4337 }
4338
4339 void
4340 lang_statement_append (list, element, field)
4341      lang_statement_list_type * list;
4342      lang_statement_union_type * element;
4343      lang_statement_union_type ** field;
4344 {
4345   *(list->tail) = element;
4346   list->tail = field;
4347 }
4348
4349 /* Set the output format type.  -oformat overrides scripts.  */
4350
4351 void
4352 lang_add_output_format (format, big, little, from_script)
4353      const char *format;
4354      const char *big;
4355      const char *little;
4356      int from_script;
4357 {
4358   if (output_target == NULL || !from_script)
4359     {
4360       if (command_line.endian == ENDIAN_BIG
4361           && big != NULL)
4362         format = big;
4363       else if (command_line.endian == ENDIAN_LITTLE
4364                && little != NULL)
4365         format = little;
4366
4367       output_target = format;
4368     }
4369 }
4370
4371 /* Enter a group.  This creates a new lang_group_statement, and sets
4372    stat_ptr to build new statements within the group.  */
4373
4374 void
4375 lang_enter_group ()
4376 {
4377   lang_group_statement_type *g;
4378
4379   g = new_stat (lang_group_statement, stat_ptr);
4380   lang_list_init (&g->children);
4381   stat_ptr = &g->children;
4382 }
4383
4384 /* Leave a group.  This just resets stat_ptr to start writing to the
4385    regular list of statements again.  Note that this will not work if
4386    groups can occur inside anything else which can adjust stat_ptr,
4387    but currently they can't.  */
4388
4389 void
4390 lang_leave_group ()
4391 {
4392   stat_ptr = &statement_list;
4393 }
4394
4395 /* Add a new program header.  This is called for each entry in a PHDRS
4396    command in a linker script.  */
4397
4398 void
4399 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4400      const char *name;
4401      etree_type *type;
4402      boolean filehdr;
4403      boolean phdrs;
4404      etree_type *at;
4405      etree_type *flags;
4406 {
4407   struct lang_phdr *n, **pp;
4408
4409   n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4410   n->next = NULL;
4411   n->name = name;
4412   n->type = exp_get_value_int (type, 0, "program header type",
4413                                lang_final_phase_enum);
4414   n->filehdr = filehdr;
4415   n->phdrs = phdrs;
4416   n->at = at;
4417   n->flags = flags;
4418
4419   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4420     ;
4421   *pp = n;
4422 }
4423
4424 /* Record the program header information in the output BFD.  FIXME: We
4425    should not be calling an ELF specific function here.  */
4426
4427 static void
4428 lang_record_phdrs ()
4429 {
4430   unsigned int alc;
4431   asection **secs;
4432   struct lang_output_section_phdr_list *last;
4433   struct lang_phdr *l;
4434   lang_statement_union_type *u;
4435
4436   alc = 10;
4437   secs = (asection **) xmalloc (alc * sizeof (asection *));
4438   last = NULL;
4439   for (l = lang_phdr_list; l != NULL; l = l->next)
4440     {
4441       unsigned int c;
4442       flagword flags;
4443       bfd_vma at;
4444
4445       c = 0;
4446       for (u = lang_output_section_statement.head;
4447            u != NULL;
4448            u = u->output_section_statement.next)
4449         {
4450           lang_output_section_statement_type *os;
4451           struct lang_output_section_phdr_list *pl;
4452
4453           os = &u->output_section_statement;
4454
4455           pl = os->phdrs;
4456           if (pl != NULL)
4457             last = pl;
4458           else
4459             {
4460               if (os->sectype == noload_section
4461                   || os->bfd_section == NULL
4462                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
4463                 continue;
4464               pl = last;
4465             }
4466
4467           if (os->bfd_section == NULL)
4468             continue;
4469
4470           for (; pl != NULL; pl = pl->next)
4471             {
4472               if (strcmp (pl->name, l->name) == 0)
4473                 {
4474                   if (c >= alc)
4475                     {
4476                       alc *= 2;
4477                       secs = ((asection **)
4478                               xrealloc (secs, alc * sizeof (asection *)));
4479                     }
4480                   secs[c] = os->bfd_section;
4481                   ++c;
4482                   pl->used = true;
4483                 }
4484             }
4485         }
4486
4487       if (l->flags == NULL)
4488         flags = 0;
4489       else
4490         flags = exp_get_vma (l->flags, 0, "phdr flags",
4491                              lang_final_phase_enum);
4492
4493       if (l->at == NULL)
4494         at = 0;
4495       else
4496         at = exp_get_vma (l->at, 0, "phdr load address",
4497                           lang_final_phase_enum);
4498
4499       if (! bfd_record_phdr (output_bfd, l->type,
4500                              l->flags == NULL ? false : true,
4501                              flags,
4502                              l->at == NULL ? false : true,
4503                              at, l->filehdr, l->phdrs, c, secs))
4504         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4505     }
4506
4507   free (secs);
4508
4509   /* Make sure all the phdr assignments succeeded.  */
4510   for (u = lang_output_section_statement.head;
4511        u != NULL;
4512        u = u->output_section_statement.next)
4513     {
4514       struct lang_output_section_phdr_list *pl;
4515
4516       if (u->output_section_statement.bfd_section == NULL)
4517         continue;
4518
4519       for (pl = u->output_section_statement.phdrs;
4520            pl != NULL;
4521            pl = pl->next)
4522         if (! pl->used && strcmp (pl->name, "NONE") != 0)
4523           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4524                  u->output_section_statement.name, pl->name);
4525     }
4526 }
4527
4528 /* Record a list of sections which may not be cross referenced.  */
4529
4530 void
4531 lang_add_nocrossref (l)
4532      struct lang_nocrossref *l;
4533 {
4534   struct lang_nocrossrefs *n;
4535
4536   n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4537   n->next = nocrossref_list;
4538   n->list = l;
4539   nocrossref_list = n;
4540
4541   /* Set notice_all so that we get informed about all symbols.  */
4542   link_info.notice_all = true;
4543 }
4544 \f
4545 /* Overlay handling.  We handle overlays with some static variables.  */
4546
4547 /* The overlay virtual address.  */
4548 static etree_type *overlay_vma;
4549
4550 /* The overlay load address.  */
4551 static etree_type *overlay_lma;
4552
4553 /* Whether nocrossrefs is set for this overlay.  */
4554 static int overlay_nocrossrefs;
4555
4556 /* An expression for the maximum section size seen so far.  */
4557 static etree_type *overlay_max;
4558
4559 /* A list of all the sections in this overlay.  */
4560
4561 struct overlay_list
4562 {
4563   struct overlay_list *next;
4564   lang_output_section_statement_type *os;
4565 };
4566
4567 static struct overlay_list *overlay_list;
4568
4569 /* Start handling an overlay.  */
4570
4571 void
4572 lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4573      etree_type *vma_expr;
4574      etree_type *lma_expr;
4575      int nocrossrefs;
4576 {
4577   /* The grammar should prevent nested overlays from occurring.  */
4578   ASSERT (overlay_vma == NULL
4579           && overlay_lma == NULL
4580           && overlay_list == NULL
4581           && overlay_max == NULL);
4582
4583   overlay_vma = vma_expr;
4584   overlay_lma = lma_expr;
4585   overlay_nocrossrefs = nocrossrefs;
4586 }
4587
4588 /* Start a section in an overlay.  We handle this by calling
4589    lang_enter_output_section_statement with the correct VMA and LMA.  */
4590
4591 void
4592 lang_enter_overlay_section (name)
4593      const char *name;
4594 {
4595   struct overlay_list *n;
4596   etree_type *size;
4597
4598   lang_enter_output_section_statement (name, overlay_vma, normal_section,
4599                                        0, 0, 0, overlay_lma);
4600
4601   /* If this is the first section, then base the VMA and LMA of future
4602      sections on this one.  This will work correctly even if `.' is
4603      used in the addresses.  */
4604   if (overlay_list == NULL)
4605     {
4606       overlay_vma = exp_nameop (ADDR, name);
4607       overlay_lma = exp_nameop (LOADADDR, name);
4608     }
4609
4610   /* Remember the section.  */
4611   n = (struct overlay_list *) xmalloc (sizeof *n);
4612   n->os = current_section;
4613   n->next = overlay_list;
4614   overlay_list = n;
4615
4616   size = exp_nameop (SIZEOF, name);
4617
4618   /* Adjust the LMA for the next section.  */
4619   overlay_lma = exp_binop ('+', overlay_lma, size);
4620
4621   /* Arrange to work out the maximum section end address.  */
4622   if (overlay_max == NULL)
4623     overlay_max = size;
4624   else
4625     overlay_max = exp_binop (MAX_K, overlay_max, size);
4626 }
4627
4628 /* Finish a section in an overlay.  There isn't any special to do
4629    here.  */
4630
4631 void
4632 lang_leave_overlay_section (fill, phdrs)
4633      bfd_vma fill;
4634      struct lang_output_section_phdr_list *phdrs;
4635 {
4636   const char *name;
4637   char *clean, *s2;
4638   const char *s1;
4639   char *buf;
4640
4641   name = current_section->name;
4642
4643   lang_leave_output_section_statement (fill, "*default*", phdrs);
4644
4645   /* Define the magic symbols.  */
4646
4647   clean = xmalloc (strlen (name) + 1);
4648   s2 = clean;
4649   for (s1 = name; *s1 != '\0'; s1++)
4650     if (isalnum ((unsigned char) *s1) || *s1 == '_')
4651       *s2++ = *s1;
4652   *s2 = '\0';
4653
4654   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4655   sprintf (buf, "__load_start_%s", clean);
4656   lang_add_assignment (exp_assop ('=', buf,
4657                                   exp_nameop (LOADADDR, name)));
4658
4659   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4660   sprintf (buf, "__load_stop_%s", clean);
4661   lang_add_assignment (exp_assop ('=', buf,
4662                                   exp_binop ('+',
4663                                              exp_nameop (LOADADDR, name),
4664                                              exp_nameop (SIZEOF, name))));
4665
4666   free (clean);
4667 }
4668
4669 /* Finish an overlay.  If there are any overlay wide settings, this
4670    looks through all the sections in the overlay and sets them.  */
4671
4672 void
4673 lang_leave_overlay (fill, memspec, phdrs)
4674      bfd_vma fill;
4675      const char *memspec;
4676      struct lang_output_section_phdr_list *phdrs;
4677 {
4678   lang_memory_region_type *region;
4679   struct overlay_list *l;
4680   struct lang_nocrossref *nocrossref;
4681
4682   if (memspec == NULL)
4683     region = NULL;
4684   else
4685     region = lang_memory_region_lookup (memspec);
4686
4687   nocrossref = NULL;
4688
4689   l = overlay_list;
4690   while (l != NULL)
4691     {
4692       struct overlay_list *next;
4693
4694       if (fill != 0 && l->os->fill == 0)
4695         l->os->fill = fill;
4696       if (region != NULL && l->os->region == NULL)
4697         l->os->region = region;
4698       if (phdrs != NULL && l->os->phdrs == NULL)
4699         l->os->phdrs = phdrs;
4700
4701       if (overlay_nocrossrefs)
4702         {
4703           struct lang_nocrossref *nc;
4704
4705           nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4706           nc->name = l->os->name;
4707           nc->next = nocrossref;
4708           nocrossref = nc;
4709         }
4710
4711       next = l->next;
4712       free (l);
4713       l = next;
4714     }
4715
4716   if (nocrossref != NULL)
4717     lang_add_nocrossref (nocrossref);
4718
4719   /* Update . for the end of the overlay.  */
4720   lang_add_assignment (exp_assop ('=', ".",
4721                                   exp_binop ('+', overlay_vma, overlay_max)));
4722
4723   overlay_vma = NULL;
4724   overlay_lma = NULL;
4725   overlay_nocrossrefs = 0;
4726   overlay_list = NULL;
4727   overlay_max = NULL;
4728 }
4729 \f
4730 /* Version handling.  This is only useful for ELF.  */
4731
4732 /* This global variable holds the version tree that we build.  */
4733
4734 struct bfd_elf_version_tree *lang_elf_version_info;
4735
4736 static int
4737 lang_vers_match_lang_c (expr, sym)
4738      struct bfd_elf_version_expr *expr;
4739      const char *sym;
4740 {
4741   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4742     return 1;
4743   return fnmatch (expr->pattern, sym, 0) == 0;
4744 }
4745
4746 static int
4747 lang_vers_match_lang_cplusplus (expr, sym)
4748      struct bfd_elf_version_expr *expr;
4749      const char *sym;
4750 {
4751   char *alt_sym;
4752   int result;
4753
4754   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4755     return 1;
4756
4757   alt_sym = cplus_demangle(sym, /* DMGL_NO_TPARAMS */ 0);
4758   if (!alt_sym)
4759     {
4760       /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4761          Should we early out false in this case?  */
4762       result = fnmatch (expr->pattern, sym, 0) == 0;
4763     }
4764   else
4765     {
4766       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4767       free (alt_sym);
4768     }
4769
4770   return result;
4771 }
4772
4773 static int
4774 lang_vers_match_lang_java (expr, sym)
4775      struct bfd_elf_version_expr *expr;
4776      const char *sym;
4777 {
4778   char *alt_sym;
4779   int result;
4780
4781   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4782     return 1;
4783
4784   alt_sym = cplus_demangle(sym, DMGL_JAVA);
4785   if (!alt_sym)
4786     {
4787       /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4788          Should we early out false in this case?  */
4789       result = fnmatch (expr->pattern, sym, 0) == 0;
4790     }
4791   else
4792     {
4793       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4794       free (alt_sym);
4795     }
4796
4797   return result;
4798 }
4799
4800 /* This is called for each variable name or match expression.  */
4801
4802 struct bfd_elf_version_expr *
4803 lang_new_vers_regex (orig, new, lang)
4804      struct bfd_elf_version_expr *orig;
4805      const char *new;
4806      const char *lang;
4807 {
4808   struct bfd_elf_version_expr *ret;
4809
4810   ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4811   ret->next = orig;
4812   ret->pattern = new;
4813
4814   if (lang == NULL || strcasecmp (lang, "C") == 0)
4815     ret->match = lang_vers_match_lang_c;
4816   else if (strcasecmp (lang, "C++") == 0)
4817     ret->match = lang_vers_match_lang_cplusplus;
4818   else if (strcasecmp (lang, "Java") == 0)
4819     ret->match = lang_vers_match_lang_java;
4820   else
4821     {
4822       einfo (_("%X%P: unknown language `%s' in version information\n"),
4823              lang);
4824       ret->match = lang_vers_match_lang_c;
4825     }
4826
4827   return ret;
4828 }
4829
4830 /* This is called for each set of variable names and match
4831    expressions.  */
4832
4833 struct bfd_elf_version_tree *
4834 lang_new_vers_node (globals, locals)
4835      struct bfd_elf_version_expr *globals;
4836      struct bfd_elf_version_expr *locals;
4837 {
4838   struct bfd_elf_version_tree *ret;
4839
4840   ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
4841   ret->next = NULL;
4842   ret->name = NULL;
4843   ret->vernum = 0;
4844   ret->globals = globals;
4845   ret->locals = locals;
4846   ret->deps = NULL;
4847   ret->name_indx = (unsigned int) -1;
4848   ret->used = 0;
4849   return ret;
4850 }
4851
4852 /* This static variable keeps track of version indices.  */
4853
4854 static int version_index;
4855
4856 /* This is called when we know the name and dependencies of the
4857    version.  */
4858
4859 void
4860 lang_register_vers_node (name, version, deps)
4861      const char *name;
4862      struct bfd_elf_version_tree *version;
4863      struct bfd_elf_version_deps *deps;
4864 {
4865   struct bfd_elf_version_tree *t, **pp;
4866   struct bfd_elf_version_expr *e1;
4867
4868   /* Make sure this node has a unique name.  */
4869   for (t = lang_elf_version_info; t != NULL; t = t->next)
4870     if (strcmp (t->name, name) == 0)
4871       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
4872
4873   /* Check the global and local match names, and make sure there
4874      aren't any duplicates.  */
4875
4876   for (e1 = version->globals; e1 != NULL; e1 = e1->next)
4877     {
4878       for (t = lang_elf_version_info; t != NULL; t = t->next)
4879         {
4880           struct bfd_elf_version_expr *e2;
4881
4882           for (e2 = t->locals; e2 != NULL; e2 = e2->next)
4883             if (strcmp (e1->pattern, e2->pattern) == 0)
4884               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4885                      e1->pattern);
4886         }
4887     }
4888
4889   for (e1 = version->locals; e1 != NULL; e1 = e1->next)
4890     {
4891       for (t = lang_elf_version_info; t != NULL; t = t->next)
4892         {
4893           struct bfd_elf_version_expr *e2;
4894
4895           for (e2 = t->globals; e2 != NULL; e2 = e2->next)
4896             if (strcmp (e1->pattern, e2->pattern) == 0)
4897               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4898                      e1->pattern);
4899         }
4900     }
4901
4902   version->deps = deps;
4903   version->name = name;
4904   ++version_index;
4905   version->vernum = version_index;
4906
4907   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
4908     ;
4909   *pp = version;
4910 }
4911
4912 /* This is called when we see a version dependency.  */
4913
4914 struct bfd_elf_version_deps *
4915 lang_add_vers_depend (list, name)
4916      struct bfd_elf_version_deps *list;
4917      const char *name;
4918 {
4919   struct bfd_elf_version_deps *ret;
4920   struct bfd_elf_version_tree *t;
4921
4922   ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
4923   ret->next = list;
4924
4925   for (t = lang_elf_version_info; t != NULL; t = t->next)
4926     {
4927       if (strcmp (t->name, name) == 0)
4928         {
4929           ret->version_needed = t;
4930           return ret;
4931         }
4932     }
4933
4934   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
4935
4936   return ret;
4937 }
4938
4939 static void
4940 lang_do_version_exports_section ()
4941 {
4942   struct bfd_elf_version_expr *greg = NULL, *lreg;
4943
4944   LANG_FOR_EACH_INPUT_STATEMENT (is)
4945     {
4946       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
4947       char *contents, *p;
4948       bfd_size_type len;
4949
4950       if (sec == NULL)
4951         continue;
4952
4953       len = bfd_section_size (is->the_bfd, sec);
4954       contents = xmalloc (len);
4955       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
4956         einfo (_("%X%P: unable to read .exports section contents"), sec);
4957
4958       p = contents;
4959       while (p < contents+len)
4960         {
4961           greg = lang_new_vers_regex (greg, p, NULL);
4962           p = strchr (p, '\0') + 1;
4963         }
4964
4965       /* Do not free the contents, as we used them creating the regex.  */
4966
4967       /* Do not include this section in the link.  */
4968       bfd_set_section_flags (is->the_bfd, sec,
4969         bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
4970     }
4971
4972   lreg = lang_new_vers_regex (NULL, "*", NULL);
4973   lang_register_vers_node (command_line.version_exports_section,
4974                            lang_new_vers_node (greg, lreg), NULL);
4975 }