ld/mpw-elfmips.c

   1 /* This file is is generated by a shell script.  DO NOT EDIT! */
   2
   3 /* 32 bit ELF emulation code for elf32ebmip
   4    Copyright (C) 1991, 93, 94, 95, 96, 98, 2000
   5    Free Software Foundation, Inc.
   6    Written by Steve Chamberlain <sac@cygnus.com>
   7    ELF support by Ian Lance Taylor <ian@cygnus.com>
   8
   9 This file is part of GLD, the Gnu Linker.
  10
  11 This program is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2 of the License, or
  14 (at your option) any later version.
  15
  16 This program is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with this program; if not, write to the Free Software
  23 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  24
  25 #define TARGET_IS_elf32ebmip
  26
  27 #include "bfd.h"
  28 #include "sysdep.h"
  29
  30 #include <ctype.h>
  31
  32 #include "bfdlink.h"
  33
  34 #include "ld.h"
  35 #include "ldmain.h"
  36 #include "ldmisc.h"
  37 #include "ldexp.h"
  38 #include "ldlang.h"
  39 #include "ldgram.h"
  40 #include "ldfile.h"
  41 #include "ldemul.h"
  42
  43 static void gldelf32ebmip_before_parse PARAMS ((void));
  44 static boolean gldelf32ebmip_open_dynamic_archive
  45   PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
  46 static void gldelf32ebmip_after_open PARAMS ((void));
  47 static void gldelf32ebmip_check_needed
  48   PARAMS ((lang_input_statement_type *));
  49 static void gldelf32ebmip_stat_needed
  50   PARAMS ((lang_input_statement_type *));
  51 static boolean gldelf32ebmip_search_needed
  52   PARAMS ((const char *, const char *));
  53 static boolean gldelf32ebmip_try_needed PARAMS ((const char *));
  54 static void gldelf32ebmip_before_allocation PARAMS ((void));
  55 static void gldelf32ebmip_find_statement_assignment
  56   PARAMS ((lang_statement_union_type *));
  57 static void gldelf32ebmip_find_exp_assignment PARAMS ((etree_type *));
  58 static boolean gldelf32ebmip_place_orphan
  59   PARAMS ((lang_input_statement_type *, asection *));
  60 static void gldelf32ebmip_place_section
  61   PARAMS ((lang_statement_union_type *));
  62 static char *gldelf32ebmip_get_script PARAMS ((int *isfile));
  63
  64 static void
  65 gldelf32ebmip_before_parse()
  66 {
  67   ldfile_output_architecture = bfd_arch_mips;
  68   config.dynamic_link = true;
  69 }
  70
  71 /* Try to open a dynamic archive.  This is where we know that ELF
  72    dynamic libraries have an extension of .so.  */
  73
  74 static boolean
  75 gldelf32ebmip_open_dynamic_archive (arch, search, entry)
  76      const char *arch;
  77      search_dirs_type *search;
  78      lang_input_statement_type *entry;
  79 {
  80   const char *filename;
  81   char *string;
  82
  83   if (! entry->is_archive)
  84     return false;
  85
  86   filename = entry->filename;
  87
  88   string = (char *) xmalloc (strlen (search->name)
  89                              + strlen (filename)
  90                              + strlen (arch)
  91                              + sizeof "/lib.so");
  92
  93   sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
  94
  95   if (! ldfile_try_open_bfd (string, entry))
  96     {
  97       free (string);
  98       return false;
  99     }
 100
 101   entry->filename = string;
 102
 103   /* We have found a dynamic object to include in the link.  The ELF
 104      backend linker will create a DT_NEEDED entry in the .dynamic
 105      section naming this file.  If this file includes a DT_SONAME
 106      entry, it will be used.  Otherwise, the ELF linker will just use
 107      the name of the file.  For an archive found by searching, like
 108      this one, the DT_NEEDED entry should consist of just the name of
 109      the file, without the path information used to find it.  Note
 110      that we only need to do this if we have a dynamic object; an
 111      archive will never be referenced by a DT_NEEDED entry.
 112
 113      FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
 114      very pretty.  I haven't been able to think of anything that is
 115      pretty, though.  */
 116   if (bfd_check_format (entry->the_bfd, bfd_object)
 117       && (entry->the_bfd->flags & DYNAMIC) != 0)
 118     {
 119       char *needed_name;
 120
 121       ASSERT (entry->is_archive && entry->search_dirs_flag);
 122       needed_name = (char *) xmalloc (strlen (filename)
 123                                       + strlen (arch)
 124                                       + sizeof "lib.so");
 125       sprintf (needed_name, "lib%s%s.so", filename, arch);
 126       bfd_elf_set_dt_needed_name (entry->the_bfd, needed_name);
 127     }
 128
 129   return true;
 130 }
 131
 132
 133 /* These variables are required to pass information back and forth
 134    between after_open and check_needed and stat_needed.  */
 135
 136 static struct bfd_link_needed_list *global_needed;
 137 static struct stat global_stat;
 138 static boolean global_found;
 139
 140 /* This is called after all the input files have been opened.  */
 141
 142 static void
 143 gldelf32ebmip_after_open ()
 144 {
 145   struct bfd_link_needed_list *needed, *l;
 146
 147   /* We only need to worry about this when doing a final link.  */
 148   if (link_info.relocateable || link_info.shared)
 149     return;
 150
 151   /* Get the list of files which appear in DT_NEEDED entries in
 152      dynamic objects included in the link (often there will be none).
 153      For each such file, we want to track down the corresponding
 154      library, and include the symbol table in the link.  This is what
 155      the runtime dynamic linker will do.  Tracking the files down here
 156      permits one dynamic object to include another without requiring
 157      special action by the person doing the link.  Note that the
 158      needed list can actually grow while we are stepping through this
 159      loop.  */
 160   needed = bfd_elf_get_needed_list (output_bfd, &link_info);
 161   for (l = needed; l != NULL; l = l->next)
 162     {
 163       struct bfd_link_needed_list *ll;
 164       const char *lib_path;
 165       size_t len;
 166       search_dirs_type *search;
 167
 168       /* If we've already seen this file, skip it.  */
 169       for (ll = needed; ll != l; ll = ll->next)
 170         if (strcmp (ll->name, l->name) == 0)
 171           break;
 172       if (ll != l)
 173         continue;
 174
 175       /* See if this file was included in the link explicitly.  */
 176       global_needed = l;
 177       global_found = false;
 178       lang_for_each_input_file (gldelf32ebmip_check_needed);
 179       if (global_found)
 180         continue;
 181
 182       /* We need to find this file and include the symbol table.  We
 183          want to search for the file in the same way that the dynamic
 184          linker will search.  That means that we want to use
 185          rpath_link, rpath, then the environment variable
 186          LD_LIBRARY_PATH (native only), then the linker script
 187          LIB_SEARCH_DIRS.  We do not search using the -L arguments.  */
 188       if (gldelf32ebmip_search_needed (command_line.rpath_link,
 189                                               l->name))
 190         continue;
 191       if (gldelf32ebmip_search_needed (command_line.rpath, l->name))
 192         continue;
 193       if (command_line.rpath_link == NULL
 194           && command_line.rpath == NULL)
 195         {
 196           lib_path = (const char *) getenv ("LD_RUN_PATH");
 197           if (gldelf32ebmip_search_needed (lib_path, l->name))
 198             continue;
 199         }
 200       len = strlen (l->name);
 201       for (search = search_head; search != NULL; search = search->next)
 202         {
 203           char *filename;
 204
 205           if (search->cmdline)
 206             continue;
 207           filename = (char *) xmalloc (strlen (search->name) + len + 2);
 208           sprintf (filename, "%s/%s", search->name, l->name);
 209           if (gldelf32ebmip_try_needed (filename))
 210             break;
 211           free (filename);
 212         }
 213       if (search != NULL)
 214         continue;
 215
 216       einfo (_("%P: warning: %s, needed by %B, not found\n"),
 217              l->name, l->by);
 218     }
 219 }
 220
 221 /* Search for a needed file in a path.  */
 222
 223 static boolean
 224 gldelf32ebmip_search_needed (path, name)
 225      const char *path;
 226      const char *name;
 227 {
 228   const char *s;
 229   size_t len;
 230
 231   if (path == NULL || *path == '\0')
 232     return false;
 233   len = strlen (name);
 234   while (1)
 235     {
 236       char *filename, *sset;
 237
 238       s = strchr (path, ':');
 239       if (s == NULL)
 240         s = path + strlen (path);
 241
 242       filename = (char *) xmalloc (s - path + len + 2);
 243       if (s == path)
 244         sset = filename;
 245       else
 246         {
 247           memcpy (filename, path, s - path);
 248           filename[s - path] = '/';
 249           sset = filename + (s - path) + 1;
 250         }
 251       strcpy (sset, name);
 252
 253       if (gldelf32ebmip_try_needed (filename))
 254         return true;
 255
 256       free (filename);
 257
 258       if (*s == '\0')
 259         break;
 260       path = s + 1;
 261     }
 262
 263   return false;
 264 }
 265
 266 /* This function is called for each possible name for a dynamic object
 267    named by a DT_NEEDED entry.  */
 268
 269 static boolean
 270 gldelf32ebmip_try_needed (name)
 271      const char *name;
 272 {
 273   bfd *abfd;
 274
 275   abfd = bfd_openr (name, bfd_get_target (output_bfd));
 276   if (abfd == NULL)
 277     return false;
 278   if (! bfd_check_format (abfd, bfd_object))
 279     {
 280       (void) bfd_close (abfd);
 281       return false;
 282     }
 283   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 284     {
 285       (void) bfd_close (abfd);
 286       return false;
 287     }
 288
 289   /* We've found a dynamic object matching the DT_NEEDED entry.  */
 290
 291   /* We have already checked that there is no other input file of the
 292      same name.  We must now check again that we are not including the
 293      same file twice.  We need to do this because on many systems
 294      libc.so is a symlink to, e.g., libc.so.1.  The SONAME entry will
 295      reference libc.so.1.  If we have already included libc.so, we
 296      don't want to include libc.so.1 if they are the same file, and we
 297      can only check that using stat.  */
 298
 299   if (bfd_stat (abfd, &global_stat) != 0)
 300     einfo (_("%F%P:%B: bfd_stat failed: %E\n"), abfd);
 301   global_found = false;
 302   lang_for_each_input_file (gldelf32ebmip_stat_needed);
 303   if (global_found)
 304     {
 305       /* Return true to indicate that we found the file, even though
 306          we aren't going to do anything with it.  */
 307       return true;
 308     }
 309
 310   /* Tell the ELF backend that don't want the output file to have a
 311      DT_NEEDED entry for this file.  */
 312   bfd_elf_set_dt_needed_name (abfd, "");
 313
 314   /* Add this file into the symbol table.  */
 315   if (! bfd_link_add_symbols (abfd, &link_info))
 316     einfo (_("%F%B: could not read symbols: %E\n"), abfd);
 317
 318   return true;
 319 }
 320
 321 /* See if an input file matches a DT_NEEDED entry by name.  */
 322
 323 static void
 324 gldelf32ebmip_check_needed (s)
 325      lang_input_statement_type *s;
 326 {
 327   if (global_found)
 328     return;
 329
 330   if (s->filename != NULL
 331       && strcmp (s->filename, global_needed->name) == 0)
 332     {
 333       global_found = true;
 334       return;
 335     }
 336
 337   if (s->the_bfd != NULL)
 338     {
 339       const char *soname;
 340
 341       soname = bfd_elf_get_dt_soname (s->the_bfd);
 342       if (soname != NULL
 343           && strcmp (soname, global_needed->name) == 0)
 344         {
 345           global_found = true;
 346           return;
 347         }
 348     }
 349
 350   if (s->search_dirs_flag
 351       && s->filename != NULL
 352       && strchr (global_needed->name, '/') == NULL)
 353     {
 354       const char *f;
 355
 356       f = strrchr (s->filename, '/');
 357       if (f != NULL
 358           && strcmp (f + 1, global_needed->name) == 0)
 359         {
 360           global_found = true;
 361           return;
 362         }
 363     }
 364 }
 365
 366 /* See if an input file matches a DT_NEEDED entry by running stat on
 367    the file.  */
 368
 369 static void
 370 gldelf32ebmip_stat_needed (s)
 371      lang_input_statement_type *s;
 372 {
 373   struct stat st;
 374   const char *suffix;
 375   const char *soname;
 376   const char *f;
 377
 378   if (global_found)
 379     return;
 380   if (s->the_bfd == NULL)
 381     return;
 382
 383   if (bfd_stat (s->the_bfd, &st) != 0)
 384     {
 385       einfo (_("%P:%B: bfd_stat failed: %E\n"), s->the_bfd);
 386       return;
 387     }
 388
 389   if (st.st_dev == global_stat.st_dev
 390       && st.st_ino == global_stat.st_ino)
 391     {
 392       global_found = true;
 393       return;
 394     }
 395
 396   /* We issue a warning if it looks like we are including two
 397      different versions of the same shared library.  For example,
 398      there may be a problem if -lc picks up libc.so.6 but some other
 399      shared library has a DT_NEEDED entry of libc.so.5.  This is a
 400      hueristic test, and it will only work if the name looks like
 401      NAME.so.VERSION.  FIXME: Depending on file names is error-prone.
 402      If we really want to issue warnings about mixing version numbers
 403      of shared libraries, we need to find a better way.  */
 404
 405   if (strchr (global_needed->name, '/') != NULL)
 406     return;
 407   suffix = strstr (global_needed->name, ".so.");
 408   if (suffix == NULL)
 409     return;
 410   suffix += sizeof ".so." - 1;
 411
 412   soname = bfd_elf_get_dt_soname (s->the_bfd);
 413   if (soname == NULL)
 414     soname = s->filename;
 415
 416   f = strrchr (soname, '/');
 417   if (f != NULL)
 418     ++f;
 419   else
 420     f = soname;
 421
 422   if (strncmp (f, global_needed->name, suffix - global_needed->name) == 0)
 423     einfo (_("%P: warning: %s, needed by %B, may conflict with %s\n"),
 424            global_needed->name, global_needed->by, f);
 425 }
 426
 427 /* This is called after the sections have been attached to output
 428    sections, but before any sizes or addresses have been set.  */
 429
 430 static void
 431 gldelf32ebmip_before_allocation ()
 432 {
 433   const char *rpath;
 434   asection *sinterp;
 435
 436   /* If we are going to make any variable assignments, we need to let
 437      the ELF backend know about them in case the variables are
 438      referred to by dynamic objects.  */
 439   lang_for_each_statement (gldelf32ebmip_find_statement_assignment);
 440
 441   /* Let the ELF backend work out the sizes of any sections required
 442      by dynamic linking.  */
 443   rpath = command_line.rpath;
 444   if (rpath == NULL)
 445     rpath = (const char *) getenv ("LD_RUN_PATH");
 446   if (! (bfd_elf32_size_dynamic_sections
 447          (output_bfd, command_line.soname, rpath,
 448           command_line.export_dynamic, command_line.filter_shlib,
 449           (const char * const *) command_line.auxiliary_filters,
 450           &link_info, &sinterp, lang_elf_version_info)))
 451     einfo (_("%P%F: failed to set dynamic section sizes: %E\n"));
 452
 453   /* Let the user override the dynamic linker we are using.  */
 454   if (command_line.interpreter != NULL
 455       && sinterp != NULL)
 456     {
 457       sinterp->contents = (bfd_byte *) command_line.interpreter;
 458       sinterp->_raw_size = strlen (command_line.interpreter) + 1;
 459     }
 460
 461   /* Look for any sections named .gnu.warning.  As a GNU extensions,
 462      we treat such sections as containing warning messages.  We print
 463      out the warning message, and then zero out the section size so
 464      that it does not get copied into the output file.  */
 465
 466   {
 467     LANG_FOR_EACH_INPUT_STATEMENT (is)
 468       {
 469         asection *s;
 470         bfd_size_type sz;
 471         char *msg;
 472         boolean ret;
 473
 474         if (is->just_syms_flag)
 475           continue;
 476
 477         s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
 478         if (s == NULL)
 479           continue;
 480
 481         sz = bfd_section_size (is->the_bfd, s);
 482         msg = xmalloc ((size_t) sz + 1);
 483         if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
 484           einfo (_("%F%B: Can't read contents of section .gnu.warning: %E\n"),
 485                  is->the_bfd);
 486         msg[sz] = '\0';
 487         ret = link_info.callbacks->warning (&link_info, msg,
 488                                             (const char *) NULL,
 489                                             is->the_bfd, (asection *) NULL,
 490                                             (bfd_vma) 0);
 491         ASSERT (ret);
 492         free (msg);
 493
 494         /* Clobber the section size, so that we don't waste copying the
 495            warning into the output file.  */
 496         s->_raw_size = 0;
 497       }
 498   }
 499 }
 500
 501 /* This is called by the before_allocation routine via
 502    lang_for_each_statement.  It locates any assignment statements, and
 503    tells the ELF backend about them, in case they are assignments to
 504    symbols which are referred to by dynamic objects.  */
 505
 506 static void
 507 gldelf32ebmip_find_statement_assignment (s)
 508      lang_statement_union_type *s;
 509 {
 510   if (s->header.type == lang_assignment_statement_enum)
 511     gldelf32ebmip_find_exp_assignment (s->assignment_statement.exp);
 512 }
 513
 514 /* Look through an expression for an assignment statement.  */
 515
 516 static void
 517 gldelf32ebmip_find_exp_assignment (exp)
 518      etree_type *exp;
 519 {
 520   struct bfd_link_hash_entry *h;
 521
 522   switch (exp->type.node_class)
 523     {
 524     case etree_provide:
 525       h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
 526                                 false, false, false);
 527       if (h == NULL)
 528         break;
 529
 530       /* We call record_link_assignment even if the symbol is defined.
 531          This is because if it is defined by a dynamic object, we
 532          actually want to use the value defined by the linker script,
 533          not the value from the dynamic object (because we are setting
 534          symbols like etext).  If the symbol is defined by a regular
 535          object, then, as it happens, calling record_link_assignment
 536          will do no harm.  */
 537
 538       /* Fall through.  */
 539     case etree_assign:
 540       if (strcmp (exp->assign.dst, ".") != 0)
 541         {
 542           if (! (bfd_elf32_record_link_assignment
 543                  (output_bfd, &link_info, exp->assign.dst,
 544                   exp->type.node_class == etree_provide ? true : false)))
 545             einfo (_("%P%F: failed to record assignment to %s: %E\n"),
 546                    exp->assign.dst);
 547         }
 548       gldelf32ebmip_find_exp_assignment (exp->assign.src);
 549       break;
 550
 551     case etree_binary:
 552       gldelf32ebmip_find_exp_assignment (exp->binary.lhs);
 553       gldelf32ebmip_find_exp_assignment (exp->binary.rhs);
 554       break;
 555
 556     case etree_trinary:
 557       gldelf32ebmip_find_exp_assignment (exp->trinary.cond);
 558       gldelf32ebmip_find_exp_assignment (exp->trinary.lhs);
 559       gldelf32ebmip_find_exp_assignment (exp->trinary.rhs);
 560       break;
 561
 562     case etree_unary:
 563       gldelf32ebmip_find_exp_assignment (exp->unary.child);
 564       break;
 565
 566     default:
 567       break;
 568     }
 569 }
 570
 571 /* Place an orphan section.  We use this to put random SHF_ALLOC
 572    sections in the right segment.  */
 573
 574 static asection *hold_section;
 575 static lang_output_section_statement_type *hold_use;
 576 static lang_output_section_statement_type *hold_text;
 577 static lang_output_section_statement_type *hold_rodata;
 578 static lang_output_section_statement_type *hold_data;
 579 static lang_output_section_statement_type *hold_bss;
 580 static lang_output_section_statement_type *hold_rel;
 581
 582 /*ARGSUSED*/
 583 static boolean
 584 gldelf32ebmip_place_orphan (file, s)
 585      lang_input_statement_type *file;
 586      asection *s;
 587 {
 588   lang_output_section_statement_type *place;
 589   asection *snew, **pps;
 590   lang_statement_list_type *old;
 591   lang_statement_list_type add;
 592   etree_type *address;
 593   const char *secname, *ps;
 594   lang_output_section_statement_type *os;
 595
 596   if ((s->flags & SEC_ALLOC) == 0)
 597     return false;
 598
 599   /* Look through the script to see where to place this section.  */
 600   hold_section = s;
 601   hold_use = NULL;
 602   lang_for_each_statement (gldelf32ebmip_place_section);
 603
 604   if (hold_use != NULL)
 605     {
 606       /* We have already placed a section with this name.  */
 607       wild_doit (&hold_use->children, s, hold_use, file);
 608       return true;
 609     }
 610
 611   secname = bfd_get_section_name (s->owner, s);
 612
 613   /* If this is a final link, then always put .gnu.warning.SYMBOL
 614      sections into the .text section to get them out of the way.  */
 615   if (! link_info.shared
 616       && ! link_info.relocateable
 617       && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
 618       && hold_text != NULL)
 619     {
 620       wild_doit (&hold_text->children, s, hold_text, file);
 621       return true;
 622     }
 623
 624   /* Decide which segment the section should go in based on the
 625      section name and section flags.  */
 626   place = NULL;
 627   if ((s->flags & SEC_HAS_CONTENTS) == 0
 628       && hold_bss != NULL)
 629     place = hold_bss;
 630   else if ((s->flags & SEC_READONLY) == 0
 631            && hold_data != NULL)
 632     place = hold_data;
 633   else if (strncmp (secname, ".rel", 4) == 0
 634            && hold_rel != NULL)
 635     place = hold_rel;
 636   else if ((s->flags & SEC_CODE) == 0
 637            && (s->flags & SEC_READONLY) != 0
 638            && hold_rodata != NULL)
 639     place = hold_rodata;
 640   else if ((s->flags & SEC_READONLY) != 0
 641            && hold_text != NULL)
 642     place = hold_text;
 643   if (place == NULL)
 644     return false;
 645
 646   /* Create the section in the output file, and put it in the right
 647      place.  This shuffling is to make the output file look neater.  */
 648   snew = bfd_make_section (output_bfd, secname);
 649   if (snew == NULL)
 650       einfo (_("%P%F: output format %s cannot represent section called %s\n"),
 651              output_bfd->xvec->name, secname);
 652   if (place->bfd_section != NULL)
 653     {
 654       for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
 655         ;
 656       *pps = snew->next;
 657       snew->next = place->bfd_section->next;
 658       place->bfd_section->next = snew;
 659     }
 660
 661   /* Start building a list of statements for this section.  */
 662   old = stat_ptr;
 663   stat_ptr = &add;
 664   lang_list_init (stat_ptr);
 665
 666   /* If the name of the section is representable in C, then create
 667      symbols to mark the start and the end of the section.  */
 668   for (ps = secname; *ps != '\0'; ps++)
 669     if (! isalnum (*ps) && *ps != '_')
 670       break;
 671   if (*ps == '\0' && config.build_constructors)
 672     {
 673       char *symname;
 674
 675       symname = (char *) xmalloc (ps - secname + sizeof "__start_");
 676       sprintf (symname, "__start_%s", secname);
 677       lang_add_assignment (exp_assop ('=', symname,
 678                                       exp_unop (ALIGN_K,
 679                                                 exp_intop ((bfd_vma) 1
 680                                                            << s->alignment_power))));
 681     }
 682
 683   if (! link_info.relocateable)
 684     address = NULL;
 685   else
 686     address = exp_intop ((bfd_vma) 0);
 687
 688   lang_enter_output_section_statement (secname, address, 0,
 689                                        (bfd_vma) 0,
 690                                        (etree_type *) NULL,
 691                                        (etree_type *) NULL,
 692                                        (etree_type *) NULL);
 693
 694   os = lang_output_section_statement_lookup (secname);
 695   wild_doit (&os->children, s, os, file);
 696
 697   lang_leave_output_section_statement
 698     ((bfd_vma) 0, "*default*",
 699      (struct lang_output_section_phdr_list *) NULL, "*default*");
 700   stat_ptr = &add;
 701
 702   if (*ps == '\0' && config.build_constructors)
 703     {
 704       char *symname;
 705
 706       symname = (char *) xmalloc (ps - secname + sizeof "__stop_");
 707       sprintf (symname, "__stop_%s", secname);
 708       lang_add_assignment (exp_assop ('=', symname,
 709                                       exp_nameop (NAME, ".")));
 710     }
 711
 712   /* Now stick the new statement list right after PLACE.  */
 713   *add.tail = place->header.next;
 714   place->header.next = add.head;
 715
 716   stat_ptr = old;
 717
 718   return true;
 719 }
 720
 721 static void
 722 gldelf32ebmip_place_section (s)
 723      lang_statement_union_type *s;
 724 {
 725   lang_output_section_statement_type *os;
 726
 727   if (s->header.type != lang_output_section_statement_enum)
 728     return;
 729
 730   os = &s->output_section_statement;
 731
 732   if (strcmp (os->name, hold_section->name) == 0)
 733     hold_use = os;
 734
 735   if (strcmp (os->name, ".text") == 0)
 736     hold_text = os;
 737   else if (strcmp (os->name, ".rodata") == 0)
 738     hold_rodata = os;
 739   else if (strcmp (os->name, ".data") == 0)
 740     hold_data = os;
 741   else if (strcmp (os->name, ".bss") == 0)
 742     hold_bss = os;
 743   else if (hold_rel == NULL
 744            && os->bfd_section != NULL
 745            && strncmp (os->name, ".rel", 4) == 0)
 746     hold_rel = os;
 747 }
 748
 749 static char *
 750 gldelf32ebmip_get_script(isfile)
 751      int *isfile;
 752 {
 753   *isfile = 0;
 754
 755   if (link_info.relocateable == true && config.build_constructors == true)
 756     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
 757               \"elf32-littlemips\")\n\
 758 OUTPUT_ARCH(mips)\n\
 759 ENTRY(_start)\n\
 760  /* For some reason, the Solaris linker makes bad executables\n\
 761   if gld -r is used and the intermediate file has sections starting\n\
 762   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld\n\
 763   bug.  But for now assigning the zero vmas works.  */\n\
 764 SECTIONS\n\
 765 {\n\
 766   /* Read-only sections, merged into text segment: */\n\
 767   .interp   0 : { *(.interp)    }\n\
 768   .reginfo     0 : { *(.reginfo) }\n\
 769   .dynamic     0 : { *(.dynamic) }\n\
 770   .dynstr      0 : { *(.dynstr)         }\n\
 771   .dynsym      0 : { *(.dynsym)         }\n\
 772   .hash        0 : { *(.hash)           }\n\
 773   .rel.text    0 : { *(.rel.text)               }\n\
 774   .rela.text   0 : { *(.rela.text)      }\n\
 775   .rel.data    0 : { *(.rel.data)               }\n\
 776   .rela.data   0 : { *(.rela.data)      }\n\
 777   .rel.rodata  0 : { *(.rel.rodata)     }\n\
 778   .rela.rodata 0 : { *(.rela.rodata)    }\n\
 779   .rel.got     0 : { *(.rel.got)                }\n\
 780   .rela.got    0 : { *(.rela.got)               }\n\
 781   .rel.ctors   0 : { *(.rel.ctors)      }\n\
 782   .rela.ctors  0 : { *(.rela.ctors)     }\n\
 783   .rel.dtors   0 : { *(.rel.dtors)      }\n\
 784   .rela.dtors  0 : { *(.rela.dtors)     }\n\
 785   .rel.init    0 : { *(.rel.init)       }\n\
 786   .rela.init   0 : { *(.rela.init)      }\n\
 787   .rel.fini    0 : { *(.rel.fini)       }\n\
 788   .rela.fini   0 : { *(.rela.fini)      }\n\
 789   .rel.bss     0 : { *(.rel.bss)                }\n\
 790   .rela.bss    0 : { *(.rela.bss)               }\n\
 791   .rel.plt     0 : { *(.rel.plt)                }\n\
 792   .rela.plt    0 : { *(.rela.plt)               }\n\
 793   .rodata  0 : { *(.rodata)  }\n\
 794   .rodata1 0 : { *(.rodata1) }\n\
 795   .init        0 : { *(.init)   } =0\n\
 796   .text    0 :\n\
 797   {\n\
 798     *(.text)\n\
 799     *(.stub)\n\
 800     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
 801     *(.gnu.warning)\n\
 802   } =0\n\
 803   .fini    0 : { *(.fini)    } =0\n\
 804   /* Adjust the address for the data segment.  We want to adjust up to\n\
 805      the same address within the page on the next page up.  It would\n\
 806      be more correct to do this:\n\
 807      The current expression does not correctly handle the case of a\n\
 808      text segment ending precisely at the end of a page; it causes the\n\
 809      data segment to skip a page.  The above expression does not have\n\
 810      this problem, but it will currently (2/95) cause BFD to allocate\n\
 811      a single segment, combining both text and data, for this case.\n\
 812      This will prevent the text segment from being shared among\n\
 813      multiple executions of the program; I think that is more\n\
 814      important than losing a page of the virtual address space (note\n\
 815      that no actual memory is lost; the page which is skipped can not\n\
 816      be referenced).  */\n\
 817   .data  0 :\n\
 818   {\n\
 819     *(.data)\n\
 820     CONSTRUCTORS\n\
 821   }\n\
 822   .data1 0 : { *(.data1) }\n\
 823   .ctors       0 : { *(.ctors)   }\n\
 824   .dtors       0 : { *(.dtors)   }\n\
 825   .got         0 :\n\
 826   {\n\
 827     *(.got.plt) *(.got)\n\
 828    }\n\
 829   /* We want the small data sections together, so single-instruction offsets\n\
 830      can access them all, and initialized data all before uninitialized, so\n\
 831      we can shorten the on-disk segment size.  */\n\
 832   .sdata   0 : { *(.sdata) }\n\
 833   .sbss    0 : { *(.sbss) *(.scommon) }\n\
 834   .bss     0 :\n\
 835   {\n\
 836    *(.dynbss)\n\
 837    *(.bss)\n\
 838    *(COMMON)\n\
 839   }\n\
 840   /* These are needed for ELF backends which have not yet been\n\
 841      converted to the new style linker.  */\n\
 842   .stab 0 : { *(.stab) }\n\
 843   .stabstr 0 : { *(.stabstr) }\n\
 844   /* DWARF debug sections.\n\
 845      Symbols in the .debug DWARF section are relative to the beginning of the\n\
 846      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
 847      for the others.   */\n\
 848   .debug          0 : { *(.debug) }\n\
 849   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
 850   .debug_aranges  0 : { *(.debug_aranges) }\n\
 851   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
 852   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
 853   .line           0 : { *(.line) }\n\
 854   /* These must appear regardless of .  */\n\
 855   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
 856   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
 857 }\n\n";
 858   else if (link_info.relocateable == true)
 859     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
 860               \"elf32-littlemips\")\n\
 861 OUTPUT_ARCH(mips)\n\
 862 ENTRY(_start)\n\
 863  /* For some reason, the Solaris linker makes bad executables\n\
 864   if gld -r is used and the intermediate file has sections starting\n\
 865   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld\n\
 866   bug.  But for now assigning the zero vmas works.  */\n\
 867 SECTIONS\n\
 868 {\n\
 869   /* Read-only sections, merged into text segment: */\n\
 870   .interp   0 : { *(.interp)    }\n\
 871   .reginfo     0 : { *(.reginfo) }\n\
 872   .dynamic     0 : { *(.dynamic) }\n\
 873   .dynstr      0 : { *(.dynstr)         }\n\
 874   .dynsym      0 : { *(.dynsym)         }\n\
 875   .hash        0 : { *(.hash)           }\n\
 876   .rel.text    0 : { *(.rel.text)               }\n\
 877   .rela.text   0 : { *(.rela.text)      }\n\
 878   .rel.data    0 : { *(.rel.data)               }\n\
 879   .rela.data   0 : { *(.rela.data)      }\n\
 880   .rel.rodata  0 : { *(.rel.rodata)     }\n\
 881   .rela.rodata 0 : { *(.rela.rodata)    }\n\
 882   .rel.got     0 : { *(.rel.got)                }\n\
 883   .rela.got    0 : { *(.rela.got)               }\n\
 884   .rel.ctors   0 : { *(.rel.ctors)      }\n\
 885   .rela.ctors  0 : { *(.rela.ctors)     }\n\
 886   .rel.dtors   0 : { *(.rel.dtors)      }\n\
 887   .rela.dtors  0 : { *(.rela.dtors)     }\n\
 888   .rel.init    0 : { *(.rel.init)       }\n\
 889   .rela.init   0 : { *(.rela.init)      }\n\
 890   .rel.fini    0 : { *(.rel.fini)       }\n\
 891   .rela.fini   0 : { *(.rela.fini)      }\n\
 892   .rel.bss     0 : { *(.rel.bss)                }\n\
 893   .rela.bss    0 : { *(.rela.bss)               }\n\
 894   .rel.plt     0 : { *(.rel.plt)                }\n\
 895   .rela.plt    0 : { *(.rela.plt)               }\n\
 896   .rodata  0 : { *(.rodata)  }\n\
 897   .rodata1 0 : { *(.rodata1) }\n\
 898   .init        0 : { *(.init)   } =0\n\
 899   .text    0 :\n\
 900   {\n\
 901     *(.text)\n\
 902     *(.stub)\n\
 903     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
 904     *(.gnu.warning)\n\
 905   } =0\n\
 906   .fini    0 : { *(.fini)    } =0\n\
 907   /* Adjust the address for the data segment.  We want to adjust up to\n\
 908      the same address within the page on the next page up.  It would\n\
 909      be more correct to do this:\n\
 910      The current expression does not correctly handle the case of a\n\
 911      text segment ending precisely at the end of a page; it causes the\n\
 912      data segment to skip a page.  The above expression does not have\n\
 913      this problem, but it will currently (2/95) cause BFD to allocate\n\
 914      a single segment, combining both text and data, for this case.\n\
 915      This will prevent the text segment from being shared among\n\
 916      multiple executions of the program; I think that is more\n\
 917      important than losing a page of the virtual address space (note\n\
 918      that no actual memory is lost; the page which is skipped can not\n\
 919      be referenced).  */\n\
 920   .data  0 :\n\
 921   {\n\
 922     *(.data)\n\
 923   }\n\
 924   .data1 0 : { *(.data1) }\n\
 925   .ctors       0 : { *(.ctors)   }\n\
 926   .dtors       0 : { *(.dtors)   }\n\
 927   .got         0 :\n\
 928   {\n\
 929     *(.got.plt) *(.got)\n\
 930    }\n\
 931   /* We want the small data sections together, so single-instruction offsets\n\
 932      can access them all, and initialized data all before uninitialized, so\n\
 933      we can shorten the on-disk segment size.  */\n\
 934   .sdata   0 : { *(.sdata) }\n\
 935   .sbss    0 : { *(.sbss) *(.scommon) }\n\
 936   .bss     0 :\n\
 937   {\n\
 938    *(.dynbss)\n\
 939    *(.bss)\n\
 940    *(COMMON)\n\
 941   }\n\
 942   /* These are needed for ELF backends which have not yet been\n\
 943      converted to the new style linker.  */\n\
 944   .stab 0 : { *(.stab) }\n\
 945   .stabstr 0 : { *(.stabstr) }\n\
 946   /* DWARF debug sections.\n\
 947      Symbols in the .debug DWARF section are relative to the beginning of the\n\
 948      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
 949      for the others.   */\n\
 950   .debug          0 : { *(.debug) }\n\
 951   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
 952   .debug_aranges  0 : { *(.debug_aranges) }\n\
 953   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
 954   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
 955   .line           0 : { *(.line) }\n\
 956   /* These must appear regardless of .  */\n\
 957   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
 958   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
 959 }\n\n";
 960   else if (!config.text_read_only)
 961     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
 962               \"elf32-littlemips\")\n\
 963 OUTPUT_ARCH(mips)\n\
 964 ENTRY(_start)\n\
 965  SEARCH_DIR(/usr/local/mips-elf/lib);\n\
 966 /* Do we need any of these for elf?\n\
 967    __DYNAMIC = 0;    */\n\
 968 SECTIONS\n\
 969 {\n\
 970   /* Read-only sections, merged into text segment: */\n\
 971   . = 0x0400000;\n\
 972   .interp     : { *(.interp)    }\n\
 973   .reginfo       : { *(.reginfo) }\n\
 974   .dynamic       : { *(.dynamic) }\n\
 975   .dynstr        : { *(.dynstr)         }\n\
 976   .dynsym        : { *(.dynsym)         }\n\
 977   .hash          : { *(.hash)           }\n\
 978   .rel.text      : { *(.rel.text)               }\n\
 979   .rela.text     : { *(.rela.text)      }\n\
 980   .rel.data      : { *(.rel.data)               }\n\
 981   .rela.data     : { *(.rela.data)      }\n\
 982   .rel.rodata    : { *(.rel.rodata)     }\n\
 983   .rela.rodata   : { *(.rela.rodata)    }\n\
 984   .rel.got       : { *(.rel.got)                }\n\
 985   .rela.got      : { *(.rela.got)               }\n\
 986   .rel.ctors     : { *(.rel.ctors)      }\n\
 987   .rela.ctors    : { *(.rela.ctors)     }\n\
 988   .rel.dtors     : { *(.rel.dtors)      }\n\
 989   .rela.dtors    : { *(.rela.dtors)     }\n\
 990   .rel.init      : { *(.rel.init)       }\n\
 991   .rela.init     : { *(.rela.init)      }\n\
 992   .rel.fini      : { *(.rel.fini)       }\n\
 993   .rela.fini     : { *(.rela.fini)      }\n\
 994   .rel.bss       : { *(.rel.bss)                }\n\
 995   .rela.bss      : { *(.rela.bss)               }\n\
 996   .rel.plt       : { *(.rel.plt)                }\n\
 997   .rela.plt      : { *(.rela.plt)               }\n\
 998   .rodata    : { *(.rodata)  }\n\
 999   .rodata1   : { *(.rodata1) }\n\
1000   .init          : { *(.init)   } =0\n\
1001   .text      :\n\
1002   {\n\
1003     _ftext = . ;\n\
1004     *(.text)\n\
1005     *(.stub)\n\
1006     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
1007     *(.gnu.warning)\n\
1008   } =0\n\
1009   _etext = .;\n\
1010   PROVIDE (etext = .);\n\
1011   .fini      : { *(.fini)    } =0\n\
1012   /* Adjust the address for the data segment.  We want to adjust up to\n\
1013      the same address within the page on the next page up.  It would\n\
1014      be more correct to do this:\n\
1015        . = .;\n\
1016      The current expression does not correctly handle the case of a\n\
1017      text segment ending precisely at the end of a page; it causes the\n\
1018      data segment to skip a page.  The above expression does not have\n\
1019      this problem, but it will currently (2/95) cause BFD to allocate\n\
1020      a single segment, combining both text and data, for this case.\n\
1021      This will prevent the text segment from being shared among\n\
1022      multiple executions of the program; I think that is more\n\
1023      important than losing a page of the virtual address space (note\n\
1024      that no actual memory is lost; the page which is skipped can not\n\
1025      be referenced).  */\n\
1026   . += . - 0x0400000;\n\
1027   .data    :\n\
1028   {\n\
1029     _fdata = . ;\n\
1030     *(.data)\n\
1031     CONSTRUCTORS\n\
1032   }\n\
1033   .data1   : { *(.data1) }\n\
1034   .ctors         : { *(.ctors)   }\n\
1035   .dtors         : { *(.dtors)   }\n\
1036   _gp = ALIGN(16) + 0x7ff0;\n\
1037   .got           :\n\
1038   {\n\
1039     *(.got.plt) *(.got)\n\
1040    }\n\
1041   /* We want the small data sections together, so single-instruction offsets\n\
1042      can access them all, and initialized data all before uninitialized, so\n\
1043      we can shorten the on-disk segment size.  */\n\
1044   .sdata     : { *(.sdata) }\n\
1045   .lit8 : { *(.lit8) }\n\
1046   .lit4 : { *(.lit4) }\n\
1047   _edata  =  .;\n\
1048   PROVIDE (edata = .);\n\
1049   __bss_start = .;\n\
1050   _fbss = .;\n\
1051   .sbss      : { *(.sbss) *(.scommon) }\n\
1052   .bss       :\n\
1053   {\n\
1054    *(.dynbss)\n\
1055    *(.bss)\n\
1056    *(COMMON)\n\
1057   }\n\
1058   _end = . ;\n\
1059   PROVIDE (end = .);\n\
1060   /* These are needed for ELF backends which have not yet been\n\
1061      converted to the new style linker.  */\n\
1062   .stab 0 : { *(.stab) }\n\
1063   .stabstr 0 : { *(.stabstr) }\n\
1064   /* DWARF debug sections.\n\
1065      Symbols in the .debug DWARF section are relative to the beginning of the\n\
1066      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
1067      for the others.   */\n\
1068   .debug          0 : { *(.debug) }\n\
1069   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
1070   .debug_aranges  0 : { *(.debug_aranges) }\n\
1071   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
1072   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
1073   .line           0 : { *(.line) }\n\
1074   /* These must appear regardless of  .  */\n\
1075   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
1076   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
1077 }\n\n";
1078   else if (!config.magic_demand_paged)
1079     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
1080               \"elf32-littlemips\")\n\
1081 OUTPUT_ARCH(mips)\n\
1082 ENTRY(_start)\n\
1083  SEARCH_DIR(/usr/local/mips-elf/lib);\n\
1084 /* Do we need any of these for elf?\n\
1085    __DYNAMIC = 0;    */\n\
1086 SECTIONS\n\
1087 {\n\
1088   /* Read-only sections, merged into text segment: */\n\
1089   . = 0x0400000;\n\
1090   .interp     : { *(.interp)    }\n\
1091   .reginfo       : { *(.reginfo) }\n\
1092   .dynamic       : { *(.dynamic) }\n\
1093   .dynstr        : { *(.dynstr)         }\n\
1094   .dynsym        : { *(.dynsym)         }\n\
1095   .hash          : { *(.hash)           }\n\
1096   .rel.text      : { *(.rel.text)               }\n\
1097   .rela.text     : { *(.rela.text)      }\n\
1098   .rel.data      : { *(.rel.data)               }\n\
1099   .rela.data     : { *(.rela.data)      }\n\
1100   .rel.rodata    : { *(.rel.rodata)     }\n\
1101   .rela.rodata   : { *(.rela.rodata)    }\n\
1102   .rel.got       : { *(.rel.got)                }\n\
1103   .rela.got      : { *(.rela.got)               }\n\
1104   .rel.ctors     : { *(.rel.ctors)      }\n\
1105   .rela.ctors    : { *(.rela.ctors)     }\n\
1106   .rel.dtors     : { *(.rel.dtors)      }\n\
1107   .rela.dtors    : { *(.rela.dtors)     }\n\
1108   .rel.init      : { *(.rel.init)       }\n\
1109   .rela.init     : { *(.rela.init)      }\n\
1110   .rel.fini      : { *(.rel.fini)       }\n\
1111   .rela.fini     : { *(.rela.fini)      }\n\
1112   .rel.bss       : { *(.rel.bss)                }\n\
1113   .rela.bss      : { *(.rela.bss)               }\n\
1114   .rel.plt       : { *(.rel.plt)                }\n\
1115   .rela.plt      : { *(.rela.plt)               }\n\
1116   .rodata    : { *(.rodata)  }\n\
1117   .rodata1   : { *(.rodata1) }\n\
1118   .init          : { *(.init)   } =0\n\
1119   .text      :\n\
1120   {\n\
1121     _ftext = . ;\n\
1122     *(.text)\n\
1123     *(.stub)\n\
1124     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
1125     *(.gnu.warning)\n\
1126   } =0\n\
1127   _etext = .;\n\
1128   PROVIDE (etext = .);\n\
1129   .fini      : { *(.fini)    } =0\n\
1130   /* Adjust the address for the data segment.  We want to adjust up to\n\
1131      the same address within the page on the next page up.  It would\n\
1132      be more correct to do this:\n\
1133        . = 0x10000000;\n\
1134      The current expression does not correctly handle the case of a\n\
1135      text segment ending precisely at the end of a page; it causes the\n\
1136      data segment to skip a page.  The above expression does not have\n\
1137      this problem, but it will currently (2/95) cause BFD to allocate\n\
1138      a single segment, combining both text and data, for this case.\n\
1139      This will prevent the text segment from being shared among\n\
1140      multiple executions of the program; I think that is more\n\
1141      important than losing a page of the virtual address space (note\n\
1142      that no actual memory is lost; the page which is skipped can not\n\
1143      be referenced).  */\n\
1144   . += 0x10000000 - 0x0400000;\n\
1145   .data    :\n\
1146   {\n\
1147     _fdata = . ;\n\
1148     *(.data)\n\
1149     CONSTRUCTORS\n\
1150   }\n\
1151   .data1   : { *(.data1) }\n\
1152   .ctors         : { *(.ctors)   }\n\
1153   .dtors         : { *(.dtors)   }\n\
1154   _gp = ALIGN(16) + 0x7ff0;\n\
1155   .got           :\n\
1156   {\n\
1157     *(.got.plt) *(.got)\n\
1158    }\n\
1159   /* We want the small data sections together, so single-instruction offsets\n\
1160      can access them all, and initialized data all before uninitialized, so\n\
1161      we can shorten the on-disk segment size.  */\n\
1162   .sdata     : { *(.sdata) }\n\
1163   .lit8 : { *(.lit8) }\n\
1164   .lit4 : { *(.lit4) }\n\
1165   _edata  =  .;\n\
1166   PROVIDE (edata = .);\n\
1167   __bss_start = .;\n\
1168   _fbss = .;\n\
1169   .sbss      : { *(.sbss) *(.scommon) }\n\
1170   .bss       :\n\
1171   {\n\
1172    *(.dynbss)\n\
1173    *(.bss)\n\
1174    *(COMMON)\n\
1175   }\n\
1176   _end = . ;\n\
1177   PROVIDE (end = .);\n\
1178   /* These are needed for ELF backends which have not yet been\n\
1179      converted to the new style linker.  */\n\
1180   .stab 0 : { *(.stab) }\n\
1181   .stabstr 0 : { *(.stabstr) }\n\
1182   /* DWARF debug sections.\n\
1183      Symbols in the .debug DWARF section are relative to the beginning of the\n\
1184      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
1185      for the others.   */\n\
1186   .debug          0 : { *(.debug) }\n\
1187   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
1188   .debug_aranges  0 : { *(.debug_aranges) }\n\
1189   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
1190   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
1191   .line           0 : { *(.line) }\n\
1192   /* These must appear regardless of  .  */\n\
1193   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
1194   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
1195 }\n\n";
1196   else if (link_info.shared)
1197     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
1198               \"elf32-littlemips\")\n\
1199 OUTPUT_ARCH(mips)\n\
1200 ENTRY(_start)\n\
1201  SEARCH_DIR(/usr/local/mips-elf/lib);\n\
1202 /* Do we need any of these for elf?\n\
1203    __DYNAMIC = 0;    */\n\
1204 SECTIONS\n\
1205 {\n\
1206   /* Read-only sections, merged into text segment: */\n\
1207   . = 0x5ffe0000 + SIZEOF_HEADERS;\n\
1208   .reginfo       : { *(.reginfo) }\n\
1209   .dynamic       : { *(.dynamic) }\n\
1210   .dynstr        : { *(.dynstr)         }\n\
1211   .dynsym        : { *(.dynsym)         }\n\
1212   .hash          : { *(.hash)           }\n\
1213   .rel.text      : { *(.rel.text)               }\n\
1214   .rela.text     : { *(.rela.text)      }\n\
1215   .rel.data      : { *(.rel.data)               }\n\
1216   .rela.data     : { *(.rela.data)      }\n\
1217   .rel.rodata    : { *(.rel.rodata)     }\n\
1218   .rela.rodata   : { *(.rela.rodata)    }\n\
1219   .rel.got       : { *(.rel.got)                }\n\
1220   .rela.got      : { *(.rela.got)               }\n\
1221   .rel.ctors     : { *(.rel.ctors)      }\n\
1222   .rela.ctors    : { *(.rela.ctors)     }\n\
1223   .rel.dtors     : { *(.rel.dtors)      }\n\
1224   .rela.dtors    : { *(.rela.dtors)     }\n\
1225   .rel.init      : { *(.rel.init)       }\n\
1226   .rela.init     : { *(.rela.init)      }\n\
1227   .rel.fini      : { *(.rel.fini)       }\n\
1228   .rela.fini     : { *(.rela.fini)      }\n\
1229   .rel.bss       : { *(.rel.bss)                }\n\
1230   .rela.bss      : { *(.rela.bss)               }\n\
1231   .rel.plt       : { *(.rel.plt)                }\n\
1232   .rela.plt      : { *(.rela.plt)               }\n\
1233   .rodata    : { *(.rodata)  }\n\
1234   .rodata1   : { *(.rodata1) }\n\
1235   .init          : { *(.init)   } =0\n\
1236   .text      :\n\
1237   {\n\
1238     *(.text)\n\
1239     *(.stub)\n\
1240     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
1241     *(.gnu.warning)\n\
1242   } =0\n\
1243   .fini      : { *(.fini)    } =0\n\
1244   /* Adjust the address for the data segment.  We want to adjust up to\n\
1245      the same address within the page on the next page up.  It would\n\
1246      be more correct to do this:\n\
1247        . = 0x10000000;\n\
1248      The current expression does not correctly handle the case of a\n\
1249      text segment ending precisely at the end of a page; it causes the\n\
1250      data segment to skip a page.  The above expression does not have\n\
1251      this problem, but it will currently (2/95) cause BFD to allocate\n\
1252      a single segment, combining both text and data, for this case.\n\
1253      This will prevent the text segment from being shared among\n\
1254      multiple executions of the program; I think that is more\n\
1255      important than losing a page of the virtual address space (note\n\
1256      that no actual memory is lost; the page which is skipped can not\n\
1257      be referenced).  */\n\
1258   . += 0x10000;\n\
1259   .data    :\n\
1260   {\n\
1261     *(.data)\n\
1262     CONSTRUCTORS\n\
1263   }\n\
1264   .data1   : { *(.data1) }\n\
1265   .ctors         : { *(.ctors)   }\n\
1266   .dtors         : { *(.dtors)   }\n\
1267   _gp = ALIGN(16) + 0x7ff0;\n\
1268   .got           :\n\
1269   {\n\
1270     *(.got.plt) *(.got)\n\
1271    }\n\
1272   /* We want the small data sections together, so single-instruction offsets\n\
1273      can access them all, and initialized data all before uninitialized, so\n\
1274      we can shorten the on-disk segment size.  */\n\
1275   .sdata     : { *(.sdata) }\n\
1276   .lit8 : { *(.lit8) }\n\
1277   .lit4 : { *(.lit4) }\n\
1278   .sbss      : { *(.sbss) *(.scommon) }\n\
1279   .bss       :\n\
1280   {\n\
1281    *(.dynbss)\n\
1282    *(.bss)\n\
1283    *(COMMON)\n\
1284   }\n\
1285   /* These are needed for ELF backends which have not yet been\n\
1286      converted to the new style linker.  */\n\
1287   .stab 0 : { *(.stab) }\n\
1288   .stabstr 0 : { *(.stabstr) }\n\
1289   /* DWARF debug sections.\n\
1290      Symbols in the .debug DWARF section are relative to the beginning of the\n\
1291      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
1292      for the others.   */\n\
1293   .debug          0 : { *(.debug) }\n\
1294   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
1295   .debug_aranges  0 : { *(.debug_aranges) }\n\
1296   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
1297   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
1298   .line           0 : { *(.line) }\n\
1299   /* These must appear regardless of  .  */\n\
1300   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
1301   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
1302 }\n\n";
1303   else
1304     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
1305               \"elf32-littlemips\")\n\
1306 OUTPUT_ARCH(mips)\n\
1307 ENTRY(_start)\n\
1308  SEARCH_DIR(/usr/local/mips-elf/lib);\n\
1309 /* Do we need any of these for elf?\n\
1310    __DYNAMIC = 0;    */\n\
1311 SECTIONS\n\
1312 {\n\
1313   /* Read-only sections, merged into text segment: */\n\
1314   . = 0x0400000;\n\
1315   .interp     : { *(.interp)    }\n\
1316   .reginfo       : { *(.reginfo) }\n\
1317   .dynamic       : { *(.dynamic) }\n\
1318   .dynstr        : { *(.dynstr)         }\n\
1319   .dynsym        : { *(.dynsym)         }\n\
1320   .hash          : { *(.hash)           }\n\
1321   .rel.text      : { *(.rel.text)               }\n\
1322   .rela.text     : { *(.rela.text)      }\n\
1323   .rel.data      : { *(.rel.data)               }\n\
1324   .rela.data     : { *(.rela.data)      }\n\
1325   .rel.rodata    : { *(.rel.rodata)     }\n\
1326   .rela.rodata   : { *(.rela.rodata)    }\n\
1327   .rel.got       : { *(.rel.got)                }\n\
1328   .rela.got      : { *(.rela.got)               }\n\
1329   .rel.ctors     : { *(.rel.ctors)      }\n\
1330   .rela.ctors    : { *(.rela.ctors)     }\n\
1331   .rel.dtors     : { *(.rel.dtors)      }\n\
1332   .rela.dtors    : { *(.rela.dtors)     }\n\
1333   .rel.init      : { *(.rel.init)       }\n\
1334   .rela.init     : { *(.rela.init)      }\n\
1335   .rel.fini      : { *(.rel.fini)       }\n\
1336   .rela.fini     : { *(.rela.fini)      }\n\
1337   .rel.bss       : { *(.rel.bss)                }\n\
1338   .rela.bss      : { *(.rela.bss)               }\n\
1339   .rel.plt       : { *(.rel.plt)                }\n\
1340   .rela.plt      : { *(.rela.plt)               }\n\
1341   .rodata    : { *(.rodata)  }\n\
1342   .rodata1   : { *(.rodata1) }\n\
1343   .init          : { *(.init)   } =0\n\
1344   .text      :\n\
1345   {\n\
1346     _ftext = . ;\n\
1347     *(.text)\n\
1348     *(.stub)\n\
1349     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
1350     *(.gnu.warning)\n\
1351   } =0\n\
1352   _etext = .;\n\
1353   PROVIDE (etext = .);\n\
1354   .fini      : { *(.fini)    } =0\n\
1355   /* Adjust the address for the data segment.  We want to adjust up to\n\
1356      the same address within the page on the next page up.  It would\n\
1357      be more correct to do this:\n\
1358        . = 0x10000000;\n\
1359      The current expression does not correctly handle the case of a\n\
1360      text segment ending precisely at the end of a page; it causes the\n\
1361      data segment to skip a page.  The above expression does not have\n\
1362      this problem, but it will currently (2/95) cause BFD to allocate\n\
1363      a single segment, combining both text and data, for this case.\n\
1364      This will prevent the text segment from being shared among\n\
1365      multiple executions of the program; I think that is more\n\
1366      important than losing a page of the virtual address space (note\n\
1367      that no actual memory is lost; the page which is skipped can not\n\
1368      be referenced).  */\n\
1369   . += 0x10000000 - 0x0400000;\n\
1370   .data    :\n\
1371   {\n\
1372     _fdata = . ;\n\
1373     *(.data)\n\
1374     CONSTRUCTORS\n\
1375   }\n\
1376   .data1   : { *(.data1) }\n\
1377   .ctors         : { *(.ctors)   }\n\
1378   .dtors         : { *(.dtors)   }\n\
1379   _gp = ALIGN(16) + 0x7ff0;\n\
1380   .got           :\n\
1381   {\n\
1382     *(.got.plt) *(.got)\n\
1383    }\n\
1384   /* We want the small data sections together, so single-instruction offsets\n\
1385      can access them all, and initialized data all before uninitialized, so\n\
1386      we can shorten the on-disk segment size.  */\n\
1387   .sdata     : { *(.sdata) }\n\
1388   .lit8 : { *(.lit8) }\n\
1389   .lit4 : { *(.lit4) }\n\
1390   _edata  =  .;\n\
1391   PROVIDE (edata = .);\n\
1392   __bss_start = .;\n\
1393   _fbss = .;\n\
1394   .sbss      : { *(.sbss) *(.scommon) }\n\
1395   .bss       :\n\
1396   {\n\
1397    *(.dynbss)\n\
1398    *(.bss)\n\
1399    *(COMMON)\n\
1400   }\n\
1401   _end = . ;\n\
1402   PROVIDE (end = .);\n\
1403   /* These are needed for ELF backends which have not yet been\n\
1404      converted to the new style linker.  */\n\
1405   .stab 0 : { *(.stab) }\n\
1406   .stabstr 0 : { *(.stabstr) }\n\
1407   /* DWARF debug sections.\n\
1408      Symbols in the .debug DWARF section are relative to the beginning of the\n\
1409      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
1410      for the others.   */\n\
1411   .debug          0 : { *(.debug) }\n\
1412   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
1413   .debug_aranges  0 : { *(.debug_aranges) }\n\
1414   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
1415   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
1416   .line           0 : { *(.line) }\n\
1417   /* These must appear regardless of  .  */\n\
1418   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
1419   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
1420 }\n\n";
1421 }
1422
1423 struct ld_emulation_xfer_struct ld_elf32ebmip_emulation =
1424 {
1425   gldelf32ebmip_before_parse,
1426   syslib_default,
1427   hll_default,
1428   after_parse_default,
1429   gldelf32ebmip_after_open,
1430   after_allocation_default,
1431   set_output_arch_default,
1432   ldemul_default_target,
1433   gldelf32ebmip_before_allocation,
1434   gldelf32ebmip_get_script,
1435   "elf32ebmip",
1436   "elf32-bigmips",
1437   NULL,
1438   NULL,
1439   gldelf32ebmip_open_dynamic_archive,
1440   gldelf32ebmip_place_orphan
1441 };