ld/ldlang.c

   1 /* Linker command language support.
   2    Copyright (C) 1991, 92, 93, 94 Free Software Foundation, Inc.
   3
   4 This file is part of GLD, the Gnu Linker.
   5
   6 GLD is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 1, or (at your option)
   9 any later version.
  10
  11 GLD is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GLD; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "libiberty.h"
  23 #include "bfdlink.h"
  24
  25 #include "ld.h"
  26 #include "ldmain.h"
  27 #include "ldgram.h"
  28 #include "ldexp.h"
  29 #include "ldlang.h"
  30 #include "ldemul.h"
  31 #include "ldlex.h"
  32 #include "ldmisc.h"
  33 #include "ldctor.h"
  34 #include "ldfile.h"
  35
  36 /* FORWARDS */
  37 static void print_statements PARAMS ((void));
  38 static void print_statement PARAMS ((lang_statement_union_type *,
  39                                       lang_output_section_statement_type *));
  40 static lang_statement_union_type *new_statement PARAMS ((enum statement_enum,
  41                                                          size_t,
  42                                                          lang_statement_list_type*));
  43
  44
  45 /* LOCALS */
  46 static struct obstack stat_obstack;
  47
  48 #define obstack_chunk_alloc xmalloc
  49 #define obstack_chunk_free free
  50 static CONST char *startup_file;
  51 static lang_statement_list_type input_file_chain;
  52
  53 /* Points to the last statement in the .data section, so we can add
  54    stuff to the data section without pain */
  55 static lang_statement_list_type end_of_data_section_statement_list;
  56
  57 static boolean placed_commons = false;
  58 static lang_output_section_statement_type *default_common_section;
  59 static boolean map_option_f;
  60 static bfd_vma print_dot;
  61 static lang_input_statement_type *first_file;
  62 static lang_statement_list_type lang_output_section_statement;
  63 static CONST char *current_target;
  64 static CONST char *output_target;
  65 static int longest_section_name = 8;
  66 static lang_statement_list_type statement_list;
  67
  68 static void print_size PARAMS ((size_t value));
  69 static void print_alignment PARAMS ((unsigned int value));
  70 static void print_fill PARAMS ((fill_type value));
  71 static void print_section PARAMS ((const char *name));
  72 static void lang_for_each_statement_worker
  73   PARAMS ((void (*func) (lang_statement_union_type *),
  74            lang_statement_union_type *s));
  75 static lang_input_statement_type *new_afile
  76   PARAMS ((const char *name, lang_input_file_enum_type file_type,
  77            const char *target, boolean add_to_list));
  78 static void print_flags PARAMS ((int *ignore_flags));
  79 static void init_os PARAMS ((lang_output_section_statement_type *s));
  80 static void wild_doit PARAMS ((lang_statement_list_type *ptr,
  81                                asection *section,
  82                                lang_output_section_statement_type *output,
  83                                lang_input_statement_type *file));
  84 static void wild_section PARAMS ((lang_wild_statement_type *ptr,
  85                                   const char *section,
  86                                   lang_input_statement_type *file,
  87                                   lang_output_section_statement_type *output));
  88 static lang_input_statement_type *lookup_name PARAMS ((const char *name));
  89 static void load_symbols PARAMS ((lang_input_statement_type *entry));
  90 static void wild PARAMS ((lang_wild_statement_type *s,
  91                           const char *section, const char *file,
  92                           const char *target,
  93                           lang_output_section_statement_type *output));
  94 static bfd *open_output PARAMS ((const char *name));
  95 static void ldlang_open_output PARAMS ((lang_statement_union_type *statement));
  96 static void open_input_bfds PARAMS ((lang_statement_union_type *statement));
  97 static void lang_reasonable_defaults PARAMS ((void));
  98 static void lang_place_undefineds PARAMS ((void));
  99 static void map_input_to_output_sections
 100   PARAMS ((lang_statement_union_type *s,
 101            const char *target,
 102            lang_output_section_statement_type *output_section_statement));
 103 static void print_output_section_statement
 104   PARAMS ((lang_output_section_statement_type *output_section_statement));
 105 static void print_assignment
 106   PARAMS ((lang_assignment_statement_type *assignment,
 107            lang_output_section_statement_type *output_section));
 108 static void print_input_statement PARAMS ((lang_input_statement_type *statm));
 109 static void print_input_section PARAMS ((lang_input_section_type *in));
 110 static void print_fill_statement PARAMS ((lang_fill_statement_type *fill));
 111 static void print_data_statement PARAMS ((lang_data_statement_type *data));
 112 static void print_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_statement PARAMS ((lang_statement_union_type *s,
 118                                      lang_output_section_statement_type *os));
 119 static void print_statements PARAMS ((void));
 120 static bfd_vma insert_pad PARAMS ((lang_statement_union_type **this_ptr,
 121                                    fill_type fill, unsigned int power,
 122                                    asection *output_section_statement,
 123                                    bfd_vma dot));
 124 static bfd_vma size_input_section
 125   PARAMS ((lang_statement_union_type **this_ptr,
 126            lang_output_section_statement_type *output_section_statement,
 127            fill_type fill, bfd_vma dot, boolean relax));
 128 static bfd_vma lang_do_assignments
 129   PARAMS ((lang_statement_union_type * s,
 130            lang_output_section_statement_type *output_section_statement,
 131            fill_type fill,
 132            bfd_vma dot));
 133 static void lang_finish PARAMS ((void));
 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 reset_memory_regions PARAMS ((void));
 140
 141 /* EXPORTS */
 142 lang_output_section_statement_type *abs_output_section;
 143 lang_statement_list_type *stat_ptr = &statement_list;
 144 lang_statement_list_type file_chain = { 0 };
 145 static const char *entry_symbol = 0;
 146 boolean lang_has_input_file = false;
 147 boolean had_output_filename = false;
 148 boolean lang_float_flag = false;
 149 boolean delete_output_file_on_failure = false;
 150
 151 etree_type *base; /* Relocation base - or null */
 152
 153
 154 #if defined(__STDC__) || defined(ALMOST_STDC)
 155 #define cat(a,b) a##b
 156 #else
 157 #define cat(a,b) a/**/b
 158 #endif
 159
 160 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
 161
 162 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
 163
 164 #define outside_symbol_address(q) ((q)->value +   outside_section_address(q->section))
 165
 166 PTR
 167 stat_alloc (size)
 168      size_t size;
 169 {
 170   return obstack_alloc (&stat_obstack, size);
 171 }
 172
 173 static void
 174 print_size (value)
 175      size_t value;
 176 {
 177   fprintf (config.map_file, "%5x", (unsigned) value);
 178 }
 179
 180 static void
 181 print_alignment (value)
 182      unsigned int value;
 183 {
 184   fprintf (config.map_file, "2**%1u", value);
 185 }
 186
 187 static void
 188 print_fill (value)
 189      fill_type value;
 190 {
 191   fprintf (config.map_file, "%04x", (unsigned) value);
 192 }
 193
 194 static void
 195 print_section (name)
 196      CONST char *name;
 197 {
 198   fprintf (config.map_file, "%*s", -longest_section_name, name);
 199 }
 200
 201 /*----------------------------------------------------------------------
 202   lang_for_each_statement walks the parse tree and calls the provided
 203   function for each node
 204 */
 205
 206 static void
 207 lang_for_each_statement_worker (func, s)
 208      void (*func) PARAMS ((lang_statement_union_type *));
 209      lang_statement_union_type *s;
 210 {
 211   for (; s != (lang_statement_union_type *) NULL; s = s->next)
 212     {
 213       func (s);
 214
 215       switch (s->header.type)
 216         {
 217         case lang_constructors_statement_enum:
 218           lang_for_each_statement_worker (func, constructor_list.head);
 219           break;
 220         case lang_output_section_statement_enum:
 221           lang_for_each_statement_worker
 222             (func,
 223              s->output_section_statement.children.head);
 224           break;
 225         case lang_wild_statement_enum:
 226           lang_for_each_statement_worker
 227             (func,
 228              s->wild_statement.children.head);
 229           break;
 230         case lang_data_statement_enum:
 231         case lang_reloc_statement_enum:
 232         case lang_object_symbols_statement_enum:
 233         case lang_output_statement_enum:
 234         case lang_target_statement_enum:
 235         case lang_input_section_enum:
 236         case lang_input_statement_enum:
 237         case lang_assignment_statement_enum:
 238         case lang_padding_statement_enum:
 239         case lang_address_statement_enum:
 240           break;
 241         default:
 242           FAIL ();
 243           break;
 244         }
 245     }
 246 }
 247
 248 void
 249 lang_for_each_statement (func)
 250      void (*func) PARAMS ((lang_statement_union_type *));
 251 {
 252   lang_for_each_statement_worker (func,
 253                                   statement_list.head);
 254 }
 255
 256 /*----------------------------------------------------------------------*/
 257 void
 258 lang_list_init (list)
 259      lang_statement_list_type *list;
 260 {
 261   list->head = (lang_statement_union_type *) NULL;
 262   list->tail = &list->head;
 263 }
 264
 265 /*----------------------------------------------------------------------
 266
 267   build a new statement node for the parse tree
 268
 269  */
 270
 271 static
 272 lang_statement_union_type *
 273 new_statement (type, size, list)
 274      enum statement_enum type;
 275      size_t size;
 276      lang_statement_list_type * list;
 277 {
 278   lang_statement_union_type *new = (lang_statement_union_type *)
 279   stat_alloc (size);
 280
 281   new->header.type = type;
 282   new->header.next = (lang_statement_union_type *) NULL;
 283   lang_statement_append (list, new, &new->header.next);
 284   return new;
 285 }
 286
 287 /*
 288   Build a new input file node for the language. There are several ways
 289   in which we treat an input file, eg, we only look at symbols, or
 290   prefix it with a -l etc.
 291
 292   We can be supplied with requests for input files more than once;
 293   they may, for example be split over serveral lines like foo.o(.text)
 294   foo.o(.data) etc, so when asked for a file we check that we havn't
 295   got it already so we don't duplicate the bfd.
 296
 297  */
 298 static lang_input_statement_type *
 299 new_afile (name, file_type, target, add_to_list)
 300      CONST char *name;
 301      lang_input_file_enum_type file_type;
 302      CONST char *target;
 303      boolean add_to_list;
 304 {
 305   lang_input_statement_type *p;
 306
 307   if (add_to_list)
 308     p = new_stat (lang_input_statement, stat_ptr);
 309   else
 310     {
 311       p = ((lang_input_statement_type *)
 312            stat_alloc (sizeof (lang_input_statement_type)));
 313       p->header.next = NULL;
 314     }
 315
 316   lang_has_input_file = true;
 317   p->target = target;
 318   p->complained = false;
 319   switch (file_type)
 320     {
 321     case lang_input_file_is_symbols_only_enum:
 322       p->filename = name;
 323       p->is_archive = false;
 324       p->real = true;
 325       p->local_sym_name = name;
 326       p->just_syms_flag = true;
 327       p->search_dirs_flag = false;
 328       break;
 329     case lang_input_file_is_fake_enum:
 330       p->filename = name;
 331       p->is_archive = false;
 332       p->real = false;
 333       p->local_sym_name = name;
 334       p->just_syms_flag = false;
 335       p->search_dirs_flag = false;
 336       break;
 337     case lang_input_file_is_l_enum:
 338       p->is_archive = true;
 339       p->filename = name;
 340       p->real = true;
 341       p->local_sym_name = concat ("-l", name, (const char *) NULL);
 342       p->just_syms_flag = false;
 343       p->search_dirs_flag = true;
 344       break;
 345     case lang_input_file_is_marker_enum:
 346       p->filename = name;
 347       p->is_archive = false;
 348       p->real = false;
 349       p->local_sym_name = name;
 350       p->just_syms_flag = false;
 351       p->search_dirs_flag = true;
 352       break;
 353     case lang_input_file_is_search_file_enum:
 354       p->filename = name;
 355       p->is_archive = false;
 356       p->real = true;
 357       p->local_sym_name = name;
 358       p->just_syms_flag = false;
 359       p->search_dirs_flag = true;
 360       break;
 361     case lang_input_file_is_file_enum:
 362       p->filename = name;
 363       p->is_archive = false;
 364       p->real = true;
 365       p->local_sym_name = name;
 366       p->just_syms_flag = false;
 367       p->search_dirs_flag = false;
 368       break;
 369     default:
 370       FAIL ();
 371     }
 372   p->the_bfd = (bfd *) NULL;
 373   p->asymbols = (asymbol **) NULL;
 374   p->next_real_file = (lang_statement_union_type *) NULL;
 375   p->next = (lang_statement_union_type *) NULL;
 376   p->symbol_count = 0;
 377   p->common_output_section = (asection *) NULL;
 378   p->loaded = false;
 379   lang_statement_append (&input_file_chain,
 380                          (lang_statement_union_type *) p,
 381                          &p->next_real_file);
 382   return p;
 383 }
 384
 385 lang_input_statement_type *
 386 lang_add_input_file (name, file_type, target)
 387      CONST char *name;
 388      lang_input_file_enum_type file_type;
 389      CONST char *target;
 390 {
 391   lang_has_input_file = true;
 392   return new_afile (name, file_type, target, true);
 393 }
 394
 395 /* Build enough state so that the parser can build its tree */
 396 void
 397 lang_init ()
 398 {
 399   obstack_begin (&stat_obstack, 1000);
 400
 401   stat_ptr = &statement_list;
 402
 403   lang_list_init (stat_ptr);
 404
 405   lang_list_init (&input_file_chain);
 406   lang_list_init (&lang_output_section_statement);
 407   lang_list_init (&file_chain);
 408   first_file = lang_add_input_file ((char *) NULL,
 409                                     lang_input_file_is_marker_enum,
 410                                     (char *) NULL);
 411   abs_output_section = lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
 412
 413   abs_output_section->bfd_section = &bfd_abs_section;
 414
 415 }
 416
 417 /*----------------------------------------------------------------------
 418  A region is an area of memory declared with the
 419  MEMORY {  name:org=exp, len=exp ... }
 420  syntax.
 421
 422  We maintain a list of all the regions here
 423
 424  If no regions are specified in the script, then the default is used
 425  which is created when looked up to be the entire data space
 426 */
 427
 428 static lang_memory_region_type *lang_memory_region_list;
 429 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
 430
 431 lang_memory_region_type *
 432 lang_memory_region_lookup (name)
 433      CONST char *CONST name;
 434 {
 435
 436   lang_memory_region_type *p = lang_memory_region_list;
 437
 438   for (p = lang_memory_region_list;
 439        p != (lang_memory_region_type *) NULL;
 440        p = p->next)
 441     {
 442       if (strcmp (p->name, name) == 0)
 443         {
 444           return p;
 445         }
 446     }
 447   if (strcmp (name, "*default*") == 0)
 448     {
 449       /* This is the default region, dig out first one on the list */
 450       if (lang_memory_region_list != (lang_memory_region_type *) NULL)
 451         {
 452           return lang_memory_region_list;
 453         }
 454     }
 455   {
 456     lang_memory_region_type *new =
 457     (lang_memory_region_type *) stat_alloc ((bfd_size_type) (sizeof (lang_memory_region_type)));
 458
 459     new->name = buystring (name);
 460     new->next = (lang_memory_region_type *) NULL;
 461
 462     *lang_memory_region_list_tail = new;
 463     lang_memory_region_list_tail = &new->next;
 464     new->origin = 0;
 465     new->length = ~(bfd_size_type)0;
 466     new->current = 0;
 467     new->had_full_message = false;
 468
 469     return new;
 470   }
 471 }
 472
 473
 474 lang_output_section_statement_type *
 475 lang_output_section_find (name)
 476      CONST char *CONST name;
 477 {
 478   lang_statement_union_type *u;
 479   lang_output_section_statement_type *lookup;
 480
 481   for (u = lang_output_section_statement.head;
 482        u != (lang_statement_union_type *) NULL;
 483        u = lookup->next)
 484     {
 485       lookup = &u->output_section_statement;
 486       if (strcmp (name, lookup->name) == 0)
 487         {
 488           return lookup;
 489         }
 490     }
 491   return (lang_output_section_statement_type *) NULL;
 492 }
 493
 494 lang_output_section_statement_type *
 495 lang_output_section_statement_lookup (name)
 496      CONST char *CONST name;
 497 {
 498   lang_output_section_statement_type *lookup;
 499
 500   lookup = lang_output_section_find (name);
 501   if (lookup == (lang_output_section_statement_type *) NULL)
 502     {
 503
 504       lookup = (lang_output_section_statement_type *)
 505         new_stat (lang_output_section_statement, stat_ptr);
 506       lookup->region = (lang_memory_region_type *) NULL;
 507       lookup->fill = 0;
 508       lookup->block_value = 1;
 509       lookup->name = name;
 510
 511       lookup->next = (lang_statement_union_type *) NULL;
 512       lookup->bfd_section = (asection *) NULL;
 513       lookup->processed = false;
 514       lookup->loadable = 1;
 515       lookup->addr_tree = (etree_type *) NULL;
 516       lang_list_init (&lookup->children);
 517
 518       lookup->memspec = (CONST char *) NULL;
 519       lookup->flags = 0;
 520       lookup->subsection_alignment = -1;
 521       lookup->section_alignment = -1;
 522       lookup->load_base = (union etree_union *) NULL;
 523
 524       lang_statement_append (&lang_output_section_statement,
 525                              (lang_statement_union_type *) lookup,
 526                              &lookup->next);
 527     }
 528   return lookup;
 529 }
 530
 531 /*ARGSUSED*/
 532 static void
 533 print_flags (ignore_flags)
 534      int *ignore_flags;
 535 {
 536   fprintf (config.map_file, "(");
 537 #if 0
 538   if (flags->flag_read)
 539     fprintf (outfile, "R");
 540   if (flags->flag_write)
 541     fprintf (outfile, "W");
 542   if (flags->flag_executable)
 543     fprintf (outfile, "X");
 544   if (flags->flag_loadable)
 545     fprintf (outfile, "L");
 546 #endif
 547  fprintf (config.map_file, ")");
 548 }
 549
 550 void
 551 lang_map ()
 552 {
 553   lang_memory_region_type *m;
 554
 555   fprintf (config.map_file, "**MEMORY CONFIGURATION**\n\n");
 556 #ifdef HOST_64_BIT
 557   fprintf (config.map_file, "name\t\torigin\t\tlength\t\tattributes\n");
 558 #else
 559   fprintf (config.map_file,
 560            "name\t\torigin   length   r_size   c_size    is    attributes\n");
 561
 562 #endif
 563   for (m = lang_memory_region_list;
 564        m != (lang_memory_region_type *) NULL;
 565        m = m->next)
 566     {
 567       fprintf (config.map_file, "%-16s", m->name);
 568       print_address (m->origin);
 569       print_space ();
 570       print_address ((bfd_vma)m->length);
 571       print_space ();
 572       print_address ((bfd_vma)m->old_length);
 573       print_space();
 574       print_address (m->current - m->origin);
 575       print_space();
 576       if (m->old_length)
 577        fprintf (config.map_file, " %2d%%  ",
 578                 (int) ((m->current - m->origin) * 100 / m->old_length));
 579       print_flags (&m->flags);
 580       fprintf (config.map_file, "\n");
 581     }
 582   fprintf (config.map_file, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
 583   fprintf (config.map_file, "output   input     virtual\n");
 584   fprintf (config.map_file, "section  section   address    tsize\n\n");
 585
 586   print_statements ();
 587
 588 }
 589
 590 /*
 591  *
 592  */
 593 static void
 594 init_os (s)
 595      lang_output_section_statement_type * s;
 596 {
 597 /*  asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
 598   section_userdata_type *new =
 599   (section_userdata_type *)
 600   stat_alloc ((bfd_size_type) (sizeof (section_userdata_type)));
 601
 602   s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
 603   if (s->bfd_section == (asection *) NULL)
 604     s->bfd_section = bfd_make_section (output_bfd, s->name);
 605   if (s->bfd_section == (asection *) NULL)
 606     {
 607       einfo ("%P%F: output format %s cannot represent section called %s\n",
 608              output_bfd->xvec->name, s->name);
 609     }
 610   s->bfd_section->output_section = s->bfd_section;
 611 /*  s->bfd_section->flags = s->flags;*/
 612
 613   /* We initialize an output sections output offset to minus its own */
 614   /* vma to allow us to output a section through itself */
 615   s->bfd_section->output_offset = 0;
 616   get_userdata (s->bfd_section) = (PTR) new;
 617
 618 }
 619
 620 /***********************************************************************
 621   The wild routines.
 622
 623   These expand statements like *(.text) and foo.o to a list of
 624   explicit actions, like foo.o(.text), bar.o(.text) and
 625   foo.o(.text,.data) .
 626
 627   The toplevel routine, wild, takes a statement, section, file and
 628   target. If either the section or file is null it is taken to be the
 629   wildcard. Seperate lang_input_section statements are created for
 630   each part of the expanstion, and placed after the statement provided.
 631
 632 */
 633
 634 static void
 635 wild_doit (ptr, section, output, file)
 636      lang_statement_list_type * ptr;
 637      asection * section;
 638      lang_output_section_statement_type * output;
 639      lang_input_statement_type * file;
 640 {
 641   if (output->bfd_section == (asection *) NULL)
 642     init_os (output);
 643
 644   if (section != (asection *) NULL
 645       && section->output_section == (asection *) NULL)
 646   {
 647     /* Add a section reference to the list */
 648     lang_input_section_type *new = new_stat (lang_input_section, ptr);
 649
 650     new->section = section;
 651     new->ifile = file;
 652     section->output_section = output->bfd_section;
 653
 654     /* We don't copy the SEC_NEVER_LOAD flag from an input section to
 655        an output section, because we want to be able to include a
 656        SEC_NEVER_LOAD section in the middle of an otherwise loaded
 657        section (I don't know why we want to do this, but we do).
 658        build_link_order in ldwrite.c handles this case by turning the
 659        embedded SEC_NEVER_LOAD section into a fill.  */
 660     section->output_section->flags |=
 661       section->flags & (flagword) (~ SEC_NEVER_LOAD);
 662
 663     if (!output->loadable)
 664     {
 665       /* Turn off load flag */
 666       output->bfd_section->flags &= ~SEC_LOAD;
 667       output->bfd_section->flags |= SEC_NEVER_LOAD;
 668     }
 669     if (section->alignment_power > output->bfd_section->alignment_power)
 670     {
 671       output->bfd_section->alignment_power = section->alignment_power;
 672     }
 673     /* If supplied an aligmnet, then force it */
 674     if (output->section_alignment != -1)
 675     {
 676       output->bfd_section->alignment_power = output->section_alignment;
 677     }
 678   }
 679 }
 680
 681 static void
 682 wild_section (ptr, section, file, output)
 683      lang_wild_statement_type * ptr;
 684      CONST char *section;
 685      lang_input_statement_type * file;
 686      lang_output_section_statement_type * output;
 687 {
 688   asection *s;
 689
 690   if (file->just_syms_flag == false)
 691     {
 692       if (section == (char *) NULL)
 693         {
 694           /* Do the creation to all sections in the file */
 695           for (s = file->the_bfd->sections; s != NULL; s = s->next)
 696             {
 697               /* except for bss */
 698               if ((s->flags & SEC_IS_COMMON)  == 0)
 699                 {
 700                   wild_doit (&ptr->children, s, output, file);
 701                 }
 702             }
 703         }
 704       else
 705         {
 706           /* Do the creation to the named section only */
 707           s = bfd_get_section_by_name (file->the_bfd, section);
 708           if (s != NULL)
 709             wild_doit (&ptr->children, s, output, file);
 710         }
 711     }
 712 }
 713
 714 /* passed a file name (which must have been seen already and added to
 715    the statement tree. We will see if it has been opened already and
 716    had its symbols read. If not then we'll read it.
 717
 718    Archives are pecuilar here. We may open them once, but if they do
 719    not define anything we need at the time, they won't have all their
 720    symbols read. If we need them later, we'll have to redo it.
 721    */
 722 static lang_input_statement_type *
 723 lookup_name (name)
 724      CONST char *name;
 725 {
 726   lang_input_statement_type *search;
 727
 728   for (search = (lang_input_statement_type *) input_file_chain.head;
 729        search != (lang_input_statement_type *) NULL;
 730        search = (lang_input_statement_type *) search->next_real_file)
 731     {
 732       if (search->filename == (char *) NULL && name == (char *) NULL)
 733         return search;
 734       if (search->filename != (char *) NULL
 735           && name != (char *) NULL
 736           && strcmp (search->filename, name) == 0)
 737         break;
 738     }
 739
 740   if (search == (lang_input_statement_type *) NULL)
 741     search = new_afile (name, lang_input_file_is_file_enum, default_target,
 742                         false);
 743
 744   /* If we have already added this file, or this file is not real
 745      (FIXME: can that ever actually happen?) or the name is NULL
 746      (FIXME: can that ever actually happen?) don't add this file.  */
 747   if (search->loaded
 748       || ! search->real
 749       || search->filename == (const char *) NULL)
 750     return search;
 751
 752   load_symbols (search);
 753
 754   return search;
 755 }
 756
 757 /* Get the symbols for an input file.  */
 758
 759 static void
 760 load_symbols (entry)
 761      lang_input_statement_type *entry;
 762 {
 763   if (entry->loaded)
 764     return;
 765
 766   ldfile_open_file (entry);
 767
 768   if (bfd_check_format (entry->the_bfd, bfd_object))
 769     {
 770       ldlang_add_file (entry);
 771       if (trace_files || trace_file_tries)
 772         info_msg ("%I\n", entry);
 773     }
 774   else if (bfd_check_format (entry->the_bfd, bfd_archive))
 775     {
 776       /* There is nothing to do here; the add_symbols routine will
 777          call ldlang_add_file (via the add_archive_element callback)
 778          for each element of the archive which is used.  */
 779     }
 780   else
 781     einfo ("%F%B: file not recognized: %E\n", entry->the_bfd);
 782
 783   if (bfd_link_add_symbols (entry->the_bfd, &link_info) == false)
 784     einfo ("%F%B: could not read symbols: %E\n", entry->the_bfd);
 785
 786   entry->loaded = true;
 787 }
 788
 789 static void
 790 wild (s, section, file, target, output)
 791      lang_wild_statement_type * s;
 792      CONST char *section;
 793      CONST char *file;
 794      CONST char *target;
 795      lang_output_section_statement_type * output;
 796 {
 797   lang_input_statement_type *f;
 798
 799   if (file == (char *) NULL)
 800     {
 801       /* Perform the iteration over all files in the list */
 802       for (f = (lang_input_statement_type *) file_chain.head;
 803            f != (lang_input_statement_type *) NULL;
 804            f = (lang_input_statement_type *) f->next)
 805         {
 806           wild_section (s, section, f, output);
 807         }
 808     }
 809   else
 810     {
 811       /* Perform the iteration over a single file */
 812       wild_section (s, section, lookup_name (file), output);
 813     }
 814   if (section != (char *) NULL
 815       && strcmp (section, "COMMON") == 0
 816    && default_common_section == (lang_output_section_statement_type *) NULL)
 817     {
 818       /* Remember the section that common is going to incase we later
 819          get something which doesn't know where to put it */
 820       default_common_section = output;
 821     }
 822 }
 823
 824 /*
 825   read in all the files
 826   */
 827
 828 static bfd *
 829 open_output (name)
 830      CONST char *name;
 831 {
 832   bfd *output;
 833
 834   if (output_target == (char *) NULL)
 835     {
 836       if (current_target != (char *) NULL)
 837         output_target = current_target;
 838       else
 839         output_target = default_target;
 840     }
 841   output = bfd_openw (name, output_target);
 842
 843   if (output == (bfd *) NULL)
 844     {
 845       if (bfd_get_error () == bfd_error_invalid_target)
 846         {
 847           einfo ("%P%F: target %s not found\n", output_target);
 848         }
 849       einfo ("%P%F: cannot open output file %s: %E\n", name);
 850     }
 851
 852   delete_output_file_on_failure = 1;
 853
 854   /*  output->flags |= D_PAGED;*/
 855
 856   if (! bfd_set_format (output, bfd_object))
 857     einfo ("%P%F:%s: can not make object file: %E\n", name);
 858   if (! bfd_set_arch_mach (output,
 859                            ldfile_output_architecture,
 860                            ldfile_output_machine))
 861     einfo ("%P%F:%s: can not set architecture: %E\n", name);
 862
 863   link_info.hash = bfd_link_hash_table_create (output);
 864   if (link_info.hash == (struct bfd_link_hash_table *) NULL)
 865     einfo ("%P%F: can not create link hash table: %E\n");
 866
 867   bfd_set_gp_size (output, g_switch_value);
 868   return output;
 869 }
 870
 871
 872
 873
 874 static void
 875 ldlang_open_output (statement)
 876      lang_statement_union_type * statement;
 877 {
 878   switch (statement->header.type)
 879     {
 880     case lang_output_statement_enum:
 881       ASSERT (output_bfd == (bfd *) NULL);
 882       output_bfd = open_output (statement->output_statement.name);
 883       ldemul_set_output_arch ();
 884       if (config.magic_demand_paged && !link_info.relocateable)
 885         output_bfd->flags |= D_PAGED;
 886       else
 887         output_bfd->flags &= ~D_PAGED;
 888       if (config.text_read_only)
 889         output_bfd->flags |= WP_TEXT;
 890       else
 891         output_bfd->flags &= ~WP_TEXT;
 892       break;
 893
 894     case lang_target_statement_enum:
 895       current_target = statement->target_statement.target;
 896       break;
 897     default:
 898       break;
 899     }
 900 }
 901
 902 static void
 903 open_input_bfds (statement)
 904      lang_statement_union_type * statement;
 905 {
 906   switch (statement->header.type)
 907     {
 908       case lang_target_statement_enum:
 909       current_target = statement->target_statement.target;
 910       break;
 911     case lang_wild_statement_enum:
 912       /* Maybe we should load the file's symbols */
 913       if (statement->wild_statement.filename)
 914         {
 915           (void) lookup_name (statement->wild_statement.filename);
 916         }
 917       break;
 918     case lang_input_statement_enum:
 919       if (statement->input_statement.real == true)
 920         {
 921           statement->input_statement.target = current_target;
 922           load_symbols (&statement->input_statement);
 923         }
 924       break;
 925     default:
 926       break;
 927     }
 928 }
 929
 930 /* If there are [COMMONS] statements, put a wild one into the bss section */
 931
 932 static void
 933 lang_reasonable_defaults ()
 934 {
 935 #if 0
 936   lang_output_section_statement_lookup (".text");
 937   lang_output_section_statement_lookup (".data");
 938
 939   default_common_section =
 940     lang_output_section_statement_lookup (".bss");
 941
 942
 943   if (placed_commons == false)
 944     {
 945       lang_wild_statement_type *new =
 946       new_stat (lang_wild_statement,
 947                 &default_common_section->children);
 948
 949       new->section_name = "COMMON";
 950       new->filename = (char *) NULL;
 951       lang_list_init (&new->children);
 952     }
 953 #endif
 954
 955 }
 956
 957 /*
 958  Add the supplied name to the symbol table as an undefined reference.
 959  Remove items from the chain as we open input bfds
 960  */
 961 typedef struct ldlang_undef_chain_list
 962 {
 963   struct ldlang_undef_chain_list *next;
 964   char *name;
 965 }                       ldlang_undef_chain_list_type;
 966
 967 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
 968
 969 void
 970 ldlang_add_undef (name)
 971      CONST char *CONST name;
 972 {
 973   ldlang_undef_chain_list_type *new =
 974   (ldlang_undef_chain_list_type
 975    *) stat_alloc ((bfd_size_type) (sizeof (ldlang_undef_chain_list_type)));
 976
 977   new->next = ldlang_undef_chain_list_head;
 978   ldlang_undef_chain_list_head = new;
 979
 980   new->name = buystring (name);
 981 }
 982
 983 /* Run through the list of undefineds created above and place them
 984    into the linker hash table as undefined symbols belonging to the
 985    script file.
 986 */
 987 static void
 988 lang_place_undefineds ()
 989 {
 990   ldlang_undef_chain_list_type *ptr;
 991
 992   for (ptr = ldlang_undef_chain_list_head;
 993        ptr != (ldlang_undef_chain_list_type *) NULL;
 994        ptr = ptr->next)
 995     {
 996       struct bfd_link_hash_entry *h;
 997
 998       h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
 999       if (h == (struct bfd_link_hash_entry *) NULL)
1000         einfo ("%P%F: bfd_link_hash_lookup failed: %E");
1001       if (h->type == bfd_link_hash_new)
1002         {
1003           h->type = bfd_link_hash_undefined;
1004           h->u.undef.abfd = NULL;
1005           bfd_link_add_undef (link_info.hash, h);
1006         }
1007     }
1008 }
1009
1010 /* Open input files and attatch to output sections */
1011 static void
1012 map_input_to_output_sections (s, target, output_section_statement)
1013      lang_statement_union_type * s;
1014      CONST char *target;
1015      lang_output_section_statement_type * output_section_statement;
1016 {
1017   for (; s != (lang_statement_union_type *) NULL; s = s->next)
1018     {
1019       switch (s->header.type)
1020         {
1021
1022
1023         case lang_wild_statement_enum:
1024           wild (&s->wild_statement, s->wild_statement.section_name,
1025                 s->wild_statement.filename, target,
1026                 output_section_statement);
1027
1028           break;
1029         case lang_constructors_statement_enum:
1030           map_input_to_output_sections (constructor_list.head,
1031                                         target,
1032                                         output_section_statement);
1033           break;
1034         case lang_output_section_statement_enum:
1035           map_input_to_output_sections (s->output_section_statement.children.head,
1036                                         target,
1037                                         &s->output_section_statement);
1038           break;
1039         case lang_output_statement_enum:
1040           break;
1041         case lang_target_statement_enum:
1042           target = s->target_statement.target;
1043           break;
1044         case lang_fill_statement_enum:
1045         case lang_input_section_enum:
1046         case lang_object_symbols_statement_enum:
1047         case lang_data_statement_enum:
1048         case lang_reloc_statement_enum:
1049         case lang_assignment_statement_enum:
1050         case lang_padding_statement_enum:
1051         case lang_input_statement_enum:
1052           if (output_section_statement != NULL
1053               && output_section_statement->bfd_section == NULL)
1054             init_os (output_section_statement);
1055           break;
1056         case lang_afile_asection_pair_statement_enum:
1057           FAIL ();
1058           break;
1059         case lang_address_statement_enum:
1060           /* Mark the specified section with the supplied address */
1061           {
1062             lang_output_section_statement_type *os =
1063               lang_output_section_statement_lookup
1064                 (s->address_statement.section_name);
1065
1066             if (os->bfd_section == NULL)
1067               init_os (os);
1068             os->addr_tree = s->address_statement.address;
1069           }
1070           break;
1071         }
1072     }
1073 }
1074
1075 static void
1076 print_output_section_statement (output_section_statement)
1077      lang_output_section_statement_type * output_section_statement;
1078 {
1079   asection *section = output_section_statement->bfd_section;
1080
1081   print_nl ();
1082   print_section (output_section_statement->name);
1083
1084
1085   if (section)
1086   {
1087     print_dot = section->vma;
1088     print_space ();
1089     print_section ("");
1090     print_space ();
1091     print_address (section->vma);
1092     print_space ();
1093     print_size (section->_raw_size);
1094     print_space();
1095     print_size(section->_cooked_size);
1096     print_space ();
1097     print_alignment (section->alignment_power);
1098     print_space ();
1099 #if 0
1100     fprintf (config.map_file, "%s flags", output_section_statement->region->name);
1101     print_flags (stdout, &output_section_statement->flags);
1102 #endif
1103     if (section->flags & SEC_LOAD)
1104      fprintf (config.map_file, "load ");
1105     if (section->flags & SEC_ALLOC)
1106      fprintf (config.map_file, "alloc ");
1107     if (section->flags & SEC_RELOC)
1108      fprintf (config.map_file, "reloc ");
1109     if (section->flags & SEC_HAS_CONTENTS)
1110      fprintf (config.map_file, "contents ");
1111
1112   }
1113   else
1114   {
1115     fprintf (config.map_file, " (no attached output section)");
1116   }
1117   print_nl ();
1118   if (output_section_statement->load_base)
1119     {
1120       int b = exp_get_value_int(output_section_statement->load_base,
1121                                 0, "output base", lang_final_phase_enum);
1122       printf("Output address   %08x\n", b);
1123     }
1124   if (output_section_statement->section_alignment >= 0
1125       || output_section_statement->section_alignment >= 0)
1126   {
1127     printf("\t\t\t\t\tforced alignment ");
1128     if ( output_section_statement->section_alignment >= 0)
1129     {
1130       printf("section 2**%d ",output_section_statement->section_alignment );
1131     }
1132     if ( output_section_statement->subsection_alignment >= 0)
1133     {
1134       printf("subsection 2**%d ",output_section_statement->subsection_alignment );
1135     }
1136
1137     print_nl ();
1138   }
1139   print_statement (output_section_statement->children.head,
1140                    output_section_statement);
1141
1142 }
1143
1144 static void
1145 print_assignment (assignment, output_section)
1146      lang_assignment_statement_type * assignment;
1147      lang_output_section_statement_type * output_section;
1148 {
1149   etree_value_type result;
1150
1151   print_section ("");
1152   print_space ();
1153   print_section ("");
1154   print_space ();
1155   print_address (print_dot);
1156   print_space ();
1157   result = exp_fold_tree (assignment->exp->assign.src,
1158                           output_section,
1159                           lang_final_phase_enum,
1160                           print_dot,
1161                           &print_dot);
1162
1163   if (result.valid)
1164     {
1165       print_address (result.value);
1166     }
1167   else
1168     {
1169       fprintf (config.map_file, "*undefined*");
1170     }
1171   print_space ();
1172   exp_print_tree (assignment->exp);
1173
1174   fprintf (config.map_file, "\n");
1175 }
1176
1177 static void
1178 print_input_statement (statm)
1179      lang_input_statement_type * statm;
1180 {
1181   if (statm->filename != (char *) NULL)
1182     {
1183       fprintf (config.map_file, "LOAD %s\n", statm->filename);
1184     }
1185 }
1186
1187 /* Print all the defined symbols for the abfd provided by in the supplied
1188    section.
1189 */
1190
1191 static boolean
1192 print_one_symbol (hash_entry, ptr)
1193 struct  bfd_link_hash_entry *hash_entry;
1194 PTR ptr;
1195 {
1196   asection * sec = (asection *)ptr;
1197
1198   if (hash_entry->type == bfd_link_hash_defined)
1199     {
1200       if (sec == hash_entry->u.def.section) {
1201         print_section ("");
1202         fprintf (config.map_file, " ");
1203         print_section ("");
1204         fprintf (config.map_file, " ");
1205         print_address (hash_entry->u.def.value + outside_section_address (sec));
1206         fprintf (config.map_file, "              %s", hash_entry->root.string);
1207         print_nl ();
1208       }
1209     }
1210
1211   return true;
1212 }
1213
1214 static void
1215 print_input_section (in)
1216      lang_input_section_type * in;
1217 {
1218   asection *i = in->section;
1219   bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
1220
1221   if (size != 0)
1222     {
1223       print_section ("");
1224       fprintf (config.map_file, " ");
1225       print_section (i->name);
1226       fprintf (config.map_file, " ");
1227       if (i->output_section)
1228         {
1229           print_address (i->output_section->vma + i->output_offset);
1230           fprintf (config.map_file, " ");
1231           print_size (i->_raw_size);
1232           fprintf (config.map_file, " ");
1233           print_size(i->_cooked_size);
1234           fprintf (config.map_file, " ");
1235           print_alignment (i->alignment_power);
1236           fprintf (config.map_file, " ");
1237           if (in->ifile)
1238             {
1239
1240               bfd *abfd = in->ifile->the_bfd;
1241
1242               if (in->ifile->just_syms_flag == true)
1243                 {
1244                   fprintf (config.map_file, "symbols only ");
1245                 }
1246
1247               fprintf (config.map_file, " %s ", abfd->xvec->name);
1248               if (abfd->my_archive != (bfd *) NULL)
1249                 {
1250                   fprintf (config.map_file, "[%s]%s", abfd->my_archive->filename,
1251                            abfd->filename);
1252                 }
1253               else
1254                 {
1255                   fprintf (config.map_file, "%s", abfd->filename);
1256                 }
1257               fprintf (config.map_file, "(overhead %d bytes)", (int) bfd_alloc_size (abfd));
1258               print_nl ();
1259
1260               /* Print all the symbols */
1261               bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
1262             }
1263           else
1264             {
1265               print_nl ();
1266             }
1267
1268
1269           print_dot = outside_section_address (i) + size;
1270         }
1271       else
1272         {
1273           fprintf (config.map_file, "No output section allocated\n");
1274         }
1275     }
1276 }
1277
1278 static void
1279 print_fill_statement (fill)
1280      lang_fill_statement_type * fill;
1281 {
1282   fprintf (config.map_file, "FILL mask ");
1283   print_fill (fill->fill);
1284 }
1285
1286 static void
1287 print_data_statement (data)
1288      lang_data_statement_type * data;
1289 {
1290 /*  bfd_vma value; */
1291   print_section ("");
1292   print_space ();
1293   print_section ("");
1294   print_space ();
1295 /*  ASSERT(print_dot == data->output_vma);*/
1296
1297   print_address (data->output_vma + data->output_section->vma);
1298   print_space ();
1299   print_address (data->value);
1300   print_space ();
1301   switch (data->type)
1302     {
1303     case BYTE:
1304       fprintf (config.map_file, "BYTE ");
1305       print_dot += BYTE_SIZE;
1306       break;
1307     case SHORT:
1308       fprintf (config.map_file, "SHORT ");
1309       print_dot += SHORT_SIZE;
1310       break;
1311     case LONG:
1312       fprintf (config.map_file, "LONG ");
1313       print_dot += LONG_SIZE;
1314       break;
1315     case QUAD:
1316       fprintf (config.map_file, "QUAD ");
1317       print_dot += QUAD_SIZE;
1318       break;
1319     }
1320
1321   exp_print_tree (data->exp);
1322
1323   fprintf (config.map_file, "\n");
1324 }
1325
1326 /* Print a reloc statement.  */
1327
1328 static void
1329 print_reloc_statement (reloc)
1330      lang_reloc_statement_type *reloc;
1331 {
1332   print_section ("");
1333   print_space ();
1334   print_section ("");
1335   print_space ();
1336
1337 /*  ASSERT(print_dot == data->output_vma);*/
1338
1339   print_address (reloc->output_vma + reloc->output_section->vma);
1340   print_space ();
1341   print_address (reloc->addend_value);
1342   print_space ();
1343
1344   fprintf (config.map_file, "RELOC %s ", reloc->howto->name);
1345
1346   print_dot += bfd_get_reloc_size (reloc->howto);
1347
1348   exp_print_tree (reloc->addend_exp);
1349
1350   fprintf (config.map_file, "\n");
1351 }
1352
1353 static void
1354 print_padding_statement (s)
1355      lang_padding_statement_type * s;
1356 {
1357   print_section ("");
1358   print_space ();
1359   print_section ("*fill*");
1360   print_space ();
1361   print_address (s->output_offset + s->output_section->vma);
1362   print_space ();
1363   print_size (s->size);
1364   print_space ();
1365   print_fill (s->fill);
1366   print_nl ();
1367
1368   print_dot = s->output_offset + s->output_section->vma + s->size;
1369
1370 }
1371
1372 static void
1373 print_wild_statement (w, os)
1374      lang_wild_statement_type * w;
1375      lang_output_section_statement_type * os;
1376 {
1377   fprintf (config.map_file, " from ");
1378   if (w->filename != (char *) NULL)
1379     {
1380       fprintf (config.map_file, "%s", w->filename);
1381     }
1382   else
1383     {
1384       fprintf (config.map_file, "*");
1385     }
1386   if (w->section_name != (char *) NULL)
1387     {
1388       fprintf (config.map_file, "(%s)", w->section_name);
1389     }
1390   else
1391     {
1392       fprintf (config.map_file, "(*)");
1393     }
1394   print_nl ();
1395   print_statement (w->children.head, os);
1396
1397 }
1398 static void
1399 print_statement (s, os)
1400      lang_statement_union_type * s;
1401      lang_output_section_statement_type * os;
1402 {
1403   while (s)
1404     {
1405       switch (s->header.type)
1406         {
1407           case lang_constructors_statement_enum:
1408           fprintf (config.map_file, "constructors:\n");
1409           print_statement (constructor_list.head, os);
1410           break;
1411         case lang_wild_statement_enum:
1412           print_wild_statement (&s->wild_statement, os);
1413           break;
1414         default:
1415           fprintf (config.map_file, "Fail with %d\n", s->header.type);
1416           FAIL ();
1417           break;
1418         case lang_address_statement_enum:
1419           fprintf (config.map_file, "address\n");
1420           break;
1421         case lang_object_symbols_statement_enum:
1422           fprintf (config.map_file, "object symbols\n");
1423           break;
1424         case lang_fill_statement_enum:
1425           print_fill_statement (&s->fill_statement);
1426           break;
1427         case lang_data_statement_enum:
1428           print_data_statement (&s->data_statement);
1429           break;
1430         case lang_reloc_statement_enum:
1431           print_reloc_statement (&s->reloc_statement);
1432           break;
1433         case lang_input_section_enum:
1434           print_input_section (&s->input_section);
1435           break;
1436         case lang_padding_statement_enum:
1437           print_padding_statement (&s->padding_statement);
1438           break;
1439         case lang_output_section_statement_enum:
1440           print_output_section_statement (&s->output_section_statement);
1441           break;
1442         case lang_assignment_statement_enum:
1443           print_assignment (&s->assignment_statement,
1444                             os);
1445           break;
1446         case lang_target_statement_enum:
1447           fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
1448           break;
1449         case lang_output_statement_enum:
1450           fprintf (config.map_file, "OUTPUT(%s %s)\n",
1451                    s->output_statement.name,
1452                    output_target ? output_target : "");
1453           break;
1454         case lang_input_statement_enum:
1455           print_input_statement (&s->input_statement);
1456           break;
1457         case lang_afile_asection_pair_statement_enum:
1458           FAIL ();
1459           break;
1460         }
1461       s = s->next;
1462     }
1463 }
1464
1465
1466 static void
1467 print_statements ()
1468 {
1469   print_statement (statement_list.head,
1470                    abs_output_section);
1471
1472 }
1473
1474 static bfd_vma
1475 insert_pad (this_ptr, fill, power, output_section_statement, dot)
1476      lang_statement_union_type ** this_ptr;
1477      fill_type fill;
1478      unsigned int power;
1479      asection * output_section_statement;
1480      bfd_vma dot;
1481 {
1482   /* Align this section first to the
1483      input sections requirement, then
1484      to the output section's requirement.
1485      If this alignment is > than any seen before,
1486      then record it too. Perform the alignment by
1487      inserting a magic 'padding' statement.
1488      */
1489
1490   unsigned int alignment_needed = align_power (dot, power) - dot;
1491
1492   if (alignment_needed != 0)
1493     {
1494       lang_statement_union_type *new =
1495       (lang_statement_union_type *)
1496       stat_alloc ((bfd_size_type) (sizeof (lang_padding_statement_type)));
1497
1498       /* Link into existing chain */
1499       new->header.next = *this_ptr;
1500       *this_ptr = new;
1501       new->header.type = lang_padding_statement_enum;
1502       new->padding_statement.output_section = output_section_statement;
1503       new->padding_statement.output_offset =
1504         dot - output_section_statement->vma;
1505       new->padding_statement.fill = fill;
1506       new->padding_statement.size = alignment_needed;
1507     }
1508
1509
1510   /* Remember the most restrictive alignment */
1511   if (power > output_section_statement->alignment_power)
1512     {
1513       output_section_statement->alignment_power = power;
1514     }
1515   output_section_statement->_raw_size += alignment_needed;
1516   return alignment_needed + dot;
1517
1518 }
1519
1520 /* Work out how much this section will move the dot point */
1521 static bfd_vma
1522 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
1523      lang_statement_union_type ** this_ptr;
1524      lang_output_section_statement_type * output_section_statement;
1525      fill_type fill;
1526      bfd_vma dot;
1527      boolean relax;
1528 {
1529   lang_input_section_type *is = &((*this_ptr)->input_section);
1530   asection *i = is->section;
1531
1532   if (is->ifile->just_syms_flag == false)
1533     {
1534       if (output_section_statement->subsection_alignment != -1)
1535        i->alignment_power =
1536         output_section_statement->subsection_alignment;
1537
1538       dot = insert_pad (this_ptr, fill, i->alignment_power,
1539                         output_section_statement->bfd_section, dot);
1540
1541       /* Remember where in the output section this input section goes */
1542
1543       i->output_offset = dot - output_section_statement->bfd_section->vma;
1544
1545       /* Mark how big the output section must be to contain this now
1546          */
1547       if (i->_cooked_size != 0)
1548         dot += i->_cooked_size;
1549       else
1550         dot += i->_raw_size;
1551       output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
1552     }
1553   else
1554     {
1555       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
1556     }
1557
1558   return dot;
1559 }
1560
1561 /* This variable indicates whether bfd_relax_section should be called
1562    again.  */
1563
1564 static boolean relax_again;
1565
1566 /* Set the sizes for all the output sections.  */
1567
1568 bfd_vma
1569 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
1570      lang_statement_union_type * s;
1571      lang_output_section_statement_type * output_section_statement;
1572      lang_statement_union_type ** prev;
1573      fill_type fill;
1574      bfd_vma dot;
1575      boolean relax;
1576 {
1577   /* Size up the sections from their constituent parts */
1578   for (; s != (lang_statement_union_type *) NULL; s = s->next)
1579   {
1580     switch (s->header.type)
1581     {
1582
1583      case lang_output_section_statement_enum:
1584      {
1585        bfd_vma after;
1586        lang_output_section_statement_type *os = &s->output_section_statement;
1587
1588        if (os->bfd_section == NULL)
1589          {
1590            /* This section was never actually created.  */
1591            break;
1592          }
1593
1594        /* If this is a COFF shared library section, use the size and
1595           address from the input section.  FIXME: This is COFF
1596           specific; it would be cleaner if there were some other way
1597           to do this, but nothing simple comes to mind.  */
1598        if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
1599          {
1600            asection *input;
1601
1602            if (os->children.head == NULL
1603                || os->children.head->next != NULL
1604                || os->children.head->header.type != lang_input_section_enum)
1605              einfo ("%P%X: Internal error on COFF shared library section %s",
1606                     os->name);
1607
1608            input = os->children.head->input_section.section;
1609            bfd_set_section_vma (os->bfd_section->owner,
1610                                 os->bfd_section,
1611                                 bfd_section_vma (input->owner, input));
1612            os->bfd_section->_raw_size = input->_raw_size;
1613            break;
1614          }
1615
1616        if (os->bfd_section == &bfd_abs_section)
1617        {
1618          /* No matter what happens, an abs section starts at zero */
1619          bfd_set_section_vma (0, os->bfd_section, 0);
1620        }
1621        else
1622        {
1623          if (os->addr_tree == (etree_type *) NULL)
1624          {
1625            /* No address specified for this section, get one
1626               from the region specification
1627               */
1628            if (os->region == (lang_memory_region_type *) NULL)
1629            {
1630              os->region = lang_memory_region_lookup ("*default*");
1631            }
1632            dot = os->region->current;
1633            if (os->section_alignment == -1)
1634              dot = align_power (dot, os->bfd_section->alignment_power);
1635          }
1636          else
1637          {
1638            etree_value_type r;
1639
1640            r = exp_fold_tree (os->addr_tree,
1641                               abs_output_section,
1642                               lang_allocating_phase_enum,
1643                               dot, &dot);
1644            if (r.valid == false)
1645            {
1646              einfo ("%F%S: non constant address expression for section %s\n",
1647                     os->name);
1648            }
1649            dot = r.value;
1650          }
1651          /* The section starts here */
1652          /* First, align to what the section needs */
1653
1654          if (os->section_alignment != -1)
1655            dot = align_power (dot, os->section_alignment);
1656
1657          bfd_set_section_vma (0, os->bfd_section, dot);
1658
1659          if (os->load_base) {
1660            os->bfd_section->lma
1661              = exp_get_value_int(os->load_base, 0,"load base", lang_final_phase_enum);
1662          }
1663        }
1664
1665
1666        os->bfd_section->output_offset = 0;
1667
1668        (void) lang_size_sections (os->children.head, os, &os->children.head,
1669                                   os->fill, dot, relax);
1670        /* Ignore the size of the input sections, use the vma and size to */
1671        /* align against */
1672
1673        after = ALIGN_N (os->bfd_section->vma +
1674                         os->bfd_section->_raw_size,
1675                         /* The coercion here is important, see ld.h.  */
1676                         (bfd_vma) os->block_value);
1677
1678        os->bfd_section->_raw_size = after - os->bfd_section->vma;
1679        dot = os->bfd_section->vma + os->bfd_section->_raw_size;
1680        os->processed = true;
1681
1682        /* Replace into region ? */
1683        if (os->addr_tree == (etree_type *) NULL
1684            && os->region != (lang_memory_region_type *) NULL)
1685        {
1686          os->region->current = dot;
1687          /* Make sure this isn't silly */
1688          if (( os->region->current
1689               > os->region->origin + os->region->length)
1690              || ( os->region->origin > os->region->current ))
1691            {
1692              einfo ("%X%P: region %s is full (%B section %s)\n",
1693                     os->region->name,
1694                     os->bfd_section->owner,
1695                     os->bfd_section->name);
1696              /* Reset the region pointer */
1697              os->region->current = 0;
1698
1699            }
1700
1701        }
1702      }
1703
1704       break;
1705      case lang_constructors_statement_enum:
1706       dot = lang_size_sections (constructor_list.head,
1707                                 output_section_statement,
1708                                 &s->wild_statement.children.head,
1709                                 fill,
1710                                 dot, relax);
1711       break;
1712
1713      case lang_data_statement_enum:
1714      {
1715        unsigned int size = 0;
1716
1717        s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
1718        s->data_statement.output_section =
1719         output_section_statement->bfd_section;
1720
1721        switch (s->data_statement.type)
1722        {
1723         case QUAD:
1724          size = QUAD_SIZE;
1725          break;
1726         case LONG:
1727          size = LONG_SIZE;
1728          break;
1729         case SHORT:
1730          size = SHORT_SIZE;
1731          break;
1732         case BYTE:
1733          size = BYTE_SIZE;
1734          break;
1735
1736        }
1737        dot += size;
1738        output_section_statement->bfd_section->_raw_size += size;
1739      }
1740       break;
1741
1742      case lang_reloc_statement_enum:
1743      {
1744        int size;
1745
1746        s->reloc_statement.output_vma =
1747          dot - output_section_statement->bfd_section->vma;
1748        s->reloc_statement.output_section =
1749          output_section_statement->bfd_section;
1750        size = bfd_get_reloc_size (s->reloc_statement.howto);
1751        dot += size;
1752        output_section_statement->bfd_section->_raw_size += size;
1753      }
1754      break;
1755
1756      case lang_wild_statement_enum:
1757
1758       dot = lang_size_sections (s->wild_statement.children.head,
1759                                 output_section_statement,
1760                                 &s->wild_statement.children.head,
1761
1762                                 fill, dot, relax);
1763
1764       break;
1765
1766      case lang_object_symbols_statement_enum:
1767       link_info.create_object_symbols_section =
1768         output_section_statement->bfd_section;
1769       break;
1770      case lang_output_statement_enum:
1771      case lang_target_statement_enum:
1772       break;
1773      case lang_input_section_enum:
1774       {
1775         asection *i;
1776
1777         i = (*prev)->input_section.section;
1778         if (! relax)
1779           i->_cooked_size = i->_raw_size;
1780         else
1781           {
1782             boolean again;
1783
1784             if (! bfd_relax_section (i->owner, i, &link_info, &again))
1785               einfo ("%P%F: can't relax section: %E\n");
1786             if (again)
1787               relax_again = true;
1788           }
1789         dot = size_input_section (prev,
1790                                   output_section_statement,
1791                                   output_section_statement->fill,
1792                                   dot, relax);
1793       }
1794       break;
1795      case lang_input_statement_enum:
1796       break;
1797      case lang_fill_statement_enum:
1798       s->fill_statement.output_section = output_section_statement->bfd_section;
1799
1800       fill = s->fill_statement.fill;
1801       break;
1802      case lang_assignment_statement_enum:
1803      {
1804        bfd_vma newdot = dot;
1805
1806        exp_fold_tree (s->assignment_statement.exp,
1807                       output_section_statement,
1808                       lang_allocating_phase_enum,
1809                       dot,
1810                       &newdot);
1811
1812        if (newdot != dot && !relax)
1813          {
1814            /* The assignment changed dot.  Insert a pad.  */
1815            if (output_section_statement == abs_output_section)
1816              {
1817                /* If we don't have an output section, then just adjust
1818                   the default memory address.  */
1819                lang_memory_region_lookup ("*default*")->current = newdot;
1820              }
1821            else
1822              {
1823                lang_statement_union_type *new =
1824                  ((lang_statement_union_type *)
1825                   stat_alloc (sizeof (lang_padding_statement_type)));
1826
1827                /* Link into existing chain */
1828                new->header.next = *prev;
1829                *prev = new;
1830                new->header.type = lang_padding_statement_enum;
1831                new->padding_statement.output_section =
1832                  output_section_statement->bfd_section;
1833                new->padding_statement.output_offset =
1834                  dot - output_section_statement->bfd_section->vma;
1835                new->padding_statement.fill = fill;
1836                new->padding_statement.size = newdot - dot;
1837                output_section_statement->bfd_section->_raw_size +=
1838                  new->padding_statement.size;
1839              }
1840
1841            dot = newdot;
1842          }
1843      }
1844      break;
1845
1846    case lang_padding_statement_enum:
1847      /* If we are relaxing, and this is not the first pass, some
1848         padding statements may have been inserted during previous
1849         passes.  We may have to move the padding statement to a new
1850         location if dot has a different value at this point in this
1851         pass than it did at this point in the previous pass.  */
1852      s->padding_statement.output_offset =
1853        dot - output_section_statement->bfd_section->vma;
1854      dot += s->padding_statement.size;
1855      break;
1856
1857      default:
1858       FAIL ();
1859       break;
1860
1861       /* This can only get here when relaxing is turned on */
1862
1863      case lang_address_statement_enum:
1864       break;
1865     }
1866     prev = &s->header.next;
1867   }
1868   return dot;
1869 }
1870
1871 static bfd_vma
1872 lang_do_assignments (s, output_section_statement, fill, dot)
1873      lang_statement_union_type * s;
1874      lang_output_section_statement_type * output_section_statement;
1875      fill_type fill;
1876      bfd_vma dot;
1877 {
1878   for (; s != (lang_statement_union_type *) NULL; s = s->next)
1879     {
1880       switch (s->header.type)
1881         {
1882         case lang_constructors_statement_enum:
1883           dot = lang_do_assignments (constructor_list.head,
1884                                      output_section_statement,
1885                                      fill,
1886                                      dot);
1887           break;
1888
1889         case lang_output_section_statement_enum:
1890           {
1891             lang_output_section_statement_type *os =
1892               &(s->output_section_statement);
1893
1894             if (os->bfd_section != NULL)
1895               {
1896                 dot = os->bfd_section->vma;
1897                 (void) lang_do_assignments (os->children.head, os,
1898                                             os->fill, dot);
1899                 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
1900               }
1901           }
1902           break;
1903         case lang_wild_statement_enum:
1904
1905           dot = lang_do_assignments (s->wild_statement.children.head,
1906                                      output_section_statement,
1907                                      fill, dot);
1908
1909           break;
1910
1911         case lang_object_symbols_statement_enum:
1912         case lang_output_statement_enum:
1913         case lang_target_statement_enum:
1914 #if 0
1915         case lang_common_statement_enum:
1916 #endif
1917           break;
1918         case lang_data_statement_enum:
1919           {
1920             etree_value_type value;
1921
1922             value = exp_fold_tree (s->data_statement.exp,
1923                                    abs_output_section,
1924                                    lang_final_phase_enum, dot, &dot);
1925             s->data_statement.value = value.value;
1926             if (value.valid == false)
1927               einfo ("%F%P: invalid data statement\n");
1928           }
1929           switch (s->data_statement.type)
1930             {
1931             case QUAD:
1932               dot += QUAD_SIZE;
1933               break;
1934             case LONG:
1935               dot += LONG_SIZE;
1936               break;
1937             case SHORT:
1938               dot += SHORT_SIZE;
1939               break;
1940             case BYTE:
1941               dot += BYTE_SIZE;
1942               break;
1943             }
1944           break;
1945
1946         case lang_reloc_statement_enum:
1947           {
1948             etree_value_type value;
1949
1950             value = exp_fold_tree (s->reloc_statement.addend_exp,
1951                                    abs_output_section,
1952                                    lang_final_phase_enum, dot, &dot);
1953             s->reloc_statement.addend_value = value.value;
1954             if (value.valid == false)
1955               einfo ("%F%P: invalid reloc statement\n");
1956           }
1957           dot += bfd_get_reloc_size (s->reloc_statement.howto);
1958           break;
1959
1960         case lang_input_section_enum:
1961           {
1962             asection *in = s->input_section.section;
1963
1964             if (in->_cooked_size != 0)
1965               dot += in->_cooked_size;
1966             else
1967               dot += in->_raw_size;
1968           }
1969           break;
1970
1971         case lang_input_statement_enum:
1972           break;
1973         case lang_fill_statement_enum:
1974           fill = s->fill_statement.fill;
1975           break;
1976         case lang_assignment_statement_enum:
1977           {
1978             exp_fold_tree (s->assignment_statement.exp,
1979                            output_section_statement,
1980                            lang_final_phase_enum,
1981                            dot,
1982                            &dot);
1983           }
1984
1985           break;
1986         case lang_padding_statement_enum:
1987           dot += s->padding_statement.size;
1988           break;
1989         default:
1990           FAIL ();
1991           break;
1992         case lang_address_statement_enum:
1993           break;
1994         }
1995
1996     }
1997   return dot;
1998 }
1999
2000 static void
2001 lang_finish ()
2002 {
2003   struct bfd_link_hash_entry *h;
2004   boolean warn = link_info.relocateable ? false : true;
2005
2006   if (entry_symbol == (char *) NULL)
2007     {
2008       /* No entry has been specified.  Look for start, but don't warn
2009          if we don't find it.  */
2010       entry_symbol = "start";
2011       warn = false;
2012     }
2013
2014   h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
2015   if (h != (struct bfd_link_hash_entry *) NULL
2016       && h->type == bfd_link_hash_defined)
2017     {
2018       bfd_vma val;
2019
2020       val = (h->u.def.value
2021              + bfd_get_section_vma (output_bfd,
2022                                     h->u.def.section->output_section)
2023              + h->u.def.section->output_offset);
2024       if (! bfd_set_start_address (output_bfd, val))
2025         einfo ("%P%F:%s: can't set start address\n", entry_symbol);
2026     }
2027   else
2028     {
2029       asection *ts;
2030
2031       /* Can't find the entry symbol.  Use the first address in the
2032          text section.  */
2033       ts = bfd_get_section_by_name (output_bfd, ".text");
2034       if (ts != (asection *) NULL)
2035         {
2036           if (warn)
2037             einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2038                    entry_symbol, bfd_get_section_vma (output_bfd, ts));
2039           if (! bfd_set_start_address (output_bfd,
2040                                        bfd_get_section_vma (output_bfd, ts)))
2041             einfo ("%P%F: can't set start address\n");
2042         }
2043       else
2044         {
2045           if (warn)
2046             einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2047                    entry_symbol);
2048         }
2049     }
2050 }
2051
2052 /* By now we know the target architecture, and we may have an */
2053 /* ldfile_output_machine_name */
2054 static void
2055 lang_check ()
2056 {
2057   lang_statement_union_type *file;
2058   bfd *input_bfd;
2059   unsigned long input_machine;
2060   enum bfd_architecture input_architecture;
2061   CONST bfd_arch_info_type *compatible;
2062
2063   for (file = file_chain.head;
2064        file != (lang_statement_union_type *) NULL;
2065        file = file->input_statement.next)
2066     {
2067       input_bfd = file->input_statement.the_bfd;
2068
2069       input_machine = bfd_get_mach (input_bfd);
2070       input_architecture = bfd_get_arch (input_bfd);
2071
2072
2073       /* Inspect the architecture and ensure we're linking like with
2074          like */
2075
2076       compatible = bfd_arch_get_compatible (input_bfd,
2077                                             output_bfd);
2078
2079       if (compatible)
2080         {
2081           ldfile_output_machine = compatible->mach;
2082           ldfile_output_architecture = compatible->arch;
2083         }
2084       else
2085         {
2086
2087           einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2088                 bfd_printable_name (input_bfd), input_bfd,
2089                 bfd_printable_name (output_bfd));
2090
2091           if (! bfd_set_arch_mach (output_bfd,
2092                                    input_architecture,
2093                                    input_machine))
2094             einfo ("%P%F:%s: can't set architecture: %E\n",
2095                    bfd_get_filename (output_bfd));
2096         }
2097
2098     }
2099 }
2100
2101 /* Look through all the global common symbols and attach them to the
2102    correct section.  The -sort-common command line switch may be used
2103    to roughly sort the entries by size.  */
2104
2105 static void
2106 lang_common ()
2107 {
2108   if (link_info.relocateable
2109       && ! command_line.force_common_definition)
2110     return;
2111
2112   if (! config.sort_common)
2113     bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
2114   else
2115     {
2116       unsigned int power;
2117
2118       for (power = 1; power <= 16; power <<= 1)
2119         bfd_link_hash_traverse (link_info.hash, lang_one_common,
2120                                 (PTR) &power);
2121     }
2122 }
2123
2124 /* Place one common symbol in the correct section.  */
2125
2126 static boolean
2127 lang_one_common (h, info)
2128      struct bfd_link_hash_entry *h;
2129      PTR info;
2130 {
2131   unsigned int power_of_two;
2132   bfd_vma size;
2133   size_t align;
2134   asection *section;
2135
2136   if (h->type != bfd_link_hash_common)
2137     return true;
2138
2139   size = h->u.c.size;
2140   switch (size)
2141     {
2142     case 0:
2143     case 1:
2144       power_of_two = 0;
2145       align = 1;
2146       break;
2147     case 2:
2148       power_of_two = 1;
2149       align = 2;
2150       break;
2151     case 3:
2152     case 4:
2153       power_of_two = 2;
2154       align = 4;
2155       break;
2156     case 5:
2157     case 6:
2158     case 7:
2159     case 8:
2160       power_of_two = 3;
2161       align = 8;
2162       break;
2163     default:
2164       power_of_two = 4;
2165       align = 16;
2166       break;
2167     }
2168
2169   if (config.sort_common && align != *(unsigned int *) info)
2170     return true;
2171
2172   section = h->u.c.section;
2173
2174   /* Increase the size of the section.  */
2175   section->_raw_size = ALIGN_N (section->_raw_size, align);
2176
2177   /* Adjust the alignment if necessary.  */
2178   if (power_of_two > section->alignment_power)
2179     section->alignment_power = power_of_two;
2180
2181   /* Change the symbol from common to defined.  */
2182   h->type = bfd_link_hash_defined;
2183   h->u.def.section = section;
2184   h->u.def.value = section->_raw_size;
2185
2186   /* Increase the size of the section.  */
2187   section->_raw_size += size;
2188
2189   if (config.map_file != NULL)
2190     fprintf (config.map_file, "Allocating common %s: %lx at %lx %s\n",
2191              h->root.string, (unsigned long) size,
2192              (unsigned long) h->u.def.value, section->owner->filename);
2193
2194   return true;
2195 }
2196
2197 /*
2198 run through the input files and ensure that every input
2199 section has somewhere to go. If one is found without
2200 a destination then create an input request and place it
2201 into the statement tree.
2202 */
2203
2204 static void
2205 lang_place_orphans ()
2206 {
2207   lang_input_statement_type *file;
2208
2209   for (file = (lang_input_statement_type *) file_chain.head;
2210        file != (lang_input_statement_type *) NULL;
2211        file = (lang_input_statement_type *) file->next)
2212     {
2213       asection *s;
2214
2215       if (file->just_syms_flag)
2216         continue;
2217
2218       for (s = file->the_bfd->sections;
2219            s != (asection *) NULL;
2220            s = s->next)
2221         {
2222           if (s->output_section == (asection *) NULL)
2223             {
2224               /* This section of the file is not attatched, root
2225                  around for a sensible place for it to go */
2226
2227               if (file->common_section == s)
2228                 {
2229                   /* This is a lonely common section which must
2230                      have come from an archive. We attatch to the
2231                      section with the wildcard  */
2232                   if (! link_info.relocateable
2233                       && ! command_line.force_common_definition)
2234                     {
2235                       if (default_common_section ==
2236                           (lang_output_section_statement_type *) NULL)
2237                         {
2238                           info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2239
2240                           default_common_section =
2241                             lang_output_section_statement_lookup (".bss");
2242
2243                         }
2244                       wild_doit (&default_common_section->children, s,
2245                                  default_common_section, file);
2246                     }
2247                 }
2248               else
2249                 {
2250                   lang_output_section_statement_type *os =
2251                   lang_output_section_statement_lookup (s->name);
2252
2253                   wild_doit (&os->children, s, os, file);
2254                 }
2255             }
2256         }
2257     }
2258 }
2259
2260
2261 void
2262 lang_set_flags (ptr, flags)
2263      int *ptr;
2264      CONST char *flags;
2265 {
2266   boolean state = false;
2267
2268   *ptr = 0;
2269   while (*flags)
2270     {
2271       if (*flags == '!')
2272         {
2273           state = false;
2274           flags++;
2275         }
2276       else
2277         state = true;
2278       switch (*flags)
2279         {
2280         case 'R':
2281           /*      ptr->flag_read = state; */
2282           break;
2283         case 'W':
2284           /*      ptr->flag_write = state; */
2285           break;
2286         case 'X':
2287           /*      ptr->flag_executable= state;*/
2288           break;
2289         case 'L':
2290         case 'I':
2291           /*      ptr->flag_loadable= state;*/
2292           break;
2293         default:
2294           einfo ("%P%F: invalid syntax in flags\n");
2295           break;
2296         }
2297       flags++;
2298     }
2299 }
2300
2301 /* Call a function on each input file.  This function will be called
2302    on an archive, but not on the elements.  */
2303
2304 void
2305 lang_for_each_input_file (func)
2306      void (*func) PARAMS ((lang_input_statement_type *));
2307 {
2308   lang_input_statement_type *f;
2309
2310   for (f = (lang_input_statement_type *) input_file_chain.head;
2311        f != NULL;
2312        f = (lang_input_statement_type *) f->next_real_file)
2313     func (f);
2314 }
2315
2316 /* Call a function on each file.  The function will be called on all
2317    the elements of an archive which are included in the link, but will
2318    not be called on the archive file itself.  */
2319
2320 void
2321 lang_for_each_file (func)
2322      void (*func) PARAMS ((lang_input_statement_type *));
2323 {
2324   lang_input_statement_type *f;
2325
2326   for (f = (lang_input_statement_type *) file_chain.head;
2327        f != (lang_input_statement_type *) NULL;
2328        f = (lang_input_statement_type *) f->next)
2329     {
2330       func (f);
2331     }
2332 }
2333
2334 #if 0
2335
2336 /* Not used.  */
2337
2338 void
2339 lang_for_each_input_section (func)
2340      void (*func) PARAMS ((bfd * ab, asection * as));
2341 {
2342   lang_input_statement_type *f;
2343
2344   for (f = (lang_input_statement_type *) file_chain.head;
2345        f != (lang_input_statement_type *) NULL;
2346        f = (lang_input_statement_type *) f->next)
2347     {
2348       asection *s;
2349
2350       for (s = f->the_bfd->sections;
2351            s != (asection *) NULL;
2352            s = s->next)
2353         {
2354           func (f->the_bfd, s);
2355         }
2356     }
2357 }
2358
2359 #endif
2360
2361 void
2362 ldlang_add_file (entry)
2363      lang_input_statement_type * entry;
2364 {
2365   bfd **pp;
2366
2367   lang_statement_append (&file_chain,
2368                          (lang_statement_union_type *) entry,
2369                          &entry->next);
2370
2371   /* The BFD linker needs to have a list of all input BFDs involved in
2372      a link.  */
2373   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
2374   ASSERT (entry->the_bfd != output_bfd);
2375   for (pp = &link_info.input_bfds;
2376        *pp != (bfd *) NULL;
2377        pp = &(*pp)->link_next)
2378     ;
2379   *pp = entry->the_bfd;
2380   entry->the_bfd->usrdata = (PTR) entry;
2381   bfd_set_gp_size (entry->the_bfd, g_switch_value);
2382 }
2383
2384 void
2385 lang_add_output (name, from_script)
2386      CONST char *name;
2387      int from_script;
2388 {
2389   /* Make -o on command line override OUTPUT in script.  */
2390   if (had_output_filename == false || !from_script)
2391     {
2392       output_filename = name;
2393       had_output_filename = true;
2394     }
2395 }
2396
2397
2398 static lang_output_section_statement_type *current_section;
2399
2400 static int topower(x)
2401      int x;
2402 {
2403   unsigned  int i = 1;
2404   int l;
2405   if (x < 0) return -1;
2406   for (l = 0; l < 32; l++)
2407   {
2408     if (i >= x) return l;
2409     i<<=1;
2410   }
2411   return 0;
2412 }
2413 void
2414 lang_enter_output_section_statement (output_section_statement_name,
2415                                      address_exp, flags, block_value,
2416                                      align, subalign, ebase)
2417      const char *output_section_statement_name;
2418      etree_type * address_exp;
2419      int flags;
2420      bfd_vma block_value;
2421      etree_type *align;
2422      etree_type *subalign;
2423      etree_type *ebase;
2424 {
2425   lang_output_section_statement_type *os;
2426
2427   current_section =
2428    os =
2429     lang_output_section_statement_lookup (output_section_statement_name);
2430
2431
2432
2433   /* Add this statement to tree */
2434   /*  add_statement(lang_output_section_statement_enum,
2435       output_section_statement);*/
2436   /* Make next things chain into subchain of this */
2437
2438   if (os->addr_tree ==
2439       (etree_type *) NULL)
2440   {
2441     os->addr_tree =
2442      address_exp;
2443   }
2444   os->flags = flags;
2445   if (flags & SEC_NEVER_LOAD)
2446    os->loadable = 0;
2447   else
2448    os->loadable = 1;
2449   os->block_value = block_value ? block_value : 1;
2450   stat_ptr = &os->children;
2451
2452   os->subsection_alignment = topower(
2453    exp_get_value_int(subalign, -1,
2454                      "subsection alignment",
2455                      0));
2456   os->section_alignment = topower(
2457    exp_get_value_int(align, -1,
2458                      "section alignment", 0));
2459
2460   os->load_base = ebase;
2461 }
2462
2463
2464 void
2465 lang_final ()
2466 {
2467   lang_output_statement_type *new =
2468     new_stat (lang_output_statement, stat_ptr);
2469
2470   new->name = output_filename;
2471 }
2472
2473 /* Reset the current counters in the regions */
2474 static void
2475 reset_memory_regions ()
2476 {
2477   lang_memory_region_type *p = lang_memory_region_list;
2478
2479   for (p = lang_memory_region_list;
2480        p != (lang_memory_region_type *) NULL;
2481        p = p->next)
2482     {
2483       p->old_length = (bfd_size_type) (p->current - p->origin);
2484       p->current = p->origin;
2485     }
2486 }
2487
2488 void
2489 lang_process ()
2490 {
2491   lang_reasonable_defaults ();
2492   current_target = default_target;
2493
2494   lang_for_each_statement (ldlang_open_output); /* Open the output file */
2495
2496   ldemul_create_output_section_statements ();
2497
2498   /* Add to the hash table all undefineds on the command line */
2499   lang_place_undefineds ();
2500
2501   /* Create a bfd for each input file */
2502   current_target = default_target;
2503   lang_for_each_statement (open_input_bfds);
2504
2505   /* Build all sets based on the information gathered from the input
2506      files.  */
2507   ldctor_build_sets ();
2508
2509   /* Size up the common data */
2510   lang_common ();
2511
2512   /* Run through the contours of the script and attatch input sections
2513      to the correct output sections
2514      */
2515   map_input_to_output_sections (statement_list.head, (char *) NULL,
2516                                 (lang_output_section_statement_type *) NULL);
2517
2518
2519   /* Find any sections not attatched explicitly and handle them */
2520   lang_place_orphans ();
2521
2522   ldemul_before_allocation ();
2523
2524   /* Now run around and relax if we can */
2525   if (command_line.relax)
2526     {
2527       /* First time round is a trial run to get the 'worst case'
2528          addresses of the objects if there was no relaxing.  */
2529       lang_size_sections (statement_list.head,
2530                           abs_output_section,
2531                           &(statement_list.head), 0, (bfd_vma) 0, false);
2532
2533
2534       reset_memory_regions ();
2535
2536       /* Keep relaxing until bfd_relax_section gives up.  */
2537       do
2538         {
2539           relax_again = false;
2540
2541           /* Do all the assignments with our current guesses as to
2542              section sizes.  */
2543           lang_do_assignments (statement_list.head,
2544                                abs_output_section,
2545                                (fill_type) 0, (bfd_vma) 0);
2546
2547           /* Perform another relax pass - this time we know where the
2548              globals are, so can make better guess.  */
2549           lang_size_sections (statement_list.head,
2550                               abs_output_section,
2551                               &(statement_list.head), 0, (bfd_vma) 0, true);
2552         }
2553       while (relax_again);
2554     }
2555   else
2556     {
2557       /* Size up the sections.  */
2558       lang_size_sections (statement_list.head,
2559                           abs_output_section,
2560                           &(statement_list.head), 0, (bfd_vma) 0, false);
2561     }
2562
2563   /* See if anything special should be done now we know how big
2564      everything is.  */
2565   ldemul_after_allocation ();
2566
2567   /* Do all the assignments, now that we know the final restingplaces
2568      of all the symbols */
2569
2570   lang_do_assignments (statement_list.head,
2571                        abs_output_section,
2572                        (fill_type) 0, (bfd_vma) 0);
2573
2574   /* Make sure that we're not mixing architectures */
2575
2576   lang_check ();
2577
2578   /* Final stuffs */
2579
2580   ldemul_finish ();
2581   lang_finish ();
2582 }
2583
2584 /* EXPORTED TO YACC */
2585
2586 void
2587 lang_add_wild (section_name, filename)
2588      CONST char *CONST section_name;
2589      CONST char *CONST filename;
2590 {
2591   lang_wild_statement_type *new = new_stat (lang_wild_statement,
2592                                             stat_ptr);
2593
2594   if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
2595     {
2596       placed_commons = true;
2597     }
2598   if (filename != (char *) NULL)
2599     {
2600       lang_has_input_file = true;
2601     }
2602   new->section_name = section_name;
2603   new->filename = filename;
2604   lang_list_init (&new->children);
2605 }
2606
2607 void
2608 lang_section_start (name, address)
2609      CONST char *name;
2610      etree_type * address;
2611 {
2612   lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
2613
2614   ad->section_name = name;
2615   ad->address = address;
2616 }
2617
2618 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
2619    because of a -e argument on the command line, or zero if this is
2620    called by ENTRY in a linker script.  Command line arguments take
2621    precedence.  */
2622
2623 void
2624 lang_add_entry (name, cmdline)
2625      CONST char *name;
2626      int cmdline;
2627 {
2628   static int from_cmdline;
2629
2630   if (entry_symbol == NULL
2631       || cmdline
2632       || ! from_cmdline)
2633     {
2634       entry_symbol = name;
2635       from_cmdline = cmdline;
2636     }
2637 }
2638
2639 void
2640 lang_add_target (name)
2641      CONST char *name;
2642 {
2643   lang_target_statement_type *new = new_stat (lang_target_statement,
2644                                               stat_ptr);
2645
2646   new->target = name;
2647
2648 }
2649
2650 void
2651 lang_add_map (name)
2652      CONST char *name;
2653 {
2654   while (*name)
2655     {
2656       switch (*name)
2657         {
2658           case 'F':
2659           map_option_f = true;
2660           break;
2661         }
2662       name++;
2663     }
2664 }
2665
2666 void
2667 lang_add_fill (exp)
2668      int exp;
2669 {
2670   lang_fill_statement_type *new = new_stat (lang_fill_statement,
2671                                             stat_ptr);
2672
2673   new->fill = exp;
2674 }
2675
2676 void
2677 lang_add_data (type, exp)
2678      int type;
2679      union etree_union *exp;
2680 {
2681
2682   lang_data_statement_type *new = new_stat (lang_data_statement,
2683                                             stat_ptr);
2684
2685   new->exp = exp;
2686   new->type = type;
2687
2688 }
2689
2690 /* Create a new reloc statement.  RELOC is the BFD relocation type to
2691    generate.  HOWTO is the corresponding howto structure (we could
2692    look this up, but the caller has already done so).  SECTION is the
2693    section to generate a reloc against, or NAME is the name of the
2694    symbol to generate a reloc against.  Exactly one of SECTION and
2695    NAME must be NULL.  ADDEND is an expression for the addend.  */
2696
2697 void
2698 lang_add_reloc (reloc, howto, section, name, addend)
2699      bfd_reloc_code_real_type reloc;
2700      const reloc_howto_type *howto;
2701      asection *section;
2702      const char *name;
2703      union etree_union *addend;
2704 {
2705   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
2706
2707   p->reloc = reloc;
2708   p->howto = howto;
2709   p->section = section;
2710   p->name = name;
2711   p->addend_exp = addend;
2712
2713   p->addend_value = 0;
2714   p->output_section = NULL;
2715   p->output_vma = 0;
2716 }
2717
2718 void
2719 lang_add_assignment (exp)
2720      etree_type * exp;
2721 {
2722   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
2723                                                   stat_ptr);
2724
2725   new->exp = exp;
2726 }
2727
2728 void
2729 lang_add_attribute (attribute)
2730      enum statement_enum attribute;
2731 {
2732   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
2733 }
2734
2735 void
2736 lang_startup (name)
2737      CONST char *name;
2738 {
2739   if (startup_file != (char *) NULL)
2740     {
2741       einfo ("%P%Fmultiple STARTUP files\n");
2742     }
2743   first_file->filename = name;
2744   first_file->local_sym_name = name;
2745   first_file->real = true;
2746
2747   startup_file = name;
2748 }
2749
2750 void
2751 lang_float (maybe)
2752      boolean maybe;
2753 {
2754   lang_float_flag = maybe;
2755 }
2756
2757 void
2758 lang_leave_output_section_statement (fill, memspec)
2759      bfd_vma fill;
2760      CONST char *memspec;
2761 {
2762   current_section->fill = fill;
2763   current_section->region = lang_memory_region_lookup (memspec);
2764   stat_ptr = &statement_list;
2765
2766   /* We remember if we are closing a .data section, since we use it to
2767      store constructors in */
2768   if (strcmp (current_section->name, ".data") == 0)
2769     {
2770       end_of_data_section_statement_list = statement_list;
2771
2772     }
2773 }
2774
2775 /*
2776  Create an absolute symbol with the given name with the value of the
2777  address of first byte of the section named.
2778
2779  If the symbol already exists, then do nothing.
2780 */
2781 void
2782 lang_abs_symbol_at_beginning_of (secname, name)
2783      const char *secname;
2784      const char *name;
2785 {
2786   struct bfd_link_hash_entry *h;
2787
2788   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
2789   if (h == (struct bfd_link_hash_entry *) NULL)
2790     einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2791
2792   if (h->type == bfd_link_hash_new
2793       || h->type == bfd_link_hash_undefined)
2794     {
2795       asection *sec;
2796
2797       h->type = bfd_link_hash_defined;
2798
2799       sec = bfd_get_section_by_name (output_bfd, secname);
2800       if (sec == (asection *) NULL)
2801         h->u.def.value = 0;
2802       else
2803         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
2804
2805       h->u.def.section = &bfd_abs_section;
2806     }
2807 }
2808
2809 /*
2810  Create an absolute symbol with the given name with the value of the
2811  address of the first byte after the end of the section named.
2812
2813  If the symbol already exists, then do nothing.
2814 */
2815 void
2816 lang_abs_symbol_at_end_of (secname, name)
2817      const char *secname;
2818      const char *name;
2819 {
2820   struct bfd_link_hash_entry *h;
2821
2822   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
2823   if (h == (struct bfd_link_hash_entry *) NULL)
2824     einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2825
2826   if (h->type == bfd_link_hash_new
2827       || h->type == bfd_link_hash_undefined)
2828     {
2829       asection *sec;
2830
2831       h->type = bfd_link_hash_defined;
2832
2833       sec = bfd_get_section_by_name (output_bfd, secname);
2834       if (sec == (asection *) NULL)
2835         h->u.def.value = 0;
2836       else
2837         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
2838                           + bfd_section_size (output_bfd, sec));
2839
2840       h->u.def.section = &bfd_abs_section;
2841     }
2842 }
2843
2844 void
2845 lang_statement_append (list, element, field)
2846      lang_statement_list_type * list;
2847      lang_statement_union_type * element;
2848      lang_statement_union_type ** field;
2849 {
2850   *(list->tail) = element;
2851   list->tail = field;
2852 }
2853
2854 /* Set the output format type.  -oformat overrides scripts.  */
2855 void
2856 lang_add_output_format (format, from_script)
2857      CONST char *format;
2858      int from_script;
2859 {
2860   if (output_target == NULL || !from_script)
2861     output_target = format;
2862 }