elf32.em revision 130565
1184610Salfred# $FreeBSD: head/contrib/binutils/ld/emultempl/elf32.em 130565 2004-06-16 06:09:06Z obrien $ 2184610Salfred 3184610Salfred 4184610Salfred# This shell script emits a C file. -*- C -*- 5184610Salfred# It does some substitutions. 6184610Salfred# This file is now misnamed, because it supports both 32 bit and 64 bit 7184610Salfred# ELF emulations. 8184610Salfredtest -z "${ELFSIZE}" && ELFSIZE=32 9184610Salfredif [ -z "$MACHINE" ]; then 10184610Salfred OUTPUT_ARCH=${ARCH} 11184610Salfredelse 12184610Salfred OUTPUT_ARCH=${ARCH}:${MACHINE} 13184610Salfredfi 14184610Salfredcat >e${EMULATION_NAME}.c <<EOF 15184610Salfred/* This file is is generated by a shell script. DO NOT EDIT! */ 16184610Salfred 17184610Salfred/* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME} 18184610Salfred Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 19184610Salfred 2002, 2003, 2004 Free Software Foundation, Inc. 20184610Salfred Written by Steve Chamberlain <sac@cygnus.com> 21184610Salfred ELF support by Ian Lance Taylor <ian@cygnus.com> 22184610Salfred 23184610SalfredThis file is part of GLD, the Gnu Linker. 24184610Salfred 25184610SalfredThis program is free software; you can redistribute it and/or modify 26184610Salfredit under the terms of the GNU General Public License as published by 27184610Salfredthe Free Software Foundation; either version 2 of the License, or 28184610Salfred(at your option) any later version. 29184610Salfred 30184610SalfredThis program is distributed in the hope that it will be useful, 31184610Salfredbut WITHOUT ANY WARRANTY; without even the implied warranty of 32184610SalfredMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 33184610SalfredGNU General Public License for more details. 34184610Salfred 35184610SalfredYou should have received a copy of the GNU General Public License 36184610Salfredalong with this program; if not, write to the Free Software 37184610SalfredFoundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 38184610Salfred 39184610Salfred#define TARGET_IS_${EMULATION_NAME} 40184610Salfred 41184610Salfred#include "bfd.h" 42184610Salfred#include "sysdep.h" 43184610Salfred#include "libiberty.h" 44184610Salfred#include "safe-ctype.h" 45184610Salfred#include "getopt.h" 46184610Salfred 47184610Salfred#include "bfdlink.h" 48184610Salfred 49184610Salfred#include "ld.h" 50184610Salfred#include "ldmain.h" 51184610Salfred#include "ldmisc.h" 52184610Salfred#include "ldexp.h" 53184610Salfred#include "ldlang.h" 54184610Salfred#include "ldfile.h" 55184610Salfred#include "ldemul.h" 56184610Salfred#include <ldgram.h> 57184610Salfred#include "elf/common.h" 58184610Salfred 59184610Salfred/* Declare functions used by various EXTRA_EM_FILEs. */ 60184610Salfredstatic void gld${EMULATION_NAME}_before_parse (void); 61184610Salfredstatic void gld${EMULATION_NAME}_after_open (void); 62184610Salfredstatic void gld${EMULATION_NAME}_before_allocation (void); 63184610Salfredstatic bfd_boolean gld${EMULATION_NAME}_place_orphan 64184610Salfred (lang_input_statement_type *file, asection *s); 65184610Salfredstatic void gld${EMULATION_NAME}_finish (void); 66184610Salfred 67184610SalfredEOF 68184610Salfred 69184610Salfred# Import any needed special functions and/or overrides. 70184610Salfred# 71184610Salfredif test -n "$EXTRA_EM_FILE" ; then 72184610Salfred. ${srcdir}/emultempl/${EXTRA_EM_FILE}.em 73184610Salfredfi 74184610Salfred 75184610Salfred# Functions in this file can be overridden by setting the LDEMUL_* shell 76184610Salfred# variables. If the name of the overriding function is the same as is 77184610Salfred# defined in this file, then don't output this file's version. 78184610Salfred# If a different overriding name is given then output the standard function 79184610Salfred# as presumably it is called from the overriding function. 80184610Salfred# 81184610Salfredif test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then 82184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 83184610Salfred 84184610Salfredstatic void 85184610Salfredgld${EMULATION_NAME}_before_parse (void) 86184610Salfred{ 87194677Sthompsa ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`); 88194677Sthompsa config.dynamic_link = ${DYNAMIC_LINK-TRUE}; 89194677Sthompsa config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`; 90194677Sthompsa} 91194677Sthompsa 92194677SthompsaEOF 93194677Sthompsafi 94194677Sthompsa 95194677Sthompsaif test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then 96194677Sthompsacat >>e${EMULATION_NAME}.c <<EOF 97194677Sthompsa/* Handle as_needed DT_NEEDED. */ 98194677Sthompsa 99194677Sthompsastatic bfd_boolean 100194677Sthompsagld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry) 101194677Sthompsa{ 102194677Sthompsa if (!entry->as_needed 103194677Sthompsa || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0) 104194677Sthompsa return FALSE; 105194677Sthompsa 106188942Sthompsa /* Tell the ELF linker that we don't want the output file to have a 107194677Sthompsa DT_NEEDED entry for this file, unless it is used to resolve 108194677Sthompsa references in a regular object. */ 109188942Sthompsa bfd_elf_set_dyn_lib_class (entry->the_bfd, DYN_AS_NEEDED); 110194677Sthompsa 111184610Salfred /* Continue on with normal load_symbols processing. */ 112184610Salfred return FALSE; 113188942Sthompsa} 114188942SthompsaEOF 115184610Salfredfi 116188942Sthompsa 117184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 118207077Sthompsa 119184610Salfred/* These variables are required to pass information back and forth 120184610Salfred between after_open and check_needed and stat_needed and vercheck. */ 121192502Sthompsa 122192502Sthompsastatic struct bfd_link_needed_list *global_needed; 123184610Salfredstatic struct stat global_stat; 124184610Salfredstatic bfd_boolean global_found; 125184610Salfredstatic struct bfd_link_needed_list *global_vercheck_needed; 126184610Salfredstatic bfd_boolean global_vercheck_failed; 127184610Salfred 128184610Salfred 129184610Salfred/* On Linux, it's possible to have different versions of the same 130184610Salfred shared library linked against different versions of libc. The 131184610Salfred dynamic linker somehow tags which libc version to use in 132184610Salfred /etc/ld.so.cache, and, based on the libc that it sees in the 133184610Salfred executable, chooses which version of the shared library to use. 134184610Salfred 135184610Salfred We try to do a similar check here by checking whether this shared 136184610Salfred library needs any other shared libraries which may conflict with 137184610Salfred libraries we have already included in the link. If it does, we 138184610Salfred skip it, and try to find another shared library farther on down the 139184610Salfred link path. 140184610Salfred 141184610Salfred This is called via lang_for_each_input_file. 142184610Salfred GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object 143184610Salfred which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find 144184610Salfred a conflicting version. */ 145184610Salfred 146211111Sgavinstatic void 147184610Salfredgld${EMULATION_NAME}_vercheck (lang_input_statement_type *s) 148187259Sthompsa{ 149187259Sthompsa const char *soname; 150187259Sthompsa struct bfd_link_needed_list *l; 151187259Sthompsa 152188413Sthompsa if (global_vercheck_failed) 153187259Sthompsa return; 154187259Sthompsa if (s->the_bfd == NULL 155184610Salfred || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0) 156192984Sthompsa return; 157192984Sthompsa 158184610Salfred soname = bfd_elf_get_dt_soname (s->the_bfd); 159192984Sthompsa if (soname == NULL) 160192984Sthompsa soname = lbasename (bfd_get_filename (s->the_bfd)); 161189265Sthompsa 162184610Salfred for (l = global_vercheck_needed; l != NULL; l = l->next) 163184610Salfred { 164184610Salfred const char *suffix; 165184610Salfred 166184610Salfred if (strcmp (soname, l->name) == 0) 167184610Salfred { 168184610Salfred /* Probably can't happen, but it's an easy check. */ 169184610Salfred continue; 170184610Salfred } 171184610Salfred 172184610Salfred if (strchr (l->name, '/') != NULL) 173184610Salfred continue; 174184610Salfred 175193045Sthompsa suffix = strstr (l->name, ".so."); 176211111Sgavin if (suffix == NULL) 177211111Sgavin continue; 178211111Sgavin 179192984Sthompsa suffix += sizeof ".so." - 1; 180192984Sthompsa 181192984Sthompsa if (strncmp (soname, l->name, suffix - l->name) == 0) 182192984Sthompsa { 183192984Sthompsa /* Here we know that S is a dynamic object FOO.SO.VER1, and 184192984Sthompsa the object we are considering needs a dynamic object 185192984Sthompsa FOO.SO.VER2, and VER1 and VER2 are different. This 186192984Sthompsa appears to be a version mismatch, so we tell the caller 187192984Sthompsa to try a different version of this library. */ 188192984Sthompsa global_vercheck_failed = TRUE; 189185948Sthompsa return; 190197570Sthompsa } 191184610Salfred } 192184610Salfred} 193184610Salfred 194184610Salfred 195184610Salfred/* See if an input file matches a DT_NEEDED entry by running stat on 196193045Sthompsa the file. */ 197193045Sthompsa 198193045Sthompsastatic void 199184610Salfredgld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s) 200192984Sthompsa{ 201184610Salfred struct stat st; 202187259Sthompsa const char *suffix; 203184610Salfred const char *soname; 204184610Salfred 205184610Salfred if (global_found) 206190734Sthompsa return; 207190734Sthompsa if (s->the_bfd == NULL) 208190734Sthompsa return; 209184610Salfred 210184610Salfred if (bfd_stat (s->the_bfd, &st) != 0) 211184610Salfred { 212187259Sthompsa einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd); 213184610Salfred return; 214184610Salfred } 215184610Salfred 216190734Sthompsa if (st.st_dev == global_stat.st_dev 217190734Sthompsa && st.st_ino == global_stat.st_ino) 218190734Sthompsa { 219184610Salfred global_found = TRUE; 220184610Salfred return; 221184610Salfred } 222187259Sthompsa 223184610Salfred /* We issue a warning if it looks like we are including two 224184610Salfred different versions of the same shared library. For example, 225184610Salfred there may be a problem if -lc picks up libc.so.6 but some other 226190734Sthompsa shared library has a DT_NEEDED entry of libc.so.5. This is a 227190734Sthompsa heuristic test, and it will only work if the name looks like 228190734Sthompsa NAME.so.VERSION. FIXME: Depending on file names is error-prone. 229184610Salfred If we really want to issue warnings about mixing version numbers 230184610Salfred of shared libraries, we need to find a better way. */ 231184610Salfred 232184610Salfred if (strchr (global_needed->name, '/') != NULL) 233194099Sthompsa return; 234194228Sthompsa suffix = strstr (global_needed->name, ".so."); 235194228Sthompsa if (suffix == NULL) 236194228Sthompsa return; 237194228Sthompsa suffix += sizeof ".so." - 1; 238194228Sthompsa 239194228Sthompsa soname = bfd_elf_get_dt_soname (s->the_bfd); 240194228Sthompsa if (soname == NULL) 241194228Sthompsa soname = lbasename (s->filename); 242194228Sthompsa 243194228Sthompsa if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0) 244197570Sthompsa einfo ("%P: warning: %s, needed by %B, may conflict with %s\n", 245184610Salfred global_needed->name, global_needed->by, soname); 246184610Salfred} 247211111Sgavin 248211111Sgavin 249184610Salfred/* This function is called for each possible name for a dynamic object 250192984Sthompsa named by a DT_NEEDED entry. The FORCE parameter indicates whether 251211153Sgavin to skip the check for a conflicting version. */ 252211153Sgavin 253211153Sgavinstatic bfd_boolean 254211153Sgavingld${EMULATION_NAME}_try_needed (const char *name, int force) 255211153Sgavin{ 256211111Sgavin bfd *abfd; 257217274Sgavin const char *soname; 258211111Sgavin 259211153Sgavin abfd = bfd_openr (name, bfd_get_target (output_bfd)); 260217202Sgavin if (abfd == NULL) 261217274Sgavin return FALSE; 262217274Sgavin if (! bfd_check_format (abfd, bfd_object)) 263211111Sgavin { 264211153Sgavin bfd_close (abfd); 265211111Sgavin return FALSE; 266211111Sgavin } 267211153Sgavin if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0) 268211153Sgavin { 269211153Sgavin bfd_close (abfd); 270211153Sgavin return FALSE; 271211111Sgavin } 272211153Sgavin 273211153Sgavin /* For DT_NEEDED, they have to match. */ 274211153Sgavin if (abfd->xvec != output_bfd->xvec) 275211153Sgavin { 276211153Sgavin bfd_close (abfd); 277211153Sgavin return FALSE; 278211153Sgavin } 279211153Sgavin 280211153Sgavin /* Check whether this object would include any conflicting library 281211153Sgavin versions. If FORCE is set, then we skip this check; we use this 282211111Sgavin the second time around, if we couldn't find any compatible 283211153Sgavin instance of the shared library. */ 284211111Sgavin 285211111Sgavin if (! force) 286217061Sgavin { 287211153Sgavin struct bfd_link_needed_list *needed; 288217274Sgavin 289211111Sgavin if (! bfd_elf_get_bfd_needed_list (abfd, &needed)) 290211111Sgavin einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd); 291211153Sgavin 292211153Sgavin if (needed != NULL) 293217274Sgavin { 294217274Sgavin global_vercheck_needed = needed; 295217274Sgavin global_vercheck_failed = FALSE; 296217274Sgavin lang_for_each_input_file (gld${EMULATION_NAME}_vercheck); 297211111Sgavin if (global_vercheck_failed) 298217274Sgavin { 299211153Sgavin bfd_close (abfd); 300211153Sgavin /* Return FALSE to force the caller to move on to try 301211153Sgavin another file on the search path. */ 302211111Sgavin return FALSE; 303211111Sgavin } 304211153Sgavin 305211153Sgavin /* But wait! It gets much worse. On Linux, if a shared 306211111Sgavin library does not use libc at all, we are supposed to skip 307211153Sgavin it the first time around in case we encounter a shared 308217274Sgavin library later on with the same name which does use the 309211153Sgavin version of libc that we want. This is much too horrible 310184610Salfred to use on any system other than Linux. */ 311201028Sthompsa 312184610SalfredEOF 313184610Salfredcase ${target} in 314184610Salfred *-*-linux-gnu*) 315184610Salfred cat >>e${EMULATION_NAME}.c <<EOF 316184610Salfred { 317184610Salfred struct bfd_link_needed_list *l; 318184610Salfred 319184610Salfred for (l = needed; l != NULL; l = l->next) 320184610Salfred if (strncmp (l->name, "libc.so", 7) == 0) 321184610Salfred break; 322184610Salfred if (l == NULL) 323184610Salfred { 324184610Salfred bfd_close (abfd); 325184610Salfred return FALSE; 326184610Salfred } 327184610Salfred } 328189275Sthompsa 329188942SthompsaEOF 330188942Sthompsa ;; 331184610Salfredesac 332184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 333184610Salfred } 334184610Salfred } 335184610Salfred 336192984Sthompsa /* We've found a dynamic object matching the DT_NEEDED entry. */ 337184610Salfred 338184610Salfred /* We have already checked that there is no other input file of the 339184610Salfred same name. We must now check again that we are not including the 340192499Sthompsa same file twice. We need to do this because on many systems 341184610Salfred libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will 342184610Salfred reference libc.so.1. If we have already included libc.so, we 343184610Salfred don't want to include libc.so.1 if they are the same file, and we 344184610Salfred can only check that using stat. */ 345184610Salfred 346184610Salfred if (bfd_stat (abfd, &global_stat) != 0) 347184610Salfred einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd); 348184610Salfred 349194228Sthompsa /* First strip off everything before the last '/'. */ 350184610Salfred soname = lbasename (abfd->filename); 351184610Salfred 352184610Salfred if (trace_file_tries) 353184610Salfred info_msg (_("found %s at %s\n"), soname, name); 354184610Salfred 355192984Sthompsa global_found = FALSE; 356184610Salfred lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed); 357192984Sthompsa if (global_found) 358192984Sthompsa { 359211111Sgavin /* Return TRUE to indicate that we found the file, even though 360184610Salfred we aren't going to do anything with it. */ 361184610Salfred return TRUE; 362184610Salfred } 363184610Salfred 364194228Sthompsa /* Specify the soname to use. */ 365189265Sthompsa bfd_elf_set_dt_needed_name (abfd, soname); 366184610Salfred 367184610Salfred /* Tell the ELF linker that we don't want the output file to have a 368184610Salfred DT_NEEDED entry for this file, unless it is used to resolve 369184610Salfred references in a regular object. */ 370184610Salfred bfd_elf_set_dyn_lib_class (abfd, DYN_DT_NEEDED); 371211111Sgavin 372211111Sgavin /* Add this file into the symbol table. */ 373211111Sgavin if (! bfd_link_add_symbols (abfd, &link_info)) 374211111Sgavin einfo ("%F%B: could not read symbols: %E\n", abfd); 375211111Sgavin 376211111Sgavin return TRUE; 377211111Sgavin} 378211111Sgavin 379211111Sgavin 380184610Salfred/* Search for a needed file in a path. */ 381211111Sgavin 382184610Salfredstatic bfd_boolean 383184610Salfredgld${EMULATION_NAME}_search_needed (const char *path, const char *name, int force) 384184610Salfred{ 385184610Salfred const char *s; 386184610Salfred size_t len; 387184610Salfred 388184610Salfred if (name[0] == '/') 389184610Salfred return gld${EMULATION_NAME}_try_needed (name, force); 390184610Salfred 391184610Salfred if (path == NULL || *path == '\0') 392184610Salfred return FALSE; 393184610Salfred len = strlen (name); 394184610Salfred while (1) 395184610Salfred { 396184610Salfred char *filename, *sset; 397184610Salfred 398184610Salfred s = strchr (path, ':'); 399184610Salfred if (s == NULL) 400194228Sthompsa s = path + strlen (path); 401184610Salfred 402194228Sthompsa filename = (char *) xmalloc (s - path + len + 2); 403184610Salfred if (s == path) 404199816Sthompsa sset = filename; 405184610Salfred else 406184610Salfred { 407184610Salfred memcpy (filename, path, s - path); 408184610Salfred filename[s - path] = '/'; 409194228Sthompsa sset = filename + (s - path) + 1; 410184610Salfred } 411184610Salfred strcpy (sset, name); 412184610Salfred 413184610Salfred if (gld${EMULATION_NAME}_try_needed (filename, force)) 414184610Salfred return TRUE; 415184610Salfred 416194228Sthompsa free (filename); 417184610Salfred 418189265Sthompsa if (*s == '\0') 419184610Salfred break; 420184610Salfred path = s + 1; 421194228Sthompsa } 422184610Salfred 423184610Salfred return FALSE; 424184610Salfred} 425184610Salfred 426184610SalfredEOF 427194228Sthompsaif [ "x${USE_LIBPATH}" = xyes ] ; then 428184610Salfred cat >>e${EMULATION_NAME}.c <<EOF 429184610Salfred 430184610Salfred/* Add the sysroot to every entry in a colon-separated path. */ 431189265Sthompsa 432194677Sthompsastatic char * 433194677Sthompsagld${EMULATION_NAME}_add_sysroot (const char *path) 434189265Sthompsa{ 435184610Salfred int len, colons, i; 436194228Sthompsa char *ret, *p; 437189265Sthompsa 438184610Salfred len = strlen (path); 439184610Salfred colons = 0; 440184610Salfred i = 0; 441184610Salfred while (path[i]) 442184610Salfred if (path[i++] == ':') 443184610Salfred colons++; 444184610Salfred 445211111Sgavin if (path[i]) 446211111Sgavin colons++; 447211111Sgavin 448184610Salfred len = len + (colons + 1) * strlen (ld_sysroot); 449214843Sn_hibma ret = xmalloc (len + 1); 450214843Sn_hibma strcpy (ret, ld_sysroot); 451184610Salfred p = ret + strlen (ret); 452184610Salfred i = 0; 453184610Salfred while (path[i]) 454184610Salfred if (path[i] == ':') 455184610Salfred { 456184610Salfred *p++ = path[i++]; 457184610Salfred strcpy (p, ld_sysroot); 458184610Salfred p = p + strlen (p); 459184610Salfred } 460184610Salfred else 461184610Salfred *p++ = path[i++]; 462184610Salfred 463184610Salfred *p = 0; 464184610Salfred return ret; 465214761Sn_hibma} 466194228Sthompsa 467189265SthompsaEOF 468184610Salfred case ${target} in 469184610Salfred *-*-freebsd*) 470184610Salfred cat >>e${EMULATION_NAME}.c <<EOF 471184610Salfred/* 472193045Sthompsa * Read the system search path the FreeBSD way rather than like Linux. 473192984Sthompsa */ 474184610Salfred#include <elf-hints.h> 475192984Sthompsa 476184610Salfredstatic bfd_boolean 477184610Salfredgld${EMULATION_NAME}_check_ld_elf_hints (const char *name, int force) 478184610Salfred{ 479184610Salfred static bfd_boolean initialized; 480184610Salfred static char *ld_elf_hints; 481184610Salfred 482184610Salfred if (! initialized) 483184610Salfred { 484194228Sthompsa FILE *f; 485184610Salfred char *tmppath; 486184610Salfred 487211111Sgavin tmppath = concat (ld_sysroot, _PATH_ELF_HINTS, NULL); 488211111Sgavin f = fopen (tmppath, FOPEN_RB); 489211111Sgavin free (tmppath); 490184610Salfred if (f != NULL) 491192984Sthompsa { 492193045Sthompsa struct elfhints_hdr hdr; 493184610Salfred 494184610Salfred if (fread(&hdr, 1, sizeof(hdr), f) == sizeof(hdr) && 495211111Sgavin hdr.magic == ELFHINTS_MAGIC && 496211111Sgavin hdr.version == 1) 497211111Sgavin { 498211111Sgavin if (fseek(f, hdr.strtab + hdr.dirlist, SEEK_SET) != -1) 499211111Sgavin { 500184610Salfred char *b; 501211111Sgavin 502211111Sgavin b = (char *) xmalloc (hdr.dirlistlen + 1); 503211111Sgavin if (fread(b, 1, hdr.dirlistlen + 1, f) != 504211111Sgavin hdr.dirlistlen + 1) 505184610Salfred { 506184610Salfred free(b); 507184610Salfred b = NULL; 508184610Salfred } 509211111Sgavin else 510211111Sgavin { 511211111Sgavin ld_elf_hints = gld${EMULATION_NAME}_add_sysroot (b); 512211111Sgavin free (b); 513211111Sgavin } 514211111Sgavin } 515211111Sgavin } 516211111Sgavin fclose (f); 517211111Sgavin } 518211111Sgavin 519211111Sgavin initialized = TRUE; 520211111Sgavin } 521211111Sgavin 522211111Sgavin if (ld_elf_hints == NULL) 523211111Sgavin return FALSE; 524211111Sgavin 525211111Sgavin return gld${EMULATION_NAME}_search_needed (ld_elf_hints, name, force); 526211111Sgavin} 527211111SgavinEOF 528211111Sgavin # FreeBSD 529211111Sgavin ;; 530211111Sgavin 531211111Sgavin *-*-linux-gnu*) 532211111Sgavin cat >>e${EMULATION_NAME}.c <<EOF 533211111Sgavin/* For a native linker, check the file /etc/ld.so.conf for directories 534211111Sgavin in which we may find shared libraries. /etc/ld.so.conf is really 535211111Sgavin only meaningful on Linux. */ 536211111Sgavin 537211111Sgavinstatic bfd_boolean 538211111Sgavingld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force) 539184610Salfred{ 540192984Sthompsa static bfd_boolean initialized; 541184610Salfred static char *ld_so_conf; 542184610Salfred 543192984Sthompsa if (! initialized) 544184610Salfred { 545184610Salfred FILE *f; 546184610Salfred char *tmppath; 547184610Salfred 548184610Salfred tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL); 549184610Salfred f = fopen (tmppath, FOPEN_RT); 550184610Salfred free (tmppath); 551184610Salfred if (f != NULL) 552184610Salfred { 553184610Salfred char *b; 554184610Salfred size_t len, alloc; 555184610Salfred int c; 556184610Salfred 557184610Salfred len = 0; 558184610Salfred alloc = 100; 559194228Sthompsa b = (char *) xmalloc (alloc); 560188413Sthompsa 561184610Salfred while ((c = getc (f)) != EOF) 562184610Salfred { 563184610Salfred if (len + 1 >= alloc) 564192984Sthompsa { 565184610Salfred alloc *= 2; 566184610Salfred b = (char *) xrealloc (b, alloc); 567192984Sthompsa } 568184610Salfred if (c != ':' 569184610Salfred && c != ' ' 570184610Salfred && c != '\t' 571184610Salfred && c != '\n' 572184610Salfred && c != ',') 573184610Salfred { 574184610Salfred b[len] = c; 575184610Salfred ++len; 576184610Salfred } 577184610Salfred else 578184610Salfred { 579184610Salfred if (len > 0 && b[len - 1] != ':') 580184610Salfred { 581184610Salfred b[len] = ':'; 582184610Salfred ++len; 583194228Sthompsa } 584188413Sthompsa } 585184610Salfred } 586184610Salfred 587184610Salfred if (len > 0 && b[len - 1] == ':') 588192984Sthompsa --len; 589184610Salfred 590184610Salfred if (len > 0) 591192984Sthompsa b[len] = '\0'; 592184610Salfred else 593184610Salfred { 594184610Salfred free (b); 595184610Salfred b = NULL; 596184610Salfred } 597184610Salfred 598184610Salfred fclose (f); 599184610Salfred 600184610Salfred if (b) 601184610Salfred { 602184610Salfred char *d = gld${EMULATION_NAME}_add_sysroot (b); 603184610Salfred free (b); 604184610Salfred b = d; 605194228Sthompsa } 606188413Sthompsa 607184610Salfred ld_so_conf = b; 608184610Salfred } 609184610Salfred 610184610Salfred initialized = TRUE; 611184610Salfred } 612184610Salfred 613184610Salfred if (ld_so_conf == NULL) 614184610Salfred return FALSE; 615184610Salfred 616184610Salfred return gld${EMULATION_NAME}_search_needed (ld_so_conf, name, force); 617184610Salfred} 618184610Salfred 619184610SalfredEOF 620184610Salfred # Linux 621184610Salfred ;; 622192984Sthompsa esac 623184610Salfredfi 624211083Sgavincat >>e${EMULATION_NAME}.c <<EOF 625184610Salfred 626184610Salfred/* See if an input file matches a DT_NEEDED entry by name. */ 627184610Salfred 628184610Salfredstatic void 629211083Sgavingld${EMULATION_NAME}_check_needed (lang_input_statement_type *s) 630211083Sgavin{ 631211083Sgavin if (global_found) 632211083Sgavin return; 633211083Sgavin 634211083Sgavin if (s->filename != NULL) 635211083Sgavin { 636211083Sgavin const char *f; 637211083Sgavin 638211083Sgavin if (strcmp (s->filename, global_needed->name) == 0) 639211111Sgavin { 640211083Sgavin global_found = TRUE; 641211083Sgavin return; 642211083Sgavin } 643184610Salfred 644211083Sgavin if (s->search_dirs_flag) 645211083Sgavin { 646211083Sgavin f = strrchr (s->filename, '/'); 647184610Salfred if (f != NULL 648184610Salfred && strcmp (f + 1, global_needed->name) == 0) 649211083Sgavin { 650211083Sgavin global_found = TRUE; 651184610Salfred return; 652184610Salfred } 653184610Salfred } 654192984Sthompsa } 655184610Salfred 656184610Salfred if (s->the_bfd != NULL) 657192984Sthompsa { 658192984Sthompsa const char *soname; 659184610Salfred 660184610Salfred soname = bfd_elf_get_dt_soname (s->the_bfd); 661184610Salfred if (soname != NULL 662184610Salfred && strcmp (soname, global_needed->name) == 0) 663184610Salfred { 664184610Salfred global_found = TRUE; 665184610Salfred return; 666184610Salfred } 667184610Salfred } 668184610Salfred} 669184610Salfred 670184610SalfredEOF 671184610Salfred 672184610Salfredif test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then 673184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 674184610Salfred 675184610Salfred/* This is called after all the input files have been opened. */ 676184610Salfred 677184610Salfredstatic void 678184610Salfredgld${EMULATION_NAME}_after_open (void) 679184610Salfred{ 680184610Salfred struct bfd_link_needed_list *needed, *l; 681184610Salfred 682184610Salfred /* We only need to worry about this when doing a final link. */ 683184610Salfred if (link_info.relocatable || !link_info.executable) 684184610Salfred return; 685184610Salfred 686184610Salfred /* Get the list of files which appear in DT_NEEDED entries in 687184610Salfred dynamic objects included in the link (often there will be none). 688184610Salfred For each such file, we want to track down the corresponding 689184610Salfred library, and include the symbol table in the link. This is what 690184610Salfred the runtime dynamic linker will do. Tracking the files down here 691184610Salfred permits one dynamic object to include another without requiring 692184610Salfred special action by the person doing the link. Note that the 693184610Salfred needed list can actually grow while we are stepping through this 694184610Salfred loop. */ 695184610Salfred needed = bfd_elf_get_needed_list (output_bfd, &link_info); 696184610Salfred for (l = needed; l != NULL; l = l->next) 697184610Salfred { 698184610Salfred struct bfd_link_needed_list *ll; 699184610Salfred int force; 700184610Salfred 701184610Salfred /* If we've already seen this file, skip it. */ 702184610Salfred for (ll = needed; ll != l; ll = ll->next) 703184610Salfred if (strcmp (ll->name, l->name) == 0) 704184610Salfred break; 705184610Salfred if (ll != l) 706184610Salfred continue; 707184610Salfred 708194228Sthompsa /* See if this file was included in the link explicitly. */ 709188413Sthompsa global_needed = l; 710184610Salfred global_found = FALSE; 711184610Salfred lang_for_each_input_file (gld${EMULATION_NAME}_check_needed); 712184610Salfred if (global_found) 713184610Salfred continue; 714184610Salfred 715184610Salfred if (trace_file_tries) 716184610Salfred info_msg (_("%s needed by %B\n"), l->name, l->by); 717184610Salfred 718211111Sgavin /* We need to find this file and include the symbol table. We 719184610Salfred want to search for the file in the same way that the dynamic 720184610Salfred linker will search. That means that we want to use 721184610Salfred rpath_link, rpath, then the environment variable 722184610Salfred LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH 723184610Salfred entries (native only), then the linker script LIB_SEARCH_DIRS. 724194228Sthompsa We do not search using the -L arguments. 725188413Sthompsa 726184610Salfred We search twice. The first time, we skip objects which may 727184610Salfred introduce version mismatches. The second time, we force 728184610Salfred their use. See gld${EMULATION_NAME}_vercheck comment. */ 729184610Salfred for (force = 0; force < 2; force++) 730184610Salfred { 731184610Salfred size_t len; 732194228Sthompsa search_dirs_type *search; 733188413SthompsaEOF 734184610Salfredif [ "x${USE_LIBPATH}" = xyes ] ; then 735184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 736184610Salfred const char *lib_path; 737184610Salfred struct bfd_link_needed_list *rp; 738192984Sthompsa int found; 739184610SalfredEOF 740184610Salfredfi 741184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 742184610Salfred 743194228Sthompsa if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link, 744184610Salfred l->name, force)) 745184610Salfred break; 746194228SthompsaEOF 747184610Salfredif [ "x${USE_LIBPATH}" = xyes ] ; then 748184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 749184610Salfred if (gld${EMULATION_NAME}_search_needed (command_line.rpath, 750192984Sthompsa l->name, force)) 751184610Salfred break; 752184610SalfredEOF 753184610Salfredfi 754184610Salfredif [ "x${NATIVE}" = xyes ] ; then 755194228Sthompsacat >>e${EMULATION_NAME}.c <<EOF 756184610Salfred if (command_line.rpath_link == NULL 757184610Salfred && command_line.rpath == NULL) 758194228Sthompsa { 759184610Salfred lib_path = (const char *) getenv ("LD_RUN_PATH"); 760184610Salfred if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, 761184610Salfred force)) 762192984Sthompsa break; 763184610Salfred } 764184610Salfred lib_path = (const char *) getenv ("LD_LIBRARY_PATH"); 765184610Salfred if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, force)) 766194228Sthompsa break; 767184610SalfredEOF 768184610Salfredfi 769184610Salfredif [ "x${USE_LIBPATH}" = xyes ] ; then 770192984Sthompsacat >>e${EMULATION_NAME}.c <<EOF 771184610Salfred found = 0; 772184610Salfred rp = bfd_elf_get_runpath_list (output_bfd, &link_info); 773184610Salfred for (; !found && rp != NULL; rp = rp->next) 774194228Sthompsa { 775184610Salfred char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name); 776184610Salfred found = (rp->by == l->by 777184610Salfred && gld${EMULATION_NAME}_search_needed (tmpname, 778192984Sthompsa l->name, 779184610Salfred force)); 780184610Salfred free (tmpname); 781184610Salfred } 782184610Salfred if (found) 783184610Salfred break; 784184610Salfred 785184610SalfredEOF 786184610Salfredfi 787184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 788184610Salfred len = strlen (l->name); 789194677Sthompsa for (search = search_head; search != NULL; search = search->next) 790184610Salfred { 791194677Sthompsa char *filename; 792194677Sthompsa 793184610Salfred if (search->cmdline) 794194677Sthompsa continue; 795184610Salfred filename = (char *) xmalloc (strlen (search->name) + len + 2); 796194677Sthompsa sprintf (filename, "%s/%s", search->name, l->name); 797194677Sthompsa if (gld${EMULATION_NAME}_try_needed (filename, force)) 798184610Salfred break; 799184610Salfred free (filename); 800184610Salfred } 801194677Sthompsa if (search != NULL) 802184610Salfred break; 803194677SthompsaEOF 804184610Salfredif [ "x${USE_LIBPATH}" = xyes ] ; then 805194677Sthompsa case ${target} in 806194677Sthompsa *-*-freebsd*) 807184610Salfred cat >>e${EMULATION_NAME}.c <<EOF 808184610Salfred if (gld${EMULATION_NAME}_check_ld_elf_hints (l->name, force)) 809184610Salfred break; 810184610SalfredEOF 811184610Salfred # FreeBSD 812184610Salfred ;; 813184610Salfred 814184610Salfred *-*-linux-gnu*) 815184610Salfred cat >>e${EMULATION_NAME}.c <<EOF 816184610Salfred if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force)) 817184610Salfred break; 818184610SalfredEOF 819184610Salfred # Linux 820184610Salfred ;; 821184610Salfred esac 822194228Sthompsafi 823184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 824184610Salfred } 825188413Sthompsa 826194677Sthompsa if (force < 2) 827194228Sthompsa continue; 828184610Salfred 829184610Salfred einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n", 830184610Salfred l->name, l->by); 831194677Sthompsa } 832188413Sthompsa} 833194677Sthompsa 834188413SthompsaEOF 835184610Salfredfi 836184610Salfred 837184610Salfredcat >>e${EMULATION_NAME}.c <<EOF 838184610Salfred 839184610Salfred/* Look through an expression for an assignment statement. */ 840184610Salfred 841194677Sthompsastatic void 842184610Salfredgld${EMULATION_NAME}_find_exp_assignment (etree_type *exp) 843194677Sthompsa{ 844194677Sthompsa struct bfd_link_hash_entry *h; 845184610Salfred 846184610Salfred switch (exp->type.node_class) 847184610Salfred { 848184610Salfred case etree_provide: 849184610Salfred h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst, 850188413Sthompsa FALSE, FALSE, FALSE); 851194677Sthompsa if (h == NULL) 852194677Sthompsa break; 853184610Salfred 854184610Salfred /* We call record_link_assignment even if the symbol is defined. 855184610Salfred This is because if it is defined by a dynamic object, we 856184610Salfred actually want to use the value defined by the linker script, 857194677Sthompsa not the value from the dynamic object (because we are setting 858194228Sthompsa symbols like etext). If the symbol is defined by a regular 859184610Salfred object, then, as it happens, calling record_link_assignment 860184610Salfred will do no harm. */ 861184610Salfred 862184610Salfred /* Fall through. */ 863194677Sthompsa case etree_assign: 864188413Sthompsa if (strcmp (exp->assign.dst, ".") != 0) 865194677Sthompsa { 866188413Sthompsa if (! (bfd_elf_record_link_assignment 867184610Salfred (output_bfd, &link_info, exp->assign.dst, 868184610Salfred exp->type.node_class == etree_provide ? TRUE : FALSE))) 869184610Salfred einfo ("%P%F: failed to record assignment to %s: %E\n", 870184610Salfred exp->assign.dst); 871184610Salfred } 872184610Salfred gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src); 873194677Sthompsa break; 874184610Salfred 875194677Sthompsa case etree_binary: 876194677Sthompsa gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs); 877194677Sthompsa gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs); 878184610Salfred break; 879194677Sthompsa 880194677Sthompsa case etree_trinary: 881184610Salfred gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond); 882184610Salfred gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs); 883194677Sthompsa gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs); 884194677Sthompsa break; 885184610Salfred 886184610Salfred case etree_unary: 887188413Sthompsa gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child); 888194677Sthompsa break; 889194228Sthompsa 890184610Salfred default: 891184610Salfred break; 892184610Salfred } 893194677Sthompsa} 894188413Sthompsa 895194677Sthompsa 896188413Sthompsa/* This is called by the before_allocation routine via 897184610Salfred lang_for_each_statement. It locates any assignment statements, and 898184610Salfred tells the ELF backend about them, in case they are assignments to 899184610Salfred symbols which are referred to by dynamic objects. */ 900184610Salfred 901197570Sthompsastatic void 902197570Sthompsagld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s) 903197570Sthompsa{ 904197570Sthompsa if (s->header.type == lang_assignment_statement_enum) 905197570Sthompsa gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp); 906197570Sthompsa} 907197570Sthompsa 908EOF 909 910if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then 911 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then 912 ELF_INTERPRETER_SET_DEFAULT=" 913 if (sinterp != NULL) 914 { 915 sinterp->contents = ${ELF_INTERPRETER_NAME}; 916 sinterp->_raw_size = strlen (sinterp->contents) + 1; 917 } 918 919" 920 else 921 ELF_INTERPRETER_SET_DEFAULT= 922 fi 923cat >>e${EMULATION_NAME}.c <<EOF 924 925/* This is called after the sections have been attached to output 926 sections, but before any sizes or addresses have been set. */ 927 928static void 929gld${EMULATION_NAME}_before_allocation (void) 930{ 931 const char *rpath; 932 asection *sinterp; 933 934 if (link_info.hash->type == bfd_link_elf_hash_table) 935 _bfd_elf_tls_setup (output_bfd, &link_info); 936 937 /* If we are going to make any variable assignments, we need to let 938 the ELF backend know about them in case the variables are 939 referred to by dynamic objects. */ 940 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment); 941 942 /* Let the ELF backend work out the sizes of any sections required 943 by dynamic linking. */ 944 rpath = command_line.rpath; 945 if (rpath == NULL) 946 rpath = (const char *) getenv ("LD_RUN_PATH"); 947 if (! (bfd_elf_size_dynamic_sections 948 (output_bfd, command_line.soname, rpath, 949 command_line.filter_shlib, 950 (const char * const *) command_line.auxiliary_filters, 951 &link_info, &sinterp, lang_elf_version_info))) 952 einfo ("%P%F: failed to set dynamic section sizes: %E\n"); 953${ELF_INTERPRETER_SET_DEFAULT} 954 /* Let the user override the dynamic linker we are using. */ 955 if (command_line.interpreter != NULL 956 && sinterp != NULL) 957 { 958 sinterp->contents = (bfd_byte *) command_line.interpreter; 959 sinterp->_raw_size = strlen (command_line.interpreter) + 1; 960 } 961 962 /* Look for any sections named .gnu.warning. As a GNU extensions, 963 we treat such sections as containing warning messages. We print 964 out the warning message, and then zero out the section size so 965 that it does not get copied into the output file. */ 966 967 { 968 LANG_FOR_EACH_INPUT_STATEMENT (is) 969 { 970 asection *s; 971 bfd_size_type sz; 972 bfd_size_type prefix_len; 973 char *msg; 974 bfd_boolean ret; 975 const char * gnu_warning_prefix = _("warning: "); 976 977 if (is->just_syms_flag) 978 continue; 979 980 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning"); 981 if (s == NULL) 982 continue; 983 984 sz = bfd_section_size (is->the_bfd, s); 985 prefix_len = strlen (gnu_warning_prefix); 986 msg = xmalloc ((size_t) (prefix_len + sz + 1)); 987 strcpy (msg, gnu_warning_prefix); 988 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len, 989 (file_ptr) 0, sz)) 990 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n", 991 is->the_bfd); 992 msg[prefix_len + sz] = '\0'; 993 ret = link_info.callbacks->warning (&link_info, msg, 994 (const char *) NULL, 995 is->the_bfd, (asection *) NULL, 996 (bfd_vma) 0); 997 ASSERT (ret); 998 free (msg); 999 1000 /* Clobber the section size, so that we don't waste copying the 1001 warning into the output file. */ 1002 s->_raw_size = 0; 1003 } 1004 } 1005} 1006 1007EOF 1008fi 1009 1010if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then 1011cat >>e${EMULATION_NAME}.c <<EOF 1012 1013/* Try to open a dynamic archive. This is where we know that ELF 1014 dynamic libraries have an extension of .so (or .sl on oddball systems 1015 like hpux). */ 1016 1017static bfd_boolean 1018gld${EMULATION_NAME}_open_dynamic_archive 1019 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry) 1020{ 1021 const char *filename; 1022 char *string; 1023 1024 if (! entry->is_archive) 1025 return FALSE; 1026 1027 filename = entry->filename; 1028 1029 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION 1030 is defined, but it does not seem worth the headache to optimize 1031 away those two bytes of space. */ 1032 string = (char *) xmalloc (strlen (search->name) 1033 + strlen (filename) 1034 + strlen (arch) 1035#ifdef EXTRA_SHLIB_EXTENSION 1036 + strlen (EXTRA_SHLIB_EXTENSION) 1037#endif 1038 + sizeof "/lib.so"); 1039 1040 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch); 1041 1042#ifdef EXTRA_SHLIB_EXTENSION 1043 /* Try the .so extension first. If that fails build a new filename 1044 using EXTRA_SHLIB_EXTENSION. */ 1045 if (! ldfile_try_open_bfd (string, entry)) 1046 sprintf (string, "%s/lib%s%s%s", search->name, 1047 filename, arch, EXTRA_SHLIB_EXTENSION); 1048#endif 1049 1050 if (! ldfile_try_open_bfd (string, entry)) 1051 { 1052 free (string); 1053 return FALSE; 1054 } 1055 1056 entry->filename = string; 1057 1058 /* We have found a dynamic object to include in the link. The ELF 1059 backend linker will create a DT_NEEDED entry in the .dynamic 1060 section naming this file. If this file includes a DT_SONAME 1061 entry, it will be used. Otherwise, the ELF linker will just use 1062 the name of the file. For an archive found by searching, like 1063 this one, the DT_NEEDED entry should consist of just the name of 1064 the file, without the path information used to find it. Note 1065 that we only need to do this if we have a dynamic object; an 1066 archive will never be referenced by a DT_NEEDED entry. 1067 1068 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not 1069 very pretty. I haven't been able to think of anything that is 1070 pretty, though. */ 1071 if (bfd_check_format (entry->the_bfd, bfd_object) 1072 && (entry->the_bfd->flags & DYNAMIC) != 0) 1073 { 1074 ASSERT (entry->is_archive && entry->search_dirs_flag); 1075 1076 /* Rather than duplicating the logic above. Just use the 1077 filename we recorded earlier. */ 1078 1079 filename = lbasename (entry->filename); 1080 bfd_elf_set_dt_needed_name (entry->the_bfd, filename); 1081 } 1082 1083 return TRUE; 1084} 1085 1086EOF 1087fi 1088 1089if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then 1090cat >>e${EMULATION_NAME}.c <<EOF 1091 1092/* A variant of lang_output_section_find. Used by place_orphan. */ 1093 1094static lang_output_section_statement_type * 1095output_rel_find (asection *sec, int isdyn) 1096{ 1097 lang_statement_union_type *u; 1098 lang_output_section_statement_type *lookup; 1099 lang_output_section_statement_type *last = NULL; 1100 lang_output_section_statement_type *last_alloc = NULL; 1101 lang_output_section_statement_type *last_rel = NULL; 1102 lang_output_section_statement_type *last_rel_alloc = NULL; 1103 int rela = sec->name[4] == 'a'; 1104 1105 for (u = lang_output_section_statement.head; u; u = lookup->next) 1106 { 1107 lookup = &u->output_section_statement; 1108 if (strncmp (".rel", lookup->name, 4) == 0) 1109 { 1110 int lookrela = lookup->name[4] == 'a'; 1111 1112 /* .rel.dyn must come before all other reloc sections, to suit 1113 GNU ld.so. */ 1114 if (isdyn) 1115 break; 1116 1117 /* Don't place after .rel.plt as doing so results in wrong 1118 dynamic tags. */ 1119 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0) 1120 break; 1121 1122 if (rela == lookrela || last_rel == NULL) 1123 last_rel = lookup; 1124 if ((rela == lookrela || last_rel_alloc == NULL) 1125 && lookup->bfd_section != NULL 1126 && (lookup->bfd_section->flags & SEC_ALLOC) != 0) 1127 last_rel_alloc = lookup; 1128 } 1129 1130 last = lookup; 1131 if (lookup->bfd_section != NULL 1132 && (lookup->bfd_section->flags & SEC_ALLOC) != 0) 1133 last_alloc = lookup; 1134 } 1135 1136 if (last_rel_alloc) 1137 return last_rel_alloc; 1138 1139 if (last_rel) 1140 return last_rel; 1141 1142 if (last_alloc) 1143 return last_alloc; 1144 1145 return last; 1146} 1147 1148/* Find the last output section before given output statement. 1149 Used by place_orphan. */ 1150 1151static asection * 1152output_prev_sec_find (lang_output_section_statement_type *os) 1153{ 1154 asection *s = (asection *) NULL; 1155 lang_statement_union_type *u; 1156 lang_output_section_statement_type *lookup; 1157 1158 for (u = lang_output_section_statement.head; 1159 u != (lang_statement_union_type *) NULL; 1160 u = lookup->next) 1161 { 1162 lookup = &u->output_section_statement; 1163 if (lookup == os) 1164 return s; 1165 1166 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL) 1167 s = lookup->bfd_section; 1168 } 1169 1170 return NULL; 1171} 1172 1173/* Place an orphan section. We use this to put random SHF_ALLOC 1174 sections in the right segment. */ 1175 1176struct orphan_save { 1177 lang_output_section_statement_type *os; 1178 asection **section; 1179 lang_statement_union_type **stmt; 1180 lang_statement_union_type **os_tail; 1181}; 1182 1183static bfd_boolean 1184gld${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s) 1185{ 1186 static struct orphan_save hold_text; 1187 static struct orphan_save hold_rodata; 1188 static struct orphan_save hold_data; 1189 static struct orphan_save hold_bss; 1190 static struct orphan_save hold_rel; 1191 static struct orphan_save hold_interp; 1192 static struct orphan_save hold_sdata; 1193 static int count = 1; 1194 struct orphan_save *place; 1195 lang_statement_list_type *old; 1196 lang_statement_list_type add; 1197 etree_type *address; 1198 const char *secname; 1199 const char *ps = NULL; 1200 lang_output_section_statement_type *os; 1201 lang_statement_union_type **os_tail; 1202 etree_type *load_base; 1203 int isdyn = 0; 1204 1205 secname = bfd_get_section_name (s->owner, s); 1206 if (! link_info.relocatable 1207 && link_info.combreloc 1208 && (s->flags & SEC_ALLOC) 1209 && strncmp (secname, ".rel", 4) == 0) 1210 { 1211 if (secname[4] == 'a') 1212 secname = ".rela.dyn"; 1213 else 1214 secname = ".rel.dyn"; 1215 isdyn = 1; 1216 } 1217 1218 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (secname))) 1219 { 1220 /* Look through the script to see where to place this section. */ 1221 os = lang_output_section_find (secname); 1222 1223 if (os != NULL 1224 && (os->bfd_section == NULL 1225 || ((s->flags ^ os->bfd_section->flags) 1226 & (SEC_LOAD | SEC_ALLOC)) == 0)) 1227 { 1228 /* We already have an output section statement with this 1229 name, and its bfd section, if any, has compatible flags. */ 1230 lang_add_section (&os->children, s, os, file); 1231 return TRUE; 1232 } 1233 } 1234 1235 if (hold_text.os == NULL) 1236 hold_text.os = lang_output_section_find (".text"); 1237 1238 /* If this is a final link, then always put .gnu.warning.SYMBOL 1239 sections into the .text section to get them out of the way. */ 1240 if (link_info.executable 1241 && ! link_info.relocatable 1242 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0 1243 && hold_text.os != NULL) 1244 { 1245 lang_add_section (&hold_text.os->children, s, hold_text.os, file); 1246 return TRUE; 1247 } 1248 1249 /* Decide which segment the section should go in based on the 1250 section name and section flags. We put loadable .note sections 1251 right after the .interp section, so that the PT_NOTE segment is 1252 stored right after the program headers where the OS can read it 1253 in the first page. */ 1254#define HAVE_SECTION(hold, name) \ 1255(hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL) 1256 1257 if ((s->flags & SEC_EXCLUDE) != 0 && !link_info.relocatable) 1258 { 1259 if (s->output_section == NULL) 1260 s->output_section = bfd_abs_section_ptr; 1261 return TRUE; 1262 } 1263 1264 place = NULL; 1265 if ((s->flags & SEC_ALLOC) == 0) 1266 ; 1267 else if ((s->flags & SEC_LOAD) != 0 1268 && strncmp (secname, ".note", 5) == 0 1269 && HAVE_SECTION (hold_interp, ".interp")) 1270 place = &hold_interp; 1271 else if ((s->flags & SEC_HAS_CONTENTS) == 0 1272 && HAVE_SECTION (hold_bss, ".bss")) 1273 place = &hold_bss; 1274 else if ((s->flags & SEC_SMALL_DATA) != 0 1275 && HAVE_SECTION (hold_sdata, ".sdata")) 1276 place = &hold_sdata; 1277 else if ((s->flags & SEC_READONLY) == 0 1278 && HAVE_SECTION (hold_data, ".data")) 1279 place = &hold_data; 1280 else if (strncmp (secname, ".rel", 4) == 0 1281 && (s->flags & SEC_LOAD) != 0 1282 && (hold_rel.os != NULL 1283 || (hold_rel.os = output_rel_find (s, isdyn)) != NULL)) 1284 place = &hold_rel; 1285 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == SEC_READONLY 1286 && HAVE_SECTION (hold_rodata, ".rodata")) 1287 place = &hold_rodata; 1288 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == (SEC_CODE | SEC_READONLY) 1289 && hold_text.os != NULL) 1290 place = &hold_text; 1291 1292#undef HAVE_SECTION 1293 1294 /* Choose a unique name for the section. This will be needed if the 1295 same section name appears in the input file with different 1296 loadable or allocatable characteristics. */ 1297 if (bfd_get_section_by_name (output_bfd, secname) != NULL) 1298 { 1299 secname = bfd_get_unique_section_name (output_bfd, secname, &count); 1300 if (secname == NULL) 1301 einfo ("%F%P: place_orphan failed: %E\n"); 1302 } 1303 1304 /* Start building a list of statements for this section. 1305 First save the current statement pointer. */ 1306 old = stat_ptr; 1307 1308 /* If we have found an appropriate place for the output section 1309 statements for this orphan, add them to our own private list, 1310 inserting them later into the global statement list. */ 1311 if (place != NULL) 1312 { 1313 stat_ptr = &add; 1314 lang_list_init (stat_ptr); 1315 } 1316 1317 if (config.build_constructors) 1318 { 1319 /* If the name of the section is representable in C, then create 1320 symbols to mark the start and the end of the section. */ 1321 for (ps = secname; *ps != '\0'; ps++) 1322 if (! ISALNUM (*ps) && *ps != '_') 1323 break; 1324 if (*ps == '\0') 1325 { 1326 char *symname; 1327 etree_type *e_align; 1328 1329 symname = (char *) xmalloc (ps - secname + sizeof "__start_"); 1330 sprintf (symname, "__start_%s", secname); 1331 e_align = exp_unop (ALIGN_K, 1332 exp_intop ((bfd_vma) 1 << s->alignment_power)); 1333 lang_add_assignment (exp_assop ('=', symname, e_align)); 1334 } 1335 } 1336 1337 address = NULL; 1338 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0) 1339 address = exp_intop ((bfd_vma) 0); 1340 1341 load_base = NULL; 1342 if (place != NULL && place->os->load_base != NULL) 1343 { 1344 etree_type *lma_from_vma; 1345 lma_from_vma = exp_binop ('-', place->os->load_base, 1346 exp_nameop (ADDR, place->os->name)); 1347 load_base = exp_binop ('+', lma_from_vma, 1348 exp_nameop (ADDR, secname)); 1349 } 1350 1351 os_tail = lang_output_section_statement.tail; 1352 os = lang_enter_output_section_statement (secname, address, 0, 1353 (etree_type *) NULL, 1354 (etree_type *) NULL, 1355 load_base); 1356 1357 lang_add_section (&os->children, s, os, file); 1358 1359 lang_leave_output_section_statement 1360 ((bfd_vma) 0, "*default*", 1361 (struct lang_output_section_phdr_list *) NULL, NULL); 1362 1363 if (config.build_constructors && *ps == '\0') 1364 { 1365 char *symname; 1366 1367 /* lang_leave_ouput_section_statement resets stat_ptr. Put 1368 stat_ptr back where we want it. */ 1369 if (place != NULL) 1370 stat_ptr = &add; 1371 1372 symname = (char *) xmalloc (ps - secname + sizeof "__stop_"); 1373 sprintf (symname, "__stop_%s", secname); 1374 lang_add_assignment (exp_assop ('=', symname, 1375 exp_nameop (NAME, "."))); 1376 } 1377 1378 /* Restore the global list pointer. */ 1379 stat_ptr = old; 1380 1381 if (place != NULL && os->bfd_section != NULL) 1382 { 1383 asection *snew, **pps; 1384 1385 snew = os->bfd_section; 1386 1387 /* Shuffle the bfd section list to make the output file look 1388 neater. This is really only cosmetic. */ 1389 if (place->section == NULL) 1390 { 1391 asection *bfd_section = place->os->bfd_section; 1392 1393 /* If the output statement hasn't been used to place 1394 any input sections (and thus doesn't have an output 1395 bfd_section), look for the closest prior output statement 1396 having an output section. */ 1397 if (bfd_section == NULL) 1398 bfd_section = output_prev_sec_find (place->os); 1399 1400 if (bfd_section != NULL && bfd_section != snew) 1401 place->section = &bfd_section->next; 1402 } 1403 1404 if (place->section != NULL) 1405 { 1406 /* Unlink the section. */ 1407 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next) 1408 ; 1409 bfd_section_list_remove (output_bfd, pps); 1410 1411 /* Now tack it on to the "place->os" section list. */ 1412 bfd_section_list_insert (output_bfd, place->section, snew); 1413 } 1414 1415 /* Save the end of this list. Further ophans of this type will 1416 follow the one we've just added. */ 1417 place->section = &snew->next; 1418 1419 /* The following is non-cosmetic. We try to put the output 1420 statements in some sort of reasonable order here, because 1421 they determine the final load addresses of the orphan 1422 sections. In addition, placing output statements in the 1423 wrong order may require extra segments. For instance, 1424 given a typical situation of all read-only sections placed 1425 in one segment and following that a segment containing all 1426 the read-write sections, we wouldn't want to place an orphan 1427 read/write section before or amongst the read-only ones. */ 1428 if (add.head != NULL) 1429 { 1430 lang_statement_union_type *newly_added_os; 1431 1432 if (place->stmt == NULL) 1433 { 1434 /* Put the new statement list right at the head. */ 1435 *add.tail = place->os->header.next; 1436 place->os->header.next = add.head; 1437 1438 place->os_tail = &place->os->next; 1439 } 1440 else 1441 { 1442 /* Put it after the last orphan statement we added. */ 1443 *add.tail = *place->stmt; 1444 *place->stmt = add.head; 1445 } 1446 1447 /* Fix the global list pointer if we happened to tack our 1448 new list at the tail. */ 1449 if (*old->tail == add.head) 1450 old->tail = add.tail; 1451 1452 /* Save the end of this list. */ 1453 place->stmt = add.tail; 1454 1455 /* Do the same for the list of output section statements. */ 1456 newly_added_os = *os_tail; 1457 *os_tail = NULL; 1458 newly_added_os->output_section_statement.next = *place->os_tail; 1459 *place->os_tail = newly_added_os; 1460 place->os_tail = &newly_added_os->output_section_statement.next; 1461 1462 /* Fixing the global list pointer here is a little different. 1463 We added to the list in lang_enter_output_section_statement, 1464 trimmed off the new output_section_statment above when 1465 assigning *os_tail = NULL, but possibly added it back in 1466 the same place when assigning *place->os_tail. */ 1467 if (*os_tail == NULL) 1468 lang_output_section_statement.tail = os_tail; 1469 } 1470 } 1471 1472 return TRUE; 1473} 1474EOF 1475fi 1476 1477if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then 1478cat >>e${EMULATION_NAME}.c <<EOF 1479 1480static void 1481gld${EMULATION_NAME}_finish (void) 1482{ 1483 if (bfd_elf_discard_info (output_bfd, &link_info)) 1484 { 1485 lang_reset_memory_regions (); 1486 1487 /* Resize the sections. */ 1488 lang_size_sections (stat_ptr->head, abs_output_section, 1489 &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE); 1490 1491 /* Redo special stuff. */ 1492 ldemul_after_allocation (); 1493 1494 /* Do the assignments again. */ 1495 lang_do_assignments (stat_ptr->head, abs_output_section, 1496 (fill_type *) 0, (bfd_vma) 0); 1497 } 1498} 1499EOF 1500fi 1501 1502if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then 1503cat >>e${EMULATION_NAME}.c <<EOF 1504 1505static char * 1506gld${EMULATION_NAME}_get_script (int *isfile) 1507EOF 1508 1509if test -n "$COMPILE_IN" 1510then 1511# Scripts compiled in. 1512 1513# sed commands to quote an ld script as a C string. 1514sc="-f stringify.sed" 1515 1516cat >>e${EMULATION_NAME}.c <<EOF 1517{ 1518 *isfile = 0; 1519 1520 if (link_info.relocatable && config.build_constructors) 1521 return 1522EOF 1523sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c 1524echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c 1525sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c 1526echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c 1527sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c 1528if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else 1529echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c 1530sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c 1531fi 1532if test -n "$GENERATE_PIE_SCRIPT" ; then 1533if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1534echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c 1535sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c 1536fi 1537echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c 1538sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c 1539fi 1540if test -n "$GENERATE_SHLIB_SCRIPT" ; then 1541if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1542echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c 1543sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c 1544fi 1545echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c 1546sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c 1547fi 1548if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1549echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c 1550sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c 1551fi 1552echo ' ; else return' >> e${EMULATION_NAME}.c 1553sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c 1554echo '; }' >> e${EMULATION_NAME}.c 1555 1556else 1557# Scripts read from the filesystem. 1558 1559cat >>e${EMULATION_NAME}.c <<EOF 1560{ 1561 *isfile = 1; 1562 1563 if (link_info.relocatable && config.build_constructors) 1564 return "ldscripts/${EMULATION_NAME}.xu"; 1565 else if (link_info.relocatable) 1566 return "ldscripts/${EMULATION_NAME}.xr"; 1567 else if (!config.text_read_only) 1568 return "ldscripts/${EMULATION_NAME}.xbn"; 1569EOF 1570if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : 1571else 1572cat >>e${EMULATION_NAME}.c <<EOF 1573 else if (!config.magic_demand_paged) 1574 return "ldscripts/${EMULATION_NAME}.xn"; 1575EOF 1576fi 1577if test -n "$GENERATE_PIE_SCRIPT" ; then 1578if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1579cat >>e${EMULATION_NAME}.c <<EOF 1580 else if (link_info.pie && link_info.combreloc) 1581 return "ldscripts/${EMULATION_NAME}.xdc"; 1582EOF 1583fi 1584cat >>e${EMULATION_NAME}.c <<EOF 1585 else if (link_info.pie) 1586 return "ldscripts/${EMULATION_NAME}.xd"; 1587EOF 1588fi 1589if test -n "$GENERATE_SHLIB_SCRIPT" ; then 1590if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1591cat >>e${EMULATION_NAME}.c <<EOF 1592 else if (link_info.shared && link_info.combreloc) 1593 return "ldscripts/${EMULATION_NAME}.xsc"; 1594EOF 1595fi 1596cat >>e${EMULATION_NAME}.c <<EOF 1597 else if (link_info.shared) 1598 return "ldscripts/${EMULATION_NAME}.xs"; 1599EOF 1600fi 1601if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1602cat >>e${EMULATION_NAME}.c <<EOF 1603 else if (link_info.combreloc) 1604 return "ldscripts/${EMULATION_NAME}.xc"; 1605EOF 1606fi 1607cat >>e${EMULATION_NAME}.c <<EOF 1608 else 1609 return "ldscripts/${EMULATION_NAME}.x"; 1610} 1611 1612EOF 1613fi 1614fi 1615 1616if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1617 1618if test -n "$PARSE_AND_LIST_PROLOGUE" ; then 1619cat >>e${EMULATION_NAME}.c <<EOF 1620 $PARSE_AND_LIST_PROLOGUE 1621EOF 1622fi 1623 1624cat >>e${EMULATION_NAME}.c <<EOF 1625 1626#define OPTION_DISABLE_NEW_DTAGS (400) 1627#define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1) 1628#define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1) 1629#define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1) 1630 1631static void 1632gld${EMULATION_NAME}_add_options 1633 (int ns, char **shortopts, int nl, struct option **longopts, 1634 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED) 1635{ 1636 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:"; 1637 static const struct option xtra_long[] = { 1638EOF 1639 1640if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1641cat >>e${EMULATION_NAME}.c <<EOF 1642 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS}, 1643 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS}, 1644 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR}, 1645 {"Bgroup", no_argument, NULL, OPTION_GROUP}, 1646EOF 1647fi 1648 1649if test -n "$PARSE_AND_LIST_LONGOPTS" ; then 1650cat >>e${EMULATION_NAME}.c <<EOF 1651 $PARSE_AND_LIST_LONGOPTS 1652EOF 1653fi 1654 1655cat >>e${EMULATION_NAME}.c <<EOF 1656 {NULL, no_argument, NULL, 0} 1657 }; 1658 1659 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short)); 1660 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short)); 1661 *longopts = (struct option *) 1662 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long)); 1663 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long)); 1664} 1665 1666static bfd_boolean 1667gld${EMULATION_NAME}_handle_option (int optc) 1668{ 1669 switch (optc) 1670 { 1671 default: 1672 return FALSE; 1673 1674EOF 1675 1676if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1677cat >>e${EMULATION_NAME}.c <<EOF 1678 case OPTION_DISABLE_NEW_DTAGS: 1679 link_info.new_dtags = FALSE; 1680 break; 1681 1682 case OPTION_ENABLE_NEW_DTAGS: 1683 link_info.new_dtags = TRUE; 1684 break; 1685 1686 case OPTION_EH_FRAME_HDR: 1687 link_info.eh_frame_hdr = TRUE; 1688 break; 1689 1690 case OPTION_GROUP: 1691 link_info.flags_1 |= (bfd_vma) DF_1_GROUP; 1692 /* Groups must be self-contained. */ 1693 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR; 1694 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR; 1695 break; 1696 1697 case 'z': 1698 if (strcmp (optarg, "initfirst") == 0) 1699 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST; 1700 else if (strcmp (optarg, "interpose") == 0) 1701 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE; 1702 else if (strcmp (optarg, "loadfltr") == 0) 1703 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR; 1704 else if (strcmp (optarg, "nodefaultlib") == 0) 1705 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB; 1706 else if (strcmp (optarg, "nodelete") == 0) 1707 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE; 1708 else if (strcmp (optarg, "nodlopen") == 0) 1709 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN; 1710 else if (strcmp (optarg, "nodump") == 0) 1711 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP; 1712 else if (strcmp (optarg, "now") == 0) 1713 { 1714 link_info.flags |= (bfd_vma) DF_BIND_NOW; 1715 link_info.flags_1 |= (bfd_vma) DF_1_NOW; 1716 } 1717 else if (strcmp (optarg, "origin") == 0) 1718 { 1719 link_info.flags |= (bfd_vma) DF_ORIGIN; 1720 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN; 1721 } 1722 else if (strcmp (optarg, "defs") == 0) 1723 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR; 1724 else if (strcmp (optarg, "muldefs") == 0) 1725 link_info.allow_multiple_definition = TRUE; 1726 else if (strcmp (optarg, "combreloc") == 0) 1727 link_info.combreloc = TRUE; 1728 else if (strcmp (optarg, "nocombreloc") == 0) 1729 link_info.combreloc = FALSE; 1730 else if (strcmp (optarg, "nocopyreloc") == 0) 1731 link_info.nocopyreloc = TRUE; 1732 else if (strcmp (optarg, "execstack") == 0) 1733 { 1734 link_info.execstack = TRUE; 1735 link_info.noexecstack = FALSE; 1736 } 1737 else if (strcmp (optarg, "noexecstack") == 0) 1738 { 1739 link_info.noexecstack = TRUE; 1740 link_info.execstack = FALSE; 1741 } 1742 /* What about the other Solaris -z options? FIXME. */ 1743 break; 1744EOF 1745fi 1746 1747if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then 1748cat >>e${EMULATION_NAME}.c <<EOF 1749 $PARSE_AND_LIST_ARGS_CASES 1750EOF 1751fi 1752 1753cat >>e${EMULATION_NAME}.c <<EOF 1754 } 1755 1756 return TRUE; 1757} 1758 1759EOF 1760 1761if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then 1762cat >>e${EMULATION_NAME}.c <<EOF 1763 1764static void 1765gld${EMULATION_NAME}_list_options (FILE * file) 1766{ 1767EOF 1768 1769if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1770cat >>e${EMULATION_NAME}.c <<EOF 1771 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n")); 1772 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n")); 1773 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n")); 1774 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n")); 1775 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n")); 1776 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n")); 1777 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n")); 1778 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n")); 1779 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n")); 1780 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n")); 1781 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n")); 1782 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n")); 1783 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n")); 1784 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n")); 1785 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n")); 1786 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n")); 1787 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n")); 1788 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n")); 1789 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n")); 1790 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n")); 1791 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n")); 1792EOF 1793fi 1794 1795if test -n "$PARSE_AND_LIST_OPTIONS" ; then 1796cat >>e${EMULATION_NAME}.c <<EOF 1797 $PARSE_AND_LIST_OPTIONS 1798EOF 1799fi 1800 1801cat >>e${EMULATION_NAME}.c <<EOF 1802} 1803EOF 1804 1805if test -n "$PARSE_AND_LIST_EPILOGUE" ; then 1806cat >>e${EMULATION_NAME}.c <<EOF 1807 $PARSE_AND_LIST_EPILOGUE 1808EOF 1809fi 1810fi 1811else 1812cat >>e${EMULATION_NAME}.c <<EOF 1813#define gld${EMULATION_NAME}_add_options NULL 1814#define gld${EMULATION_NAME}_handle_option NULL 1815EOF 1816if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then 1817cat >>e${EMULATION_NAME}.c <<EOF 1818#define gld${EMULATION_NAME}_list_options NULL 1819EOF 1820fi 1821fi 1822 1823cat >>e${EMULATION_NAME}.c <<EOF 1824 1825struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = 1826{ 1827 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse}, 1828 ${LDEMUL_SYSLIB-syslib_default}, 1829 ${LDEMUL_HLL-hll_default}, 1830 ${LDEMUL_AFTER_PARSE-after_parse_default}, 1831 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open}, 1832 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default}, 1833 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default}, 1834 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target}, 1835 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation}, 1836 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script}, 1837 "${EMULATION_NAME}", 1838 "${OUTPUT_FORMAT}", 1839 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish}, 1840 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL}, 1841 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive}, 1842 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan}, 1843 ${LDEMUL_SET_SYMBOLS-NULL}, 1844 ${LDEMUL_PARSE_ARGS-NULL}, 1845 gld${EMULATION_NAME}_add_options, 1846 gld${EMULATION_NAME}_handle_option, 1847 ${LDEMUL_UNRECOGNIZED_FILE-NULL}, 1848 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options}, 1849 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols}, 1850 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL}, 1851 ${LDEMUL_NEW_VERS_PATTERN-NULL} 1852}; 1853EOF 1854