ld/emultempl/elf32.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 cat >e${EMULATION_NAME}.c <<EOF
   4 /* This file is is generated by a shell script.  DO NOT EDIT! */
   5
   6 /* 32 bit ELF emulation code for ${EMULATION_NAME}
   7    Copyright (C) 1991, 1993, 1994, 1995 Free Software Foundation, Inc.
   8    Written by Steve Chamberlain <sac@cygnus.com>
   9    ELF support by Ian Lance Taylor <ian@cygnus.com>
  10
  11 This file is part of GLD, the Gnu Linker.
  12
  13 This program is free software; you can redistribute it and/or modify
  14 it under the terms of the GNU General Public License as published by
  15 the Free Software Foundation; either version 2 of the License, or
  16 (at your option) any later version.
  17
  18 This program is distributed in the hope that it will be useful,
  19 but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 GNU General Public License for more details.
  22
  23 You should have received a copy of the GNU General Public License
  24 along with this program; if not, write to the Free Software
  25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  26
  27 #define TARGET_IS_${EMULATION_NAME}
  28
  29 #include "bfd.h"
  30 #include "sysdep.h"
  31
  32 #include <ctype.h>
  33
  34 #include "bfdlink.h"
  35
  36 #include "ld.h"
  37 #include "config.h"
  38 #include "ldmain.h"
  39 #include "ldemul.h"
  40 #include "ldfile.h"
  41 #include "ldmisc.h"
  42 #include "ldexp.h"
  43 #include "ldlang.h"
  44 #include "ldgram.h"
  45
  46 static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
  47 static boolean gld${EMULATION_NAME}_open_dynamic_archive
  48   PARAMS ((const char *, lang_input_statement_type *));
  49 static void gld${EMULATION_NAME}_after_open PARAMS ((void));
  50 static void gld${EMULATION_NAME}_check_needed
  51   PARAMS ((lang_input_statement_type *));
  52 static boolean gld${EMULATION_NAME}_search_needed
  53   PARAMS ((const char *, const char *));
  54 static boolean gld${EMULATION_NAME}_try_needed PARAMS ((const char *));
  55 static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
  56 static void gld${EMULATION_NAME}_find_statement_assignment
  57   PARAMS ((lang_statement_union_type *));
  58 static void gld${EMULATION_NAME}_find_exp_assignment PARAMS ((etree_type *));
  59 static boolean gld${EMULATION_NAME}_place_orphan
  60   PARAMS ((lang_input_statement_type *, asection *));
  61 static void gld${EMULATION_NAME}_place_section
  62   PARAMS ((lang_statement_union_type *));
  63 static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile));
  64
  65 static void
  66 gld${EMULATION_NAME}_before_parse()
  67 {
  68   ldfile_output_architecture = bfd_arch_${ARCH};
  69   config.dynamic_link = ${DYNAMIC_LINK-true};
  70 }
  71
  72 /* Try to open a dynamic archive.  This is where we know that ELF
  73    dynamic libraries have an extension of .so.  */
  74
  75 static boolean
  76 gld${EMULATION_NAME}_open_dynamic_archive (arch, entry)
  77      const char *arch;
  78      lang_input_statement_type *entry;
  79 {
  80   const char *filename;
  81
  82   filename = entry->filename;
  83
  84   if (! ldfile_open_file_search (arch, entry, "lib", ".so"))
  85     return false;
  86
  87   /* We have found a dynamic object to include in the link.  The ELF
  88      backend linker will create a DT_NEEDED entry in the .dynamic
  89      section naming this file.  If this file includes a DT_SONAME
  90      entry, it will be used.  Otherwise, the ELF linker will just use
  91      the name of the file.  For an archive found by searching, like
  92      this one, the DT_NEEDED entry should consist of just the name of
  93      the file, without the path information used to find it.  Note
  94      that we only need to do this if we have a dynamic object; an
  95      archive will never be referenced by a DT_NEEDED entry.
  96
  97      FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
  98      very pretty.  I haven't been able to think of anything that is
  99      pretty, though.  */
 100   if (bfd_check_format (entry->the_bfd, bfd_object)
 101       && (entry->the_bfd->flags & DYNAMIC) != 0)
 102     {
 103       char *needed_name;
 104
 105       ASSERT (entry->is_archive && entry->search_dirs_flag);
 106       needed_name = (char *) xmalloc (strlen (filename)
 107                                       + strlen (arch)
 108                                       + sizeof "lib.so");
 109       sprintf (needed_name, "lib%s%s.so", filename, arch);
 110       bfd_elf_set_dt_needed_name (entry->the_bfd, needed_name);
 111     }
 112
 113   return true;
 114 }
 115
 116 /* These variables are required to pass information back and forth
 117    between after_open and check_needed.  */
 118
 119 static struct bfd_elf_link_needed_list *global_needed;
 120 static boolean global_found;
 121
 122 /* This is called after all the input files have been opened.  */
 123
 124 static void
 125 gld${EMULATION_NAME}_after_open ()
 126 {
 127   struct bfd_elf_link_needed_list *needed, *l;
 128
 129   /* Get the list of files which appear in DT_NEEDED entries in
 130      dynamic objects included in the link (often there will be none).
 131      For each such file, we want to track down the corresponding
 132      library, and include the symbol table in the link.  This is what
 133      the runtime dynamic linker will do.  Tracking the files down here
 134      permits one dynamic object to include another without requiring
 135      special action by the person doing the link.  Note that the
 136      needed list can actually grow while we are stepping through this
 137      loop.  */
 138   needed = bfd_elf_get_needed_list (output_bfd, &link_info);
 139   for (l = needed; l != NULL; l = l->next)
 140     {
 141       struct bfd_elf_link_needed_list *ll;
 142       const char *lib_path;
 143       size_t len;
 144       search_dirs_type *search;
 145
 146       /* If we've already seen this file, skip it.  */
 147       for (ll = needed; ll != l; ll = ll->next)
 148         if (strcmp (ll->name, l->name) == 0)
 149           break;
 150       if (ll != l)
 151         continue;
 152
 153       /* See if this file was included in the link explicitly.  */
 154       global_needed = l;
 155       global_found = false;
 156       lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
 157       if (global_found)
 158         continue;
 159
 160       /* We need to find this file and include the symbol table.  We
 161          want to search for the file in the same way that the dynamic
 162          linker will search.  That means that we want to use rpath,
 163          then the environment variable LD_LIBRARY_PATH, then the
 164          linker script LIB_SEARCH_DIRS.  We do not search using the -L
 165          arguments.  */
 166       if (gld${EMULATION_NAME}_search_needed (command_line.rpath, l->name))
 167         continue;
 168       lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
 169       if (gld${EMULATION_NAME}_search_needed (lib_path, l->name))
 170         continue;
 171       len = strlen (l->name);
 172       for (search = search_head; search != NULL; search = search->next)
 173         {
 174           char *filename;
 175
 176           if (search->cmdline)
 177             continue;
 178           filename = (char *) xmalloc (strlen (search->name) + len + 2);
 179           sprintf (filename, "%s/%s", search->name, l->name);
 180           if (gld${EMULATION_NAME}_try_needed (filename))
 181             break;
 182           free (filename);
 183         }
 184       if (search != NULL)
 185         continue;
 186
 187       einfo ("%P: warning: %s, needed by %B, not found\n",
 188              l->name, l->by);
 189     }
 190 }
 191
 192 /* Search for a needed file in a path.  */
 193
 194 static boolean
 195 gld${EMULATION_NAME}_search_needed (path, name)
 196      const char *path;
 197      const char *name;
 198 {
 199   const char *s;
 200   size_t len;
 201
 202   if (path == NULL || *path == '\0')
 203     return false;
 204   len = strlen (name);
 205   while (1)
 206     {
 207       char *filename, *sset;
 208
 209       s = strchr (path, ':');
 210       if (s == NULL)
 211         s = path + strlen (path);
 212
 213       filename = (char *) xmalloc (s - path + len + 2);
 214       if (s == path)
 215         sset = filename;
 216       else
 217         {
 218           memcpy (filename, path, s - path);
 219           filename[s - path] = '/';
 220           sset = filename + (s - path) + 1;
 221         }
 222       strcpy (sset, name);
 223
 224       if (gld${EMULATION_NAME}_try_needed (filename))
 225         return true;
 226
 227       free (filename);
 228
 229       if (*s == '\0')
 230         break;
 231       path = s + 1;
 232     }
 233
 234   return false;
 235 }
 236
 237 /* This function is called for each possible name for a dynamic object
 238    named by a DT_NEEDED entry.  */
 239
 240 static boolean
 241 gld${EMULATION_NAME}_try_needed (name)
 242      const char *name;
 243 {
 244   bfd *abfd;
 245
 246   abfd = bfd_openr (name, bfd_get_target (output_bfd));
 247   if (abfd == NULL)
 248     return false;
 249   if (! bfd_check_format (abfd, bfd_object))
 250     {
 251       (void) bfd_close (abfd);
 252       return false;
 253     }
 254   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 255     {
 256       (void) bfd_close (abfd);
 257       return false;
 258     }
 259
 260   /* We've found a dynamic object matching the DT_NEEDED entry.  */
 261
 262   /* Tell the ELF backend that don't want the output file to have a
 263      DT_NEEDED entry for this file.  */
 264   bfd_elf_set_dt_needed_name (abfd, "");
 265
 266   /* Add this file into the symbol table.  */
 267   if (! bfd_link_add_symbols (abfd, &link_info))
 268     einfo ("%F%B: could not read symbols: %E\n", abfd);
 269
 270   return true;
 271 }
 272
 273 /* See if an input file matches a DT_NEEDED entry.  */
 274
 275 static void
 276 gld${EMULATION_NAME}_check_needed (s)
 277      lang_input_statement_type *s;
 278 {
 279   if (s->filename != NULL
 280       && strcmp (s->filename, global_needed->name) == 0)
 281     global_found = true;
 282 }
 283
 284 /* This is called after the sections have been attached to output
 285    sections, but before any sizes or addresses have been set.  */
 286
 287 static void
 288 gld${EMULATION_NAME}_before_allocation ()
 289 {
 290   asection *sinterp;
 291
 292   /* If we are going to make any variable assignments, we need to let
 293      the ELF backend know about them in case the variables are
 294      referred to by dynamic objects.  */
 295   lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
 296
 297   /* Let the ELF backend work out the sizes of any sections required
 298      by dynamic linking.  */
 299   if (! bfd_elf32_size_dynamic_sections (output_bfd,
 300                                          command_line.soname,
 301                                          command_line.rpath,
 302                                          command_line.export_dynamic,
 303                                          &link_info,
 304                                          &sinterp))
 305     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
 306
 307   /* Let the user override the dynamic linker we are using.  */
 308   if (command_line.interpreter != NULL
 309       && sinterp != NULL)
 310     {
 311       sinterp->contents = (bfd_byte *) command_line.interpreter;
 312       sinterp->_raw_size = strlen (command_line.interpreter) + 1;
 313     }
 314
 315   /* Look for any sections named .gnu.warning.  As a GNU extensions,
 316      we treat such sections as containing warning messages.  We print
 317      out the warning message, and then zero out the section size so
 318      that it does not get copied into the output file.  */
 319
 320   {
 321     LANG_FOR_EACH_INPUT_STATEMENT (is)
 322       {
 323         asection *s;
 324         bfd_size_type sz;
 325         char *msg;
 326         boolean ret;
 327
 328         if (is->just_syms_flag)
 329           continue;
 330
 331         s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
 332         if (s == NULL)
 333           continue;
 334
 335         sz = bfd_section_size (is->the_bfd, s);
 336         msg = xmalloc ((size_t) sz + 1);
 337         if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
 338           einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
 339                  is->the_bfd);
 340         msg[sz] = '\0';
 341         ret = link_info.callbacks->warning (&link_info, msg);
 342         ASSERT (ret);
 343         free (msg);
 344
 345         /* Clobber the section size, so that we don't waste copying the
 346            warning into the output file.  */
 347         s->_raw_size = 0;
 348       }
 349   }
 350
 351 #if defined (TARGET_IS_elf32bmip) || defined (TARGET_IS_elf32lmip)
 352   /* For MIPS ELF the .reginfo section requires special handling.
 353      Each input section is 24 bytes, and the final output section must
 354      also be 24 bytes.  We handle this by clobbering all but the first
 355      input section size to 0.  The .reginfo section is handled
 356      specially by the backend code anyhow.  */
 357   {
 358     boolean found = false;
 359     LANG_FOR_EACH_INPUT_STATEMENT (is)
 360       {
 361         asection *s;
 362
 363         if (is->just_syms_flag)
 364           continue;
 365
 366         s = bfd_get_section_by_name (is->the_bfd, ".reginfo");
 367         if (s == NULL)
 368           continue;
 369
 370         if (! found)
 371           {
 372             found = true;
 373             continue;
 374           }
 375
 376         s->_raw_size = 0;
 377         s->_cooked_size = 0;
 378       }
 379   }
 380 #endif
 381 }
 382
 383 /* This is called by the before_allocation routine via
 384    lang_for_each_statement.  It locates any assignment statements, and
 385    tells the ELF backend about them, in case they are assignments to
 386    symbols which are referred to by dynamic objects.  */
 387
 388 static void
 389 gld${EMULATION_NAME}_find_statement_assignment (s)
 390      lang_statement_union_type *s;
 391 {
 392   if (s->header.type == lang_assignment_statement_enum)
 393     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
 394 }
 395
 396 /* Look through an expression for an assignment statement.  */
 397
 398 static void
 399 gld${EMULATION_NAME}_find_exp_assignment (exp)
 400      etree_type *exp;
 401 {
 402   switch (exp->type.node_class)
 403     {
 404     case etree_assign:
 405       if (strcmp (exp->assign.dst, ".") != 0)
 406         {
 407           if (! bfd_elf32_record_link_assignment (output_bfd, &link_info,
 408                                                   exp->assign.dst))
 409             einfo ("%P%F: failed to record assignment to %s: %E\n",
 410                    exp->assign.dst);
 411         }
 412       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
 413       break;
 414
 415     case etree_binary:
 416       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
 417       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
 418       break;
 419
 420     case etree_trinary:
 421       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 422       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 423       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
 424       break;
 425
 426     case etree_unary:
 427       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
 428       break;
 429
 430     default:
 431       break;
 432     }
 433 }
 434
 435 /* Place an orphan section.  We use this to put random SHF_ALLOC
 436    sections in the right segment.  */
 437
 438 static asection *hold_section;
 439 static lang_output_section_statement_type *hold_use;
 440 static lang_output_section_statement_type *hold_text;
 441 static lang_output_section_statement_type *hold_data;
 442 static lang_output_section_statement_type *hold_bss;
 443 static lang_output_section_statement_type *hold_rel;
 444
 445 /*ARGSUSED*/
 446 static boolean
 447 gld${EMULATION_NAME}_place_orphan (file, s)
 448      lang_input_statement_type *file;
 449      asection *s;
 450 {
 451   lang_output_section_statement_type *place;
 452   asection *snew, **pps;
 453   lang_statement_list_type *old;
 454   lang_statement_list_type add;
 455   etree_type *address;
 456   const char *secname, *ps;
 457   lang_output_section_statement_type *os;
 458
 459   if ((s->flags & SEC_ALLOC) == 0)
 460     return false;
 461
 462   /* Look through the script to see where to place this section.  */
 463   hold_section = s;
 464   hold_use = NULL;
 465   lang_for_each_statement (gld${EMULATION_NAME}_place_section);
 466
 467   if (hold_use != NULL)
 468     {
 469       /* We have already placed a section with this name.  */
 470       wild_doit (&hold_use->children, s, hold_use, file);
 471       return true;
 472     }
 473
 474   secname = bfd_get_section_name (s->owner, s);
 475
 476   /* Decide which segment the section should go in based on the
 477      section name and section flags.  */
 478   place = NULL;
 479   if ((s->flags & SEC_HAS_CONTENTS) == 0
 480       && hold_bss != NULL)
 481     place = hold_bss;
 482   else if ((s->flags & SEC_READONLY) == 0
 483            && hold_data != NULL)
 484     place = hold_data;
 485   else if (strncmp (secname, ".rel", 4) == 0
 486            && hold_rel != NULL)
 487     place = hold_rel;
 488   else if ((s->flags & SEC_READONLY) != 0
 489            && hold_text != NULL)
 490     place = hold_text;
 491   if (place == NULL)
 492     return false;
 493
 494   /* Create the section in the output file, and put it in the right
 495      place.  This shuffling is to make the output file look neater.  */
 496   snew = bfd_make_section (output_bfd, secname);
 497   if (snew == NULL)
 498       einfo ("%P%F: output format %s cannot represent section called %s\n",
 499              output_bfd->xvec->name, secname);
 500   if (place->bfd_section != NULL)
 501     {
 502       for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
 503         ;
 504       *pps = snew->next;
 505       snew->next = place->bfd_section->next;
 506       place->bfd_section->next = snew;
 507     }
 508
 509   /* Start building a list of statements for this section.  */
 510   old = stat_ptr;
 511   stat_ptr = &add;
 512   lang_list_init (stat_ptr);
 513
 514   /* If the name of the section is representable in C, then create
 515      symbols to mark the start and the end of the section.  */
 516   for (ps = secname; *ps != '\0'; ps++)
 517     if (! isalnum (*ps) && *ps != '_')
 518       break;
 519   if (*ps == '\0' && config.build_constructors)
 520     {
 521       char *symname;
 522
 523       symname = (char *) xmalloc (ps - secname + sizeof "__start_");
 524       sprintf (symname, "__start_%s", secname);
 525       lang_add_assignment (exp_assop ('=', symname,
 526                                       exp_nameop (NAME, ".")));
 527     }
 528
 529   if (! link_info.relocateable)
 530     address = NULL;
 531   else
 532     address = exp_intop ((bfd_vma) 0);
 533
 534   lang_enter_output_section_statement (secname, address, 0,
 535                                        (bfd_vma) 0,
 536                                        (etree_type *) NULL,
 537                                        (etree_type *) NULL,
 538                                        (etree_type *) NULL);
 539
 540   os = lang_output_section_statement_lookup (secname);
 541   wild_doit (&os->children, s, os, file);
 542
 543   lang_leave_output_section_statement ((bfd_vma) 0, "*default*");
 544   stat_ptr = &add;
 545
 546   if (*ps == '\0' && config.build_constructors)
 547     {
 548       char *symname;
 549
 550       symname = (char *) xmalloc (ps - secname + sizeof "__stop_");
 551       sprintf (symname, "__stop_%s", secname);
 552       lang_add_assignment (exp_assop ('=', symname,
 553                                       exp_nameop (NAME, ".")));
 554     }
 555
 556   /* Now stick the new statement list right after PLACE.  */
 557   *add.tail = place->header.next;
 558   place->header.next = add.head;
 559
 560   stat_ptr = old;
 561
 562   return true;
 563 }
 564
 565 static void
 566 gld${EMULATION_NAME}_place_section (s)
 567      lang_statement_union_type *s;
 568 {
 569   lang_output_section_statement_type *os;
 570
 571   if (s->header.type != lang_output_section_statement_enum)
 572     return;
 573
 574   os = &s->output_section_statement;
 575
 576   if (strcmp (os->name, hold_section->name) == 0)
 577     hold_use = os;
 578
 579   if (strcmp (os->name, ".text") == 0)
 580     hold_text = os;
 581   else if (strcmp (os->name, ".data") == 0)
 582     hold_data = os;
 583   else if (strcmp (os->name, ".bss") == 0)
 584     hold_bss = os;
 585   else if (hold_rel == NULL
 586            && strncmp (os->name, ".rel", 4) == 0)
 587     hold_rel = os;
 588 }
 589
 590 static char *
 591 gld${EMULATION_NAME}_get_script(isfile)
 592      int *isfile;
 593 EOF
 594
 595 if test -n "$COMPILE_IN"
 596 then
 597 # Scripts compiled in.
 598
 599 # sed commands to quote an ld script as a C string.
 600 sc='s/["\\]/\\&/g
 601 s/$/\\n\\/
 602 1s/^/"/
 603 $s/$/n"/
 604 '
 605
 606 cat >>e${EMULATION_NAME}.c <<EOF
 607 {
 608   *isfile = 0;
 609
 610   if (link_info.relocateable == true && config.build_constructors == true)
 611     return `sed "$sc" ldscripts/${EMULATION_NAME}.xu`;
 612   else if (link_info.relocateable == true)
 613     return `sed "$sc" ldscripts/${EMULATION_NAME}.xr`;
 614   else if (!config.text_read_only)
 615     return `sed "$sc" ldscripts/${EMULATION_NAME}.xbn`;
 616   else if (!config.magic_demand_paged)
 617     return `sed "$sc" ldscripts/${EMULATION_NAME}.xn`;
 618   else if (link_info.shared)
 619     return `sed "$sc" ldscripts/${EMULATION_NAME}.xs`;
 620   else
 621     return `sed "$sc" ldscripts/${EMULATION_NAME}.x`;
 622 }
 623 EOF
 624
 625 else
 626 # Scripts read from the filesystem.
 627
 628 cat >>e${EMULATION_NAME}.c <<EOF
 629 {
 630   *isfile = 1;
 631
 632   if (link_info.relocateable == true && config.build_constructors == true)
 633     return "ldscripts/${EMULATION_NAME}.xu";
 634   else if (link_info.relocateable == true)
 635     return "ldscripts/${EMULATION_NAME}.xr";
 636   else if (!config.text_read_only)
 637     return "ldscripts/${EMULATION_NAME}.xbn";
 638   else if (!config.magic_demand_paged)
 639     return "ldscripts/${EMULATION_NAME}.xn";
 640   else if (link_info.shared)
 641     return "ldscripts/${EMULATION_NAME}.xs";
 642   else
 643     return "ldscripts/${EMULATION_NAME}.x";
 644 }
 645 EOF
 646
 647 fi
 648
 649 cat >>e${EMULATION_NAME}.c <<EOF
 650
 651 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
 652 {
 653   gld${EMULATION_NAME}_before_parse,
 654   syslib_default,
 655   hll_default,
 656   after_parse_default,
 657   gld${EMULATION_NAME}_after_open,
 658   after_allocation_default,
 659   set_output_arch_default,
 660   ldemul_default_target,
 661   gld${EMULATION_NAME}_before_allocation,
 662   gld${EMULATION_NAME}_get_script,
 663   "${EMULATION_NAME}",
 664   "${OUTPUT_FORMAT}",
 665   NULL,
 666   NULL,
 667   gld${EMULATION_NAME}_open_dynamic_archive,
 668   gld${EMULATION_NAME}_place_orphan
 669 };
 670 EOF