ld/ldlang.c

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