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   int size = i->reloc_done ?
1285   bfd_get_section_size_after_reloc (i) :
1286   bfd_get_section_size_before_reloc (i);
1287
1288   if (size != 0)
1289     {
1290       print_section ("");
1291       fprintf (config.map_file, " ");
1292       print_section (i->name);
1293       fprintf (config.map_file, " ");
1294       if (i->output_section)
1295         {
1296           print_address (i->output_section->vma + i->output_offset);
1297           fprintf (config.map_file, " ");
1298           print_size (i->_raw_size);
1299           fprintf (config.map_file, " ");
1300           print_size(i->_cooked_size);
1301           fprintf (config.map_file, " ");
1302           print_alignment (i->alignment_power);
1303           fprintf (config.map_file, " ");
1304           if (in->ifile)
1305             {
1306
1307               bfd *abfd = in->ifile->the_bfd;
1308
1309               if (in->ifile->just_syms_flag == true)
1310                 {
1311                   fprintf (config.map_file, "symbols only ");
1312                 }
1313
1314               fprintf (config.map_file, " %s ", abfd->xvec->name);
1315               if (abfd->my_archive != (bfd *) NULL)
1316                 {
1317                   fprintf (config.map_file, "[%s]%s", abfd->my_archive->filename,
1318                            abfd->filename);
1319                 }
1320               else
1321                 {
1322                   fprintf (config.map_file, "%s", abfd->filename);
1323                 }
1324               fprintf (config.map_file, "(overhead %d bytes)", (int) bfd_alloc_size (abfd));
1325               print_nl ();
1326
1327               /* Print all the symbols */
1328               bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
1329             }
1330           else
1331             {
1332               print_nl ();
1333             }
1334
1335
1336           print_dot = outside_section_address (i) + size;
1337         }
1338       else
1339         {
1340           fprintf (config.map_file, "No output section allocated\n");
1341         }
1342     }
1343 }
1344
1345 static void
1346 print_fill_statement (fill)
1347      lang_fill_statement_type * fill;
1348 {
1349   fprintf (config.map_file, "FILL mask ");
1350   print_fill (fill->fill);
1351 }
1352
1353 static void
1354 print_data_statement (data)
1355      lang_data_statement_type * data;
1356 {
1357 /*  bfd_vma value; */
1358   print_section ("");
1359   print_space ();
1360   print_section ("");
1361   print_space ();
1362 /*  ASSERT(print_dot == data->output_vma);*/
1363
1364   print_address (data->output_vma + data->output_section->vma);
1365   print_space ();
1366   print_address (data->value);
1367   print_space ();
1368   switch (data->type)
1369     {
1370     case BYTE:
1371       fprintf (config.map_file, "BYTE ");
1372       print_dot += BYTE_SIZE;
1373       break;
1374     case SHORT:
1375       fprintf (config.map_file, "SHORT ");
1376       print_dot += SHORT_SIZE;
1377       break;
1378     case LONG:
1379       fprintf (config.map_file, "LONG ");
1380       print_dot += LONG_SIZE;
1381       break;
1382     case QUAD:
1383       fprintf (config.map_file, "QUAD ");
1384       print_dot += QUAD_SIZE;
1385       break;
1386     }
1387
1388   exp_print_tree (data->exp);
1389
1390   fprintf (config.map_file, "\n");
1391 }
1392
1393 /* Print a reloc statement.  */
1394
1395 static void
1396 print_reloc_statement (reloc)
1397      lang_reloc_statement_type *reloc;
1398 {
1399   print_section ("");
1400   print_space ();
1401   print_section ("");
1402   print_space ();
1403
1404 /*  ASSERT(print_dot == data->output_vma);*/
1405
1406   print_address (reloc->output_vma + reloc->output_section->vma);
1407   print_space ();
1408   print_address (reloc->addend_value);
1409   print_space ();
1410
1411   fprintf (config.map_file, "RELOC %s ", reloc->howto->name);
1412
1413   print_dot += bfd_get_reloc_size (reloc->howto);
1414
1415   exp_print_tree (reloc->addend_exp);
1416
1417   fprintf (config.map_file, "\n");
1418 }
1419
1420 static void
1421 print_padding_statement (s)
1422      lang_padding_statement_type * s;
1423 {
1424   print_section ("");
1425   print_space ();
1426   print_section ("*fill*");
1427   print_space ();
1428   print_address (s->output_offset + s->output_section->vma);
1429   print_space ();
1430   print_size (s->size);
1431   print_space ();
1432   print_fill (s->fill);
1433   print_nl ();
1434
1435   print_dot = s->output_offset + s->output_section->vma + s->size;
1436
1437 }
1438
1439 static void
1440 print_wild_statement (w, os)
1441      lang_wild_statement_type * w;
1442      lang_output_section_statement_type * os;
1443 {
1444   fprintf (config.map_file, " from ");
1445   if (w->filename != (char *) NULL)
1446     {
1447       fprintf (config.map_file, "%s", w->filename);
1448     }
1449   else
1450     {
1451       fprintf (config.map_file, "*");
1452     }
1453   if (w->section_name != (char *) NULL)
1454     {
1455       fprintf (config.map_file, "(%s)", w->section_name);
1456     }
1457   else
1458     {
1459       fprintf (config.map_file, "(*)");
1460     }
1461   print_nl ();
1462   print_statement (w->children.head, os);
1463
1464 }
1465 static void
1466 print_statement (s, os)
1467      lang_statement_union_type * s;
1468      lang_output_section_statement_type * os;
1469 {
1470   while (s)
1471     {
1472       switch (s->header.type)
1473         {
1474           case lang_constructors_statement_enum:
1475           fprintf (config.map_file, "constructors:\n");
1476           print_statement (constructor_list.head, os);
1477           break;
1478         case lang_wild_statement_enum:
1479           print_wild_statement (&s->wild_statement, os);
1480           break;
1481         default:
1482           fprintf (config.map_file, "Fail with %d\n", s->header.type);
1483           FAIL ();
1484           break;
1485         case lang_address_statement_enum:
1486           fprintf (config.map_file, "address\n");
1487           break;
1488         case lang_object_symbols_statement_enum:
1489           fprintf (config.map_file, "object symbols\n");
1490           break;
1491         case lang_fill_statement_enum:
1492           print_fill_statement (&s->fill_statement);
1493           break;
1494         case lang_data_statement_enum:
1495           print_data_statement (&s->data_statement);
1496           break;
1497         case lang_reloc_statement_enum:
1498           print_reloc_statement (&s->reloc_statement);
1499           break;
1500         case lang_input_section_enum:
1501           print_input_section (&s->input_section);
1502           break;
1503         case lang_padding_statement_enum:
1504           print_padding_statement (&s->padding_statement);
1505           break;
1506         case lang_output_section_statement_enum:
1507           print_output_section_statement (&s->output_section_statement);
1508           break;
1509         case lang_assignment_statement_enum:
1510           print_assignment (&s->assignment_statement,
1511                             os);
1512           break;
1513         case lang_target_statement_enum:
1514           fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
1515           break;
1516         case lang_output_statement_enum:
1517           fprintf (config.map_file, "OUTPUT(%s %s)\n",
1518                    s->output_statement.name,
1519                    output_target ? output_target : "");
1520           break;
1521         case lang_input_statement_enum:
1522           print_input_statement (&s->input_statement);
1523           break;
1524         case lang_afile_asection_pair_statement_enum:
1525           FAIL ();
1526           break;
1527         }
1528       s = s->next;
1529     }
1530 }
1531
1532
1533 static void
1534 print_statements ()
1535 {
1536   print_statement (statement_list.head,
1537                    abs_output_section);
1538
1539 }
1540
1541 static bfd_vma
1542 insert_pad (this_ptr, fill, power, output_section_statement, dot)
1543      lang_statement_union_type ** this_ptr;
1544      fill_type fill;
1545      unsigned int power;
1546      asection * output_section_statement;
1547      bfd_vma dot;
1548 {
1549   /* Align this section first to the
1550      input sections requirement, then
1551      to the output section's requirement.
1552      If this alignment is > than any seen before,
1553      then record it too. Perform the alignment by
1554      inserting a magic 'padding' statement.
1555      */
1556
1557   unsigned int alignment_needed = align_power (dot, power) - dot;
1558
1559   if (alignment_needed != 0)
1560     {
1561       lang_statement_union_type *new =
1562       (lang_statement_union_type *)
1563       stat_alloc ((bfd_size_type) (sizeof (lang_padding_statement_type)));
1564
1565       /* Link into existing chain */
1566       new->header.next = *this_ptr;
1567       *this_ptr = new;
1568       new->header.type = lang_padding_statement_enum;
1569       new->padding_statement.output_section = output_section_statement;
1570       new->padding_statement.output_offset =
1571         dot - output_section_statement->vma;
1572       new->padding_statement.fill = fill;
1573       new->padding_statement.size = alignment_needed;
1574     }
1575
1576
1577   /* Remember the most restrictive alignment */
1578   if (power > output_section_statement->alignment_power)
1579     {
1580       output_section_statement->alignment_power = power;
1581     }
1582   output_section_statement->_raw_size += alignment_needed;
1583   return alignment_needed + dot;
1584
1585 }
1586
1587 /* Work out how much this section will move the dot point */
1588 static bfd_vma
1589 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
1590      lang_statement_union_type ** this_ptr;
1591      lang_output_section_statement_type * output_section_statement;
1592      fill_type fill;
1593      bfd_vma dot;
1594      boolean relax;
1595 {
1596   lang_input_section_type *is = &((*this_ptr)->input_section);
1597   asection *i = is->section;
1598
1599   if (is->ifile->just_syms_flag == false)
1600     {
1601       if (output_section_statement->subsection_alignment != -1)
1602        i->alignment_power =
1603         output_section_statement->subsection_alignment;
1604
1605       dot = insert_pad (this_ptr, fill, i->alignment_power,
1606                         output_section_statement->bfd_section, dot);
1607
1608       /* Remember where in the output section this input section goes */
1609
1610       i->output_offset = dot - output_section_statement->bfd_section->vma;
1611
1612       /* Mark how big the output section must be to contain this now
1613          */
1614       if (relax)
1615         {
1616           dot += i->_cooked_size;
1617         }
1618       else
1619         {
1620           dot += i->_raw_size;
1621         }
1622       output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
1623     }
1624   else
1625     {
1626       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
1627     }
1628
1629   return dot;
1630 }
1631
1632 /* This variable indicates whether bfd_relax_section should be called
1633    again.  */
1634
1635 static boolean relax_again;
1636
1637 /* Set the sizes for all the output sections.  */
1638
1639 bfd_vma
1640 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
1641      lang_statement_union_type * s;
1642      lang_output_section_statement_type * output_section_statement;
1643      lang_statement_union_type ** prev;
1644      fill_type fill;
1645      bfd_vma dot;
1646      boolean relax;
1647 {
1648   /* Size up the sections from their constituent parts */
1649   for (; s != (lang_statement_union_type *) NULL; s = s->next)
1650   {
1651     switch (s->header.type)
1652     {
1653
1654      case lang_output_section_statement_enum:
1655      {
1656        bfd_vma after;
1657        lang_output_section_statement_type *os = &s->output_section_statement;
1658
1659        /* If this is a shared library section, don't change the size
1660           and address.  */
1661        if (os->bfd_section->flags & SEC_SHARED_LIBRARY)
1662          break;
1663
1664        if (os->bfd_section == &bfd_abs_section)
1665        {
1666          /* No matter what happens, an abs section starts at zero */
1667          bfd_set_section_vma (0, os->bfd_section, 0);
1668        }
1669        else
1670        {
1671          if (os->addr_tree == (etree_type *) NULL)
1672          {
1673            /* No address specified for this section, get one
1674               from the region specification
1675               */
1676            if (os->region == (lang_memory_region_type *) NULL)
1677            {
1678              os->region = lang_memory_region_lookup ("*default*");
1679            }
1680            dot = os->region->current;
1681          }
1682          else
1683          {
1684            etree_value_type r;
1685
1686            r = exp_fold_tree (os->addr_tree,
1687                               abs_output_section,
1688                               lang_allocating_phase_enum,
1689                               dot, &dot);
1690            if (r.valid == false)
1691            {
1692              einfo ("%F%S: non constant address expression for section %s\n",
1693                     os->name);
1694            }
1695            dot = r.value;
1696          }
1697          /* The section starts here */
1698          /* First, align to what the section needs */
1699
1700          if (os->section_alignment != -1)
1701            dot = align_power (dot, os->section_alignment);
1702
1703          bfd_set_section_vma (0, os->bfd_section, dot);
1704
1705          if (os->load_base) {
1706            os->bfd_section->lma
1707              = exp_get_value_int(os->load_base, 0,"load base", lang_final_phase_enum);
1708          }
1709        }
1710
1711
1712        os->bfd_section->output_offset = 0;
1713
1714        (void) lang_size_sections (os->children.head, os, &os->children.head,
1715                                   os->fill, dot, relax);
1716        /* Ignore the size of the input sections, use the vma and size to */
1717        /* align against */
1718
1719        after = ALIGN_N (os->bfd_section->vma +
1720                         os->bfd_section->_raw_size,
1721                         /* The coercion here is important, see ld.h.  */
1722                         (bfd_vma) os->block_value);
1723
1724        os->bfd_section->_raw_size = after - os->bfd_section->vma;
1725        dot = os->bfd_section->vma + os->bfd_section->_raw_size;
1726        os->processed = true;
1727
1728        /* Replace into region ? */
1729        if (os->addr_tree == (etree_type *) NULL
1730            && os->region != (lang_memory_region_type *) NULL)
1731        {
1732          os->region->current = dot;
1733          /* Make sure this isn't silly */
1734          if (( os->region->current
1735               > os->region->origin + os->region->length)
1736              || ( os->region->origin > os->region->current ))
1737            {
1738              einfo ("%X%P: region %s is full (%B section %s)\n",
1739                     os->region->name,
1740                     os->bfd_section->owner,
1741                     os->bfd_section->name);
1742              /* Reset the region pointer */
1743              os->region->current = 0;
1744
1745            }
1746
1747        }
1748      }
1749
1750       break;
1751      case lang_constructors_statement_enum:
1752       dot = lang_size_sections (constructor_list.head,
1753                                 output_section_statement,
1754                                 &s->wild_statement.children.head,
1755                                 fill,
1756                                 dot, relax);
1757       break;
1758
1759      case lang_data_statement_enum:
1760      {
1761        unsigned int size = 0;
1762
1763        s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
1764        s->data_statement.output_section =
1765         output_section_statement->bfd_section;
1766
1767        switch (s->data_statement.type)
1768        {
1769         case QUAD:
1770          size = QUAD_SIZE;
1771          break;
1772         case LONG:
1773          size = LONG_SIZE;
1774          break;
1775         case SHORT:
1776          size = SHORT_SIZE;
1777          break;
1778         case BYTE:
1779          size = BYTE_SIZE;
1780          break;
1781
1782        }
1783        dot += size;
1784        output_section_statement->bfd_section->_raw_size += size;
1785      }
1786       break;
1787
1788      case lang_reloc_statement_enum:
1789      {
1790        int size;
1791
1792        s->reloc_statement.output_vma =
1793          dot - output_section_statement->bfd_section->vma;
1794        s->reloc_statement.output_section =
1795          output_section_statement->bfd_section;
1796        size = bfd_get_reloc_size (s->reloc_statement.howto);
1797        dot += size;
1798        output_section_statement->bfd_section->_raw_size += size;
1799      }
1800      break;
1801
1802      case lang_wild_statement_enum:
1803
1804       dot = lang_size_sections (s->wild_statement.children.head,
1805                                 output_section_statement,
1806                                 &s->wild_statement.children.head,
1807
1808                                 fill, dot, relax);
1809
1810       break;
1811
1812      case lang_object_symbols_statement_enum:
1813       link_info.create_object_symbols_section =
1814         output_section_statement->bfd_section;
1815       break;
1816      case lang_output_statement_enum:
1817      case lang_target_statement_enum:
1818       break;
1819      case lang_input_section_enum:
1820       {
1821         asection *i;
1822
1823         i = (*prev)->input_section.section;
1824         if (! relax)
1825           i->_cooked_size = i->_raw_size;
1826         else
1827           {
1828             boolean again;
1829
1830             if (! bfd_relax_section (i->owner, i, &link_info, &again))
1831               einfo ("%P%F: can't relax section: %E\n");
1832             if (again)
1833               relax_again = true;
1834           }
1835         dot = size_input_section (prev,
1836                                   output_section_statement,
1837                                   output_section_statement->fill,
1838                                   dot, relax);
1839       }
1840       break;
1841      case lang_input_statement_enum:
1842       break;
1843      case lang_fill_statement_enum:
1844       s->fill_statement.output_section = output_section_statement->bfd_section;
1845
1846       fill = s->fill_statement.fill;
1847       break;
1848      case lang_assignment_statement_enum:
1849      {
1850        bfd_vma newdot = dot;
1851
1852        exp_fold_tree (s->assignment_statement.exp,
1853                       output_section_statement,
1854                       lang_allocating_phase_enum,
1855                       dot,
1856                       &newdot);
1857
1858        if (newdot != dot && !relax)
1859         /* We've been moved ! so insert a pad */
1860        {
1861          lang_statement_union_type *new =
1862           (lang_statement_union_type *)
1863            stat_alloc ((bfd_size_type) (sizeof (lang_padding_statement_type)));
1864
1865          /* Link into existing chain */
1866          new->header.next = *prev;
1867          *prev = new;
1868          new->header.type = lang_padding_statement_enum;
1869          new->padding_statement.output_section =
1870           output_section_statement->bfd_section;
1871          new->padding_statement.output_offset =
1872           dot - output_section_statement->bfd_section->vma;
1873          new->padding_statement.fill = fill;
1874          new->padding_statement.size = newdot - dot;
1875          output_section_statement->bfd_section->_raw_size +=
1876           new->padding_statement.size;
1877          dot = newdot;
1878        }
1879      }
1880
1881       break;
1882      default:
1883       FAIL ();
1884       break;
1885       /* This can only get here when relaxing is turned on */
1886      case lang_padding_statement_enum:
1887
1888      case lang_address_statement_enum:
1889       break;
1890     }
1891     prev = &s->header.next;
1892   }
1893   return dot;
1894 }
1895
1896 static bfd_vma
1897 lang_do_assignments (s, output_section_statement, fill, dot)
1898      lang_statement_union_type * s;
1899      lang_output_section_statement_type * output_section_statement;
1900      fill_type fill;
1901      bfd_vma dot;
1902 {
1903   for (; s != (lang_statement_union_type *) NULL; s = s->next)
1904     {
1905       switch (s->header.type)
1906         {
1907         case lang_constructors_statement_enum:
1908           dot = lang_do_assignments (constructor_list.head,
1909                                      output_section_statement,
1910                                      fill,
1911                                      dot);
1912           break;
1913
1914         case lang_output_section_statement_enum:
1915           {
1916             lang_output_section_statement_type *os =
1917             &(s->output_section_statement);
1918
1919             dot = os->bfd_section->vma;
1920             (void) lang_do_assignments (os->children.head, os, os->fill, dot);
1921             dot = os->bfd_section->vma + os->bfd_section->_raw_size;
1922           }
1923           break;
1924         case lang_wild_statement_enum:
1925
1926           dot = lang_do_assignments (s->wild_statement.children.head,
1927                                      output_section_statement,
1928                                      fill, dot);
1929
1930           break;
1931
1932         case lang_object_symbols_statement_enum:
1933         case lang_output_statement_enum:
1934         case lang_target_statement_enum:
1935 #if 0
1936         case lang_common_statement_enum:
1937 #endif
1938           break;
1939         case lang_data_statement_enum:
1940           {
1941             etree_value_type value;
1942
1943             value = exp_fold_tree (s->data_statement.exp,
1944                                    abs_output_section,
1945                                    lang_final_phase_enum, dot, &dot);
1946             s->data_statement.value = value.value;
1947             if (value.valid == false)
1948               einfo ("%F%P: invalid data statement\n");
1949           }
1950           switch (s->data_statement.type)
1951             {
1952             case QUAD:
1953               dot += QUAD_SIZE;
1954               break;
1955             case LONG:
1956               dot += LONG_SIZE;
1957               break;
1958             case SHORT:
1959               dot += SHORT_SIZE;
1960               break;
1961             case BYTE:
1962               dot += BYTE_SIZE;
1963               break;
1964             }
1965           break;
1966
1967         case lang_reloc_statement_enum:
1968           {
1969             etree_value_type value;
1970
1971             value = exp_fold_tree (s->reloc_statement.addend_exp,
1972                                    abs_output_section,
1973                                    lang_final_phase_enum, dot, &dot);
1974             s->reloc_statement.addend_value = value.value;
1975             if (value.valid == false)
1976               einfo ("%F%P: invalid reloc statement\n");
1977           }
1978           dot += bfd_get_reloc_size (s->reloc_statement.howto);
1979           break;
1980
1981         case lang_input_section_enum:
1982           {
1983             asection *in = s->input_section.section;
1984
1985             dot += bfd_get_section_size_before_reloc (in);
1986           }
1987           break;
1988
1989         case lang_input_statement_enum:
1990           break;
1991         case lang_fill_statement_enum:
1992           fill = s->fill_statement.fill;
1993           break;
1994         case lang_assignment_statement_enum:
1995           {
1996             exp_fold_tree (s->assignment_statement.exp,
1997                            output_section_statement,
1998                            lang_final_phase_enum,
1999                            dot,
2000                            &dot);
2001           }
2002
2003           break;
2004         case lang_padding_statement_enum:
2005           dot += s->padding_statement.size;
2006           break;
2007         default:
2008           FAIL ();
2009           break;
2010         case lang_address_statement_enum:
2011           break;
2012         }
2013
2014     }
2015   return dot;
2016 }
2017
2018 static void
2019 lang_finish ()
2020 {
2021   struct bfd_link_hash_entry *h;
2022   boolean warn = link_info.relocateable ? false : true;
2023
2024   if (entry_symbol == (char *) NULL)
2025     {
2026       /* No entry has been specified.  Look for start, but don't warn
2027          if we don't find it.  */
2028       entry_symbol = "start";
2029       warn = false;
2030     }
2031
2032   h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
2033   if (h != (struct bfd_link_hash_entry *) NULL
2034       && h->type == bfd_link_hash_defined)
2035     {
2036       bfd_vma val;
2037
2038       val = (h->u.def.value
2039              + bfd_get_section_vma (output_bfd,
2040                                     h->u.def.section->output_section)
2041              + h->u.def.section->output_offset);
2042       if (! bfd_set_start_address (output_bfd, val))
2043         einfo ("%P%F:%s: can't set start address\n", entry_symbol);
2044     }
2045   else
2046     {
2047       asection *ts;
2048
2049       /* Can't find the entry symbol.  Use the first address in the
2050          text section.  */
2051       ts = bfd_get_section_by_name (output_bfd, ".text");
2052       if (ts != (asection *) NULL)
2053         {
2054           if (warn)
2055             einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2056                    entry_symbol, bfd_get_section_vma (output_bfd, ts));
2057           if (! bfd_set_start_address (output_bfd,
2058                                        bfd_get_section_vma (output_bfd, ts)))
2059             einfo ("%P%F: can't set start address\n");
2060         }
2061       else
2062         {
2063           if (warn)
2064             einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2065                    entry_symbol);
2066         }
2067     }
2068 }
2069
2070 /* By now we know the target architecture, and we may have an */
2071 /* ldfile_output_machine_name */
2072 static void
2073 lang_check ()
2074 {
2075   lang_statement_union_type *file;
2076   bfd *input_bfd;
2077   unsigned long input_machine;
2078   enum bfd_architecture input_architecture;
2079   CONST bfd_arch_info_type *compatible;
2080
2081   for (file = file_chain.head;
2082        file != (lang_statement_union_type *) NULL;
2083        file = file->input_statement.next)
2084     {
2085       input_bfd = file->input_statement.the_bfd;
2086
2087       input_machine = bfd_get_mach (input_bfd);
2088       input_architecture = bfd_get_arch (input_bfd);
2089
2090
2091       /* Inspect the architecture and ensure we're linking like with
2092          like */
2093
2094       compatible = bfd_arch_get_compatible (input_bfd,
2095                                             output_bfd);
2096
2097       if (compatible)
2098         {
2099           ldfile_output_machine = compatible->mach;
2100           ldfile_output_architecture = compatible->arch;
2101         }
2102       else
2103         {
2104
2105           einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2106                 bfd_printable_name (input_bfd), input_bfd,
2107                 bfd_printable_name (output_bfd));
2108
2109           if (! bfd_set_arch_mach (output_bfd,
2110                                    input_architecture,
2111                                    input_machine))
2112             einfo ("%P%F:%s: can't set architecture: %E\n",
2113                    bfd_get_filename (output_bfd));
2114         }
2115
2116     }
2117 }
2118
2119 /* Look through all the global common symbols and attach them to the
2120    correct section.  The -sort-common command line switch may be used
2121    to roughly sort the entries by size.  */
2122
2123 static void
2124 lang_common ()
2125 {
2126   if (link_info.relocateable
2127       && ! command_line.force_common_definition)
2128     return;
2129
2130   if (! config.sort_common)
2131     bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
2132   else
2133     {
2134       unsigned int power;
2135
2136       for (power = 1; power <= 16; power <<= 1)
2137         bfd_link_hash_traverse (link_info.hash, lang_one_common,
2138                                 (PTR) &power);
2139     }
2140 }
2141
2142 /* Place one common symbol in the correct section.  */
2143
2144 static boolean
2145 lang_one_common (h, info)
2146      struct bfd_link_hash_entry *h;
2147      PTR info;
2148 {
2149   unsigned int power_of_two;
2150   bfd_vma size;
2151   size_t align;
2152   asection *section;
2153
2154   if (h->type != bfd_link_hash_common)
2155     return true;
2156
2157   size = h->u.c.size;
2158   switch (size)
2159     {
2160     case 0:
2161     case 1:
2162       power_of_two = 0;
2163       align = 1;
2164       break;
2165     case 2:
2166       power_of_two = 1;
2167       align = 2;
2168       break;
2169     case 3:
2170     case 4:
2171       power_of_two = 2;
2172       align = 4;
2173       break;
2174     case 5:
2175     case 6:
2176     case 7:
2177     case 8:
2178       power_of_two = 3;
2179       align = 8;
2180       break;
2181     default:
2182       power_of_two = 4;
2183       align = 16;
2184       break;
2185     }
2186
2187   if (config.sort_common && align != *(unsigned int *) info)
2188     return true;
2189
2190   section = h->u.c.section;
2191
2192   /* Increase the size of the section.  */
2193   section->_raw_size = ALIGN_N (section->_raw_size, align);
2194
2195   /* Adjust the alignment if necessary.  */
2196   if (power_of_two > section->alignment_power)
2197     section->alignment_power = power_of_two;
2198
2199   /* Change the symbol from common to defined.  */
2200   h->type = bfd_link_hash_defined;
2201   h->u.def.section = section;
2202   h->u.def.value = section->_raw_size;
2203
2204   /* Increase the size of the section.  */
2205   section->_raw_size += size;
2206
2207   if (config.map_file != NULL)
2208     fprintf (config.map_file, "Allocating common %s: %lx at %lx %s\n",
2209              h->root.string, (unsigned long) size,
2210              (unsigned long) h->u.def.value, section->owner->filename);
2211
2212   return true;
2213 }
2214
2215 /*
2216 run through the input files and ensure that every input
2217 section has somewhere to go. If one is found without
2218 a destination then create an input request and place it
2219 into the statement tree.
2220 */
2221
2222 static void
2223 lang_place_orphans ()
2224 {
2225   lang_input_statement_type *file;
2226
2227   for (file = (lang_input_statement_type *) file_chain.head;
2228        file != (lang_input_statement_type *) NULL;
2229        file = (lang_input_statement_type *) file->next)
2230     {
2231       asection *s;
2232
2233       for (s = file->the_bfd->sections;
2234            s != (asection *) NULL;
2235            s = s->next)
2236         {
2237           if (s->output_section == (asection *) NULL)
2238             {
2239               /* This section of the file is not attatched, root
2240                  around for a sensible place for it to go */
2241
2242               if (file->common_section == s)
2243                 {
2244                   /* This is a lonely common section which must
2245                      have come from an archive. We attatch to the
2246                      section with the wildcard  */
2247                   if (! link_info.relocateable
2248                       && ! command_line.force_common_definition)
2249                     {
2250                       if (default_common_section ==
2251                           (lang_output_section_statement_type *) NULL)
2252                         {
2253                           info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2254
2255                           default_common_section =
2256                             lang_output_section_statement_lookup (".bss");
2257
2258                         }
2259                       wild_doit (&default_common_section->children, s,
2260                                  default_common_section, file);
2261                     }
2262                 }
2263               else
2264                 {
2265                   lang_output_section_statement_type *os =
2266                   lang_output_section_statement_lookup (s->name);
2267
2268                   wild_doit (&os->children, s, os, file);
2269                 }
2270             }
2271         }
2272     }
2273 }
2274
2275
2276 void
2277 lang_set_flags (ptr, flags)
2278      int *ptr;
2279      CONST char *flags;
2280 {
2281   boolean state = false;
2282
2283   *ptr = 0;
2284   while (*flags)
2285     {
2286       if (*flags == '!')
2287         {
2288           state = false;
2289           flags++;
2290         }
2291       else
2292         state = true;
2293       switch (*flags)
2294         {
2295         case 'R':
2296           /*      ptr->flag_read = state; */
2297           break;
2298         case 'W':
2299           /*      ptr->flag_write = state; */
2300           break;
2301         case 'X':
2302           /*      ptr->flag_executable= state;*/
2303           break;
2304         case 'L':
2305         case 'I':
2306           /*      ptr->flag_loadable= state;*/
2307           break;
2308         default:
2309           einfo ("%P%F: invalid syntax in flags\n");
2310           break;
2311         }
2312       flags++;
2313     }
2314 }
2315
2316
2317
2318 void
2319 lang_for_each_file (func)
2320      void (*func) PARAMS ((lang_input_statement_type *));
2321 {
2322   lang_input_statement_type *f;
2323
2324   for (f = (lang_input_statement_type *) file_chain.head;
2325        f != (lang_input_statement_type *) NULL;
2326        f = (lang_input_statement_type *) f->next)
2327     {
2328       func (f);
2329     }
2330 }
2331
2332 #if 0
2333
2334 /* Not used.  */
2335
2336 void
2337 lang_for_each_input_section (func)
2338      void (*func) PARAMS ((bfd * ab, asection * as));
2339 {
2340   lang_input_statement_type *f;
2341
2342   for (f = (lang_input_statement_type *) file_chain.head;
2343        f != (lang_input_statement_type *) NULL;
2344        f = (lang_input_statement_type *) f->next)
2345     {
2346       asection *s;
2347
2348       for (s = f->the_bfd->sections;
2349            s != (asection *) NULL;
2350            s = s->next)
2351         {
2352           func (f->the_bfd, s);
2353         }
2354     }
2355 }
2356
2357 #endif
2358
2359 void
2360 ldlang_add_file (entry)
2361      lang_input_statement_type * entry;
2362 {
2363   bfd **pp;
2364
2365   lang_statement_append (&file_chain,
2366                          (lang_statement_union_type *) entry,
2367                          &entry->next);
2368
2369   /* The BFD linker needs to have a list of all input BFDs involved in
2370      a link.  */
2371   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
2372   ASSERT (entry->the_bfd != output_bfd);
2373   for (pp = &link_info.input_bfds;
2374        *pp != (bfd *) NULL;
2375        pp = &(*pp)->link_next)
2376     ;
2377   *pp = entry->the_bfd;
2378   entry->the_bfd->usrdata = (PTR) entry;
2379   bfd_set_gp_size (entry->the_bfd, g_switch_value);
2380 }
2381
2382 void
2383 lang_add_output (name, from_script)
2384      CONST char *name;
2385      int from_script;
2386 {
2387   /* Make -o on command line override OUTPUT in script.  */
2388   if (had_output_filename == false || !from_script)
2389     {
2390       output_filename = name;
2391       had_output_filename = true;
2392     }
2393 }
2394
2395
2396 static lang_output_section_statement_type *current_section;
2397
2398 static int topower(x)
2399      int x;
2400 {
2401   unsigned  int i = 1;
2402   int l;
2403   if (x < 0) return -1;
2404   for (l = 0; l < 32; l++)
2405   {
2406     if (i >= x) return l;
2407     i<<=1;
2408   }
2409   return 0;
2410 }
2411 void
2412 lang_enter_output_section_statement (output_section_statement_name,
2413                                      address_exp, flags, block_value,
2414                                      align, subalign, ebase)
2415      const char *output_section_statement_name;
2416      etree_type * address_exp;
2417      int flags;
2418      bfd_vma block_value;
2419      etree_type *align;
2420      etree_type *subalign;
2421      etree_type *ebase;
2422 {
2423   lang_output_section_statement_type *os;
2424
2425   current_section =
2426    os =
2427     lang_output_section_statement_lookup (output_section_statement_name);
2428
2429
2430
2431   /* Add this statement to tree */
2432   /*  add_statement(lang_output_section_statement_enum,
2433       output_section_statement);*/
2434   /* Make next things chain into subchain of this */
2435
2436   if (os->addr_tree ==
2437       (etree_type *) NULL)
2438   {
2439     os->addr_tree =
2440      address_exp;
2441   }
2442   os->flags = flags;
2443   if (flags & SEC_NEVER_LOAD)
2444    os->loadable = 0;
2445   else
2446    os->loadable = 1;
2447   os->block_value = block_value ? block_value : 1;
2448   stat_ptr = &os->children;
2449
2450   os->subsection_alignment = topower(
2451    exp_get_value_int(subalign, -1,
2452                      "subsection alignment",
2453                      0));
2454   os->section_alignment = topower(
2455    exp_get_value_int(align, -1,
2456                      "section alignment", 0));
2457
2458   os->load_base = ebase;
2459 }
2460
2461
2462 void
2463 lang_final ()
2464 {
2465   lang_output_statement_type *new =
2466     new_stat (lang_output_statement, stat_ptr);
2467
2468   new->name = output_filename;
2469 }
2470
2471 /* Reset the current counters in the regions */
2472 static void
2473 reset_memory_regions ()
2474 {
2475   lang_memory_region_type *p = lang_memory_region_list;
2476
2477   for (p = lang_memory_region_list;
2478        p != (lang_memory_region_type *) NULL;
2479        p = p->next)
2480     {
2481       p->old_length = (bfd_size_type) (p->current - p->origin);
2482       p->current = p->origin;
2483     }
2484 }
2485
2486 void
2487 lang_process ()
2488 {
2489   lang_reasonable_defaults ();
2490   current_target = default_target;
2491
2492   lang_for_each_statement (ldlang_open_output); /* Open the output file */
2493   /* For each output section statement, create a section in the output
2494      file */
2495   lang_create_output_section_statements ();
2496
2497   ldemul_create_output_section_statements ();
2498
2499   /* Add to the hash table all undefineds on the command line */
2500   lang_place_undefineds ();
2501
2502   /* Create a bfd for each input file */
2503   current_target = default_target;
2504   lang_for_each_statement (open_input_bfds);
2505
2506   /* Build all sets based on the information gathered from the input
2507      files.  */
2508   ldctor_build_sets ();
2509
2510   /* Size up the common data */
2511   lang_common ();
2512
2513   /* Run through the contours of the script and attatch input sections
2514      to the correct output sections
2515      */
2516   map_input_to_output_sections (statement_list.head, (char *) NULL,
2517                                 (lang_output_section_statement_type *) NULL);
2518
2519
2520   /* Find any sections not attatched explicitly and handle them */
2521   lang_place_orphans ();
2522
2523   ldemul_before_allocation ();
2524
2525   /* Now run around and relax if we can */
2526   if (command_line.relax)
2527     {
2528       /* First time round is a trial run to get the 'worst case'
2529          addresses of the objects if there was no relaxing.  */
2530       lang_size_sections (statement_list.head,
2531                           abs_output_section,
2532                           &(statement_list.head), 0, (bfd_vma) 0, false);
2533
2534
2535       reset_memory_regions ();
2536
2537       /* Keep relaxing until bfd_relax_section gives up.  */
2538       do
2539         {
2540           relax_again = false;
2541
2542           /* Do all the assignments with our current guesses as to
2543              section sizes.  */
2544           lang_do_assignments (statement_list.head,
2545                                abs_output_section,
2546                                (fill_type) 0, (bfd_vma) 0);
2547
2548           /* Perform another relax pass - this time we know where the
2549              globals are, so can make better guess.  */
2550           lang_size_sections (statement_list.head,
2551                               abs_output_section,
2552                               &(statement_list.head), 0, (bfd_vma) 0, true);
2553         }
2554       while (relax_again);
2555     }
2556   else
2557     {
2558       /* Size up the sections.  */
2559       lang_size_sections (statement_list.head,
2560                           abs_output_section,
2561                           &(statement_list.head), 0, (bfd_vma) 0, false);
2562     }
2563
2564   /* See if anything special should be done now we know how big
2565      everything is.  */
2566   ldemul_after_allocation ();
2567
2568   /* Do all the assignments, now that we know the final restingplaces
2569      of all the symbols */
2570
2571   lang_do_assignments (statement_list.head,
2572                        abs_output_section,
2573                        (fill_type) 0, (bfd_vma) 0);
2574
2575   /* Make sure that we're not mixing architectures */
2576
2577   lang_check ();
2578
2579   /* Final stuffs */
2580
2581   ldemul_finish ();
2582   lang_finish ();
2583 }
2584
2585 /* EXPORTED TO YACC */
2586
2587 void
2588 lang_add_wild (section_name, filename)
2589      CONST char *CONST section_name;
2590      CONST char *CONST filename;
2591 {
2592   lang_wild_statement_type *new = new_stat (lang_wild_statement,
2593                                             stat_ptr);
2594
2595   if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
2596     {
2597       placed_commons = true;
2598     }
2599   if (filename != (char *) NULL)
2600     {
2601       lang_has_input_file = true;
2602     }
2603   new->section_name = section_name;
2604   new->filename = filename;
2605   lang_list_init (&new->children);
2606 }
2607
2608 void
2609 lang_section_start (name, address)
2610      CONST char *name;
2611      etree_type * address;
2612 {
2613   lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
2614
2615   ad->section_name = name;
2616   ad->address = address;
2617 }
2618
2619 void
2620 lang_add_entry (name)
2621      CONST char *name;
2622 {
2623   entry_symbol = name;
2624 }
2625
2626 void
2627 lang_add_target (name)
2628      CONST char *name;
2629 {
2630   lang_target_statement_type *new = new_stat (lang_target_statement,
2631                                               stat_ptr);
2632
2633   new->target = name;
2634
2635 }
2636
2637 void
2638 lang_add_map (name)
2639      CONST char *name;
2640 {
2641   while (*name)
2642     {
2643       switch (*name)
2644         {
2645           case 'F':
2646           map_option_f = true;
2647           break;
2648         }
2649       name++;
2650     }
2651 }
2652
2653 void
2654 lang_add_fill (exp)
2655      int exp;
2656 {
2657   lang_fill_statement_type *new = new_stat (lang_fill_statement,
2658                                             stat_ptr);
2659
2660   new->fill = exp;
2661 }
2662
2663 void
2664 lang_add_data (type, exp)
2665      int type;
2666      union etree_union *exp;
2667 {
2668
2669   lang_data_statement_type *new = new_stat (lang_data_statement,
2670                                             stat_ptr);
2671
2672   new->exp = exp;
2673   new->type = type;
2674
2675 }
2676
2677 /* Create a new reloc statement.  RELOC is the BFD relocation type to
2678    generate.  HOWTO is the corresponding howto structure (we could
2679    look this up, but the caller has already done so).  SECTION is the
2680    section to generate a reloc against, or NAME is the name of the
2681    symbol to generate a reloc against.  Exactly one of SECTION and
2682    NAME must be NULL.  ADDEND is an expression for the addend.  */
2683
2684 void
2685 lang_add_reloc (reloc, howto, section, name, addend)
2686      bfd_reloc_code_real_type reloc;
2687      const reloc_howto_type *howto;
2688      asection *section;
2689      const char *name;
2690      union etree_union *addend;
2691 {
2692   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
2693
2694   p->reloc = reloc;
2695   p->howto = howto;
2696   p->section = section;
2697   p->name = name;
2698   p->addend_exp = addend;
2699
2700   p->addend_value = 0;
2701   p->output_section = NULL;
2702   p->output_vma = 0;
2703 }
2704
2705 void
2706 lang_add_assignment (exp)
2707      etree_type * exp;
2708 {
2709   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
2710                                                   stat_ptr);
2711
2712   new->exp = exp;
2713 }
2714
2715 void
2716 lang_add_attribute (attribute)
2717      enum statement_enum attribute;
2718 {
2719   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
2720 }
2721
2722 void
2723 lang_startup (name)
2724      CONST char *name;
2725 {
2726   if (startup_file != (char *) NULL)
2727     {
2728       einfo ("%P%Fmultiple STARTUP files\n");
2729     }
2730   first_file->filename = name;
2731   first_file->local_sym_name = name;
2732   first_file->real = true;
2733
2734   startup_file = name;
2735 }
2736
2737 void
2738 lang_float (maybe)
2739      boolean maybe;
2740 {
2741   lang_float_flag = maybe;
2742 }
2743
2744 void
2745 lang_leave_output_section_statement (fill, memspec)
2746      bfd_vma fill;
2747      CONST char *memspec;
2748 {
2749   current_section->fill = fill;
2750   current_section->region = lang_memory_region_lookup (memspec);
2751   stat_ptr = &statement_list;
2752
2753   /* We remember if we are closing a .data section, since we use it to
2754      store constructors in */
2755   if (strcmp (current_section->name, ".data") == 0)
2756     {
2757       end_of_data_section_statement_list = statement_list;
2758
2759     }
2760 }
2761
2762 /*
2763  Create an absolute symbol with the given name with the value of the
2764  address of first byte of the section named.
2765
2766  If the symbol already exists, then do nothing.
2767 */
2768 void
2769 lang_abs_symbol_at_beginning_of (secname, name)
2770      const char *secname;
2771      const char *name;
2772 {
2773   struct bfd_link_hash_entry *h;
2774
2775   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
2776   if (h == (struct bfd_link_hash_entry *) NULL)
2777     einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2778
2779   if (h->type == bfd_link_hash_new
2780       || h->type == bfd_link_hash_undefined)
2781     {
2782       asection *sec;
2783
2784       h->type = bfd_link_hash_defined;
2785
2786       sec = bfd_get_section_by_name (output_bfd, secname);
2787       if (sec == (asection *) NULL)
2788         h->u.def.value = 0;
2789       else
2790         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
2791
2792       h->u.def.section = &bfd_abs_section;
2793     }
2794 }
2795
2796 /*
2797  Create an absolute symbol with the given name with the value of the
2798  address of the first byte after the end of the section named.
2799
2800  If the symbol already exists, then do nothing.
2801 */
2802 void
2803 lang_abs_symbol_at_end_of (secname, name)
2804      const char *secname;
2805      const char *name;
2806 {
2807   struct bfd_link_hash_entry *h;
2808
2809   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
2810   if (h == (struct bfd_link_hash_entry *) NULL)
2811     einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2812
2813   if (h->type == bfd_link_hash_new
2814       || h->type == bfd_link_hash_undefined)
2815     {
2816       asection *sec;
2817
2818       h->type = bfd_link_hash_defined;
2819
2820       sec = bfd_get_section_by_name (output_bfd, secname);
2821       if (sec == (asection *) NULL)
2822         h->u.def.value = 0;
2823       else
2824         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
2825                           + bfd_section_size (output_bfd, sec));
2826
2827       h->u.def.section = &bfd_abs_section;
2828     }
2829 }
2830
2831 void
2832 lang_statement_append (list, element, field)
2833      lang_statement_list_type * list;
2834      lang_statement_union_type * element;
2835      lang_statement_union_type ** field;
2836 {
2837   *(list->tail) = element;
2838   list->tail = field;
2839 }
2840
2841 /* Set the output format type.  -oformat overrides scripts.  */
2842 void
2843 lang_add_output_format (format, from_script)
2844      CONST char *format;
2845      int from_script;
2846 {
2847   if (output_target == NULL || !from_script)
2848     output_target = format;
2849 }