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