ld/ldlang.c

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