ld/ldlang.c

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