1 /* ELF emulation code for targets using elf.em.
2 Copyright (C) 1991-2019 Free Software Foundation, Inc.
4 This file is part of the GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
23 #include "libiberty.h"
24 #include "filenames.h"
25 #include "safe-ctype.h"
34 #include "ldbuildid.h"
48 /* Style of .note.gnu.build-id section. */
49 const char *ldelf_emit_note_gnu_build_id
;
51 /* These variables are required to pass information back and forth
52 between after_open and check_needed and stat_needed and vercheck. */
54 static struct bfd_link_needed_list
*global_needed
;
55 static lang_input_statement_type
*global_found
;
56 static struct stat global_stat
;
57 static struct bfd_link_needed_list
*global_vercheck_needed
;
58 static bfd_boolean global_vercheck_failed
;
61 ldelf_after_parse (void)
63 if (bfd_link_pie (&link_info
))
64 link_info
.flags_1
|= (bfd_vma
) DF_1_PIE
;
66 if (bfd_link_executable (&link_info
)
67 && link_info
.nointerp
)
69 if (link_info
.dynamic_undefined_weak
> 0)
70 einfo (_("%P: warning: -z dynamic-undefined-weak ignored\n"));
71 link_info
.dynamic_undefined_weak
= 0;
73 after_parse_default ();
76 /* Handle the generation of DT_NEEDED tags. */
79 ldelf_load_symbols (lang_input_statement_type
*entry
)
83 /* Tell the ELF linker that we don't want the output file to have a
84 DT_NEEDED entry for this file, unless it is used to resolve
85 references in a regular object. */
86 if (entry
->flags
.add_DT_NEEDED_for_regular
)
87 link_class
= DYN_AS_NEEDED
;
89 /* Tell the ELF linker that we don't want the output file to have a
90 DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
92 if (!entry
->flags
.add_DT_NEEDED_for_dynamic
)
93 link_class
|= DYN_NO_ADD_NEEDED
;
95 if (entry
->flags
.just_syms
96 && (bfd_get_file_flags (entry
->the_bfd
) & DYNAMIC
) != 0)
97 einfo (_("%F%P: %pB: --just-symbols may not be used on DSO\n"),
101 || (bfd_get_file_flags (entry
->the_bfd
) & DYNAMIC
) == 0)
104 bfd_elf_set_dyn_lib_class (entry
->the_bfd
,
105 (enum dynamic_lib_link_class
) link_class
);
107 /* Continue on with normal load_symbols processing. */
111 /* On Linux, it's possible to have different versions of the same
112 shared library linked against different versions of libc. The
113 dynamic linker somehow tags which libc version to use in
114 /etc/ld.so.cache, and, based on the libc that it sees in the
115 executable, chooses which version of the shared library to use.
117 We try to do a similar check here by checking whether this shared
118 library needs any other shared libraries which may conflict with
119 libraries we have already included in the link. If it does, we
120 skip it, and try to find another shared library farther on down the
123 This is called via lang_for_each_input_file.
124 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
125 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
126 a conflicting version. */
129 ldelf_vercheck (lang_input_statement_type
*s
)
132 struct bfd_link_needed_list
*l
;
134 if (global_vercheck_failed
)
136 if (s
->the_bfd
== NULL
137 || (bfd_get_file_flags (s
->the_bfd
) & DYNAMIC
) == 0)
140 soname
= bfd_elf_get_dt_soname (s
->the_bfd
);
142 soname
= lbasename (bfd_get_filename (s
->the_bfd
));
144 for (l
= global_vercheck_needed
; l
!= NULL
; l
= l
->next
)
148 if (filename_cmp (soname
, l
->name
) == 0)
150 /* Probably can't happen, but it's an easy check. */
154 if (strchr (l
->name
, '/') != NULL
)
157 suffix
= strstr (l
->name
, ".so.");
161 suffix
+= sizeof ".so." - 1;
163 if (filename_ncmp (soname
, l
->name
, suffix
- l
->name
) == 0)
165 /* Here we know that S is a dynamic object FOO.SO.VER1, and
166 the object we are considering needs a dynamic object
167 FOO.SO.VER2, and VER1 and VER2 are different. This
168 appears to be a version mismatch, so we tell the caller
169 to try a different version of this library. */
170 global_vercheck_failed
= TRUE
;
177 /* See if an input file matches a DT_NEEDED entry by running stat on
181 ldelf_stat_needed (lang_input_statement_type
*s
)
187 if (global_found
!= NULL
)
189 if (s
->the_bfd
== NULL
)
192 /* If this input file was an as-needed entry, and wasn't found to be
193 needed at the stage it was linked, then don't say we have loaded it. */
194 if ((bfd_elf_get_dyn_lib_class (s
->the_bfd
) & DYN_AS_NEEDED
) != 0)
197 if (bfd_stat (s
->the_bfd
, &st
) != 0)
199 einfo (_("%P: %pB: bfd_stat failed: %E\n"), s
->the_bfd
);
203 /* Some operating systems, e.g. Windows, do not provide a meaningful
204 st_ino; they always set it to zero. (Windows does provide a
205 meaningful st_dev.) Do not indicate a duplicate library in that
206 case. While there is no guarantee that a system that provides
207 meaningful inode numbers will never set st_ino to zero, this is
208 merely an optimization, so we do not need to worry about false
210 if (st
.st_dev
== global_stat
.st_dev
211 && st
.st_ino
== global_stat
.st_ino
218 /* We issue a warning if it looks like we are including two
219 different versions of the same shared library. For example,
220 there may be a problem if -lc picks up libc.so.6 but some other
221 shared library has a DT_NEEDED entry of libc.so.5. This is a
222 heuristic test, and it will only work if the name looks like
223 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
224 If we really want to issue warnings about mixing version numbers
225 of shared libraries, we need to find a better way. */
227 if (strchr (global_needed
->name
, '/') != NULL
)
229 suffix
= strstr (global_needed
->name
, ".so.");
232 suffix
+= sizeof ".so." - 1;
234 soname
= bfd_elf_get_dt_soname (s
->the_bfd
);
236 soname
= lbasename (s
->filename
);
238 if (filename_ncmp (soname
, global_needed
->name
,
239 suffix
- global_needed
->name
) == 0)
240 einfo (_("%P: warning: %s, needed by %pB, may conflict with %s\n"),
241 global_needed
->name
, global_needed
->by
, soname
);
244 /* This function is called for each possible name for a dynamic object
245 named by a DT_NEEDED entry. The FORCE parameter indicates whether
246 to skip the check for a conflicting version. */
249 ldelf_try_needed (struct dt_needed
*needed
, int force
, int is_linux
)
252 const char *name
= needed
->name
;
256 abfd
= bfd_openr (name
, bfd_get_target (link_info
.output_bfd
));
260 info_msg (_("attempt to open %s failed\n"), name
);
264 /* Linker needs to decompress sections. */
265 abfd
->flags
|= BFD_DECOMPRESS
;
267 if (! bfd_check_format (abfd
, bfd_object
))
272 if ((bfd_get_file_flags (abfd
) & DYNAMIC
) == 0)
278 /* For DT_NEEDED, they have to match. */
279 if (abfd
->xvec
!= link_info
.output_bfd
->xvec
)
285 /* Check whether this object would include any conflicting library
286 versions. If FORCE is set, then we skip this check; we use this
287 the second time around, if we couldn't find any compatible
288 instance of the shared library. */
292 struct bfd_link_needed_list
*needs
;
294 if (! bfd_elf_get_bfd_needed_list (abfd
, &needs
))
295 einfo (_("%F%P: %pB: bfd_elf_get_bfd_needed_list failed: %E\n"), abfd
);
299 global_vercheck_needed
= needs
;
300 global_vercheck_failed
= FALSE
;
301 lang_for_each_input_file (ldelf_vercheck
);
302 if (global_vercheck_failed
)
305 /* Return FALSE to force the caller to move on to try
306 another file on the search path. */
310 /* But wait! It gets much worse. On Linux, if a shared
311 library does not use libc at all, we are supposed to skip
312 it the first time around in case we encounter a shared
313 library later on with the same name which does use the
314 version of libc that we want. This is much too horrible
315 to use on any system other than Linux. */
318 struct bfd_link_needed_list
*l
;
320 for (l
= needs
; l
!= NULL
; l
= l
->next
)
321 if (CONST_STRNEQ (l
->name
, "libc.so"))
332 /* We've found a dynamic object matching the DT_NEEDED entry. */
334 /* We have already checked that there is no other input file of the
335 same name. We must now check again that we are not including the
336 same file twice. We need to do this because on many systems
337 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
338 reference libc.so.1. If we have already included libc.so, we
339 don't want to include libc.so.1 if they are the same file, and we
340 can only check that using stat. */
342 if (bfd_stat (abfd
, &global_stat
) != 0)
343 einfo (_("%F%P: %pB: bfd_stat failed: %E\n"), abfd
);
345 /* First strip off everything before the last '/'. */
346 soname
= lbasename (bfd_get_filename (abfd
));
349 info_msg (_("found %s at %s\n"), soname
, name
);
352 lang_for_each_input_file (ldelf_stat_needed
);
353 if (global_found
!= NULL
)
355 /* Return TRUE to indicate that we found the file, even though
356 we aren't going to do anything with it. */
360 /* Specify the soname to use. */
361 bfd_elf_set_dt_needed_name (abfd
, soname
);
363 /* Tell the ELF linker that we don't want the output file to have a
364 DT_NEEDED entry for this file, unless it is used to resolve
365 references in a regular object. */
366 link_class
= DYN_DT_NEEDED
;
368 /* Tell the ELF linker that we don't want the output file to have a
369 DT_NEEDED entry for this file at all if the entry is from a file
370 with DYN_NO_ADD_NEEDED. */
371 if (needed
->by
!= NULL
372 && (bfd_elf_get_dyn_lib_class (needed
->by
) & DYN_NO_ADD_NEEDED
) != 0)
373 link_class
|= DYN_NO_NEEDED
| DYN_NO_ADD_NEEDED
;
375 bfd_elf_set_dyn_lib_class (abfd
, (enum dynamic_lib_link_class
) link_class
);
377 /* Add this file into the symbol table. */
378 if (! bfd_link_add_symbols (abfd
, &link_info
))
379 einfo (_("%F%P: %pB: error adding symbols: %E\n"), abfd
);
384 /* Search for a needed file in a path. */
387 ldelf_search_needed (const char *path
, struct dt_needed
*n
, int force
,
388 int is_linux
, int elfsize
)
391 const char *name
= n
->name
;
393 struct dt_needed needed
;
396 return ldelf_try_needed (n
, force
, is_linux
);
398 if (path
== NULL
|| *path
== '\0')
402 needed
.name
= n
->name
;
409 char *filename
, *sset
;
411 s
= strchr (path
, config
.rpath_separator
);
413 s
= path
+ strlen (path
);
415 #if HAVE_DOS_BASED_FILE_SYSTEM
416 /* Assume a match on the second char is part of drive specifier. */
417 else if (config
.rpath_separator
== ':'
421 s
= strchr (s
+ 1, config
.rpath_separator
);
423 s
= path
+ strlen (path
);
426 filename
= (char *) xmalloc (s
- path
+ len
+ 2);
431 memcpy (filename
, path
, s
- path
);
432 filename
[s
- path
] = '/';
433 sset
= filename
+ (s
- path
) + 1;
437 /* PR 20535: Support the same pseudo-environment variables that
438 are supported by ld.so. Namely, $ORIGIN, $LIB and $PLATFORM.
439 Since there can be more than one occurrence of these tokens in
440 the path we loop until no more are found. Since we might not
441 be able to substitute some of the tokens we maintain an offset
442 into the filename for where we should begin our scan. */
443 while ((var
= strchr (filename
+ offset
, '$')) != NULL
)
445 /* The ld.so manual page does not say, but I am going to assume that
446 these tokens are terminated by a directory separator character
447 (/) or the end of the string. There is also an implication that
448 $ORIGIN should only be used at the start of a path, but that is
451 The ld.so manual page also states that it allows ${ORIGIN},
452 ${LIB} and ${PLATFORM}, so these are supported as well.
454 FIXME: The code could be a lot cleverer about allocating space
455 for the processed string. */
456 char * end
= strchr (var
, '/');
457 const char *replacement
= NULL
;
459 char * freeme
= NULL
;
460 unsigned flen
= strlen (filename
);
463 /* Temporarily terminate the filename at the end of the token. */
471 if (strcmp (v
, "RIGIN") == 0 || strcmp (v
, "RIGIN}") == 0)
473 /* ORIGIN - replace with the full path to the directory
474 containing the program or shared object. */
475 if (needed
.by
== NULL
)
477 if (link_info
.output_bfd
== NULL
)
482 replacement
= bfd_get_filename (link_info
.output_bfd
);
485 replacement
= bfd_get_filename (needed
.by
);
491 if (replacement
[0] == '/')
492 freeme
= xstrdup (replacement
);
495 char * current_dir
= getpwd ();
497 freeme
= xmalloc (strlen (replacement
)
498 + strlen (current_dir
) + 2);
499 sprintf (freeme
, "%s/%s", current_dir
, replacement
);
502 replacement
= freeme
;
503 if ((slash
= strrchr (replacement
, '/')) != NULL
)
510 if (strcmp (v
, "IB") == 0 || strcmp (v
, "IB}") == 0)
512 /* LIB - replace with "lib" in 32-bit environments
513 and "lib64" in 64-bit environments. */
517 case 32: replacement
= "lib"; break;
518 case 64: replacement
= "lib64"; break;
526 /* Supporting $PLATFORM in a cross-hosted environment is not
527 possible. Supporting it in a native environment involves
528 loading the <sys/auxv.h> header file which loads the
529 system <elf.h> header file, which conflicts with the
530 "include/elf/mips.h" header file. */
538 char * filename2
= xmalloc (flen
+ strlen (replacement
));
542 sprintf (filename2
, "%.*s%s/%s",
543 (int)(var
- filename
), filename
,
544 replacement
, end
+ 1);
545 offset
= (var
- filename
) + 1 + strlen (replacement
);
549 sprintf (filename2
, "%.*s%s",
550 (int)(var
- filename
), filename
,
552 offset
= var
- filename
+ strlen (replacement
);
556 filename
= filename2
;
557 /* There is no need to restore the path separator (when
558 end != NULL) as we have replaced the entire string. */
563 /* We only issue an "unrecognised" message in verbose mode
564 as the $<foo> token might be a legitimate component of
565 a path name in the target's file system. */
566 info_msg (_("unrecognised or unsupported token "
567 "'%s' in search path\n"), var
);
569 /* Restore the path separator. */
572 /* PR 20784: Make sure that we resume the scan *after*
573 the token that we could not replace. */
574 offset
= (var
+ 1) - filename
;
580 needed
.name
= filename
;
582 if (ldelf_try_needed (&needed
, force
, is_linux
))
595 /* Prefix the sysroot to absolute paths in PATH, a string containing
596 paths separated by config.rpath_separator. If running on a DOS
597 file system, paths containing a drive spec won't have the sysroot
598 prefix added, unless the sysroot also specifies the same drive. */
601 ldelf_add_sysroot (const char *path
)
606 int dos_drive_sysroot
= HAS_DRIVE_SPEC (ld_sysroot
);
608 len
= strlen (ld_sysroot
);
609 for (extra
= 0, p
= path
; ; )
611 int dos_drive
= HAS_DRIVE_SPEC (p
);
615 if (IS_DIR_SEPARATOR (*p
)
617 || (dos_drive_sysroot
618 && ld_sysroot
[0] == p
[-2])))
620 if (dos_drive
&& dos_drive_sysroot
)
625 p
= strchr (p
, config
.rpath_separator
);
631 ret
= xmalloc (strlen (path
) + extra
+ 1);
633 for (q
= ret
, p
= path
; ; )
636 int dos_drive
= HAS_DRIVE_SPEC (p
);
643 if (IS_DIR_SEPARATOR (*p
)
645 || (dos_drive_sysroot
646 && ld_sysroot
[0] == p
[-2])))
648 if (dos_drive
&& dos_drive_sysroot
)
650 strcpy (q
, ld_sysroot
+ 2);
655 strcpy (q
, ld_sysroot
);
659 end
= strchr (p
, config
.rpath_separator
);
662 size_t n
= end
- p
+ 1;
677 /* Read the system search path the FreeBSD way rather than the Linux way. */
678 #ifdef HAVE_ELF_HINTS_H
679 #include <elf-hints.h>
681 #include "elf-hints-local.h"
685 ldelf_check_ld_elf_hints (const struct bfd_link_needed_list
*l
, int force
,
688 static bfd_boolean initialized
;
689 static const char *ld_elf_hints
;
690 struct dt_needed needed
;
697 tmppath
= concat (ld_sysroot
, _PATH_ELF_HINTS
, (const char *) NULL
);
698 f
= fopen (tmppath
, FOPEN_RB
);
702 struct elfhints_hdr hdr
;
704 if (fread (&hdr
, 1, sizeof (hdr
), f
) == sizeof (hdr
)
705 && hdr
.magic
== ELFHINTS_MAGIC
708 if (fseek (f
, hdr
.strtab
+ hdr
.dirlist
, SEEK_SET
) != -1)
712 b
= xmalloc (hdr
.dirlistlen
+ 1);
713 if (fread (b
, 1, hdr
.dirlistlen
+ 1, f
) ==
715 ld_elf_hints
= ldelf_add_sysroot (b
);
726 if (ld_elf_hints
== NULL
)
730 needed
.name
= l
->name
;
731 return ldelf_search_needed (ld_elf_hints
, &needed
, force
, FALSE
, elfsize
);
734 /* For a native linker, check the file /etc/ld.so.conf for directories
735 in which we may find shared libraries. /etc/ld.so.conf is really
736 only meaningful on Linux. */
738 struct ldelf_ld_so_conf
745 ldelf_parse_ld_so_conf (struct ldelf_ld_so_conf
*, const char *);
748 ldelf_parse_ld_so_conf_include (struct ldelf_ld_so_conf
*info
,
749 const char *filename
,
757 if (pattern
[0] != '/')
759 char *p
= strrchr (filename
, '/');
760 size_t patlen
= strlen (pattern
) + 1;
762 newp
= xmalloc (p
- filename
+ 1 + patlen
);
763 memcpy (newp
, filename
, p
- filename
+ 1);
764 memcpy (newp
+ (p
- filename
+ 1), pattern
, patlen
);
769 if (glob (pattern
, 0, NULL
, &gl
) == 0)
773 for (i
= 0; i
< gl
.gl_pathc
; ++i
)
774 ldelf_parse_ld_so_conf (info
, gl
.gl_pathv
[i
]);
778 /* If we do not have glob, treat the pattern as a literal filename. */
779 ldelf_parse_ld_so_conf (info
, pattern
);
787 ldelf_parse_ld_so_conf (struct ldelf_ld_so_conf
*info
, const char *filename
)
789 FILE *f
= fopen (filename
, FOPEN_RT
);
797 line
= xmalloc (linelen
);
802 /* Normally this would use getline(3), but we need to be portable. */
803 while ((q
= fgets (p
, linelen
- (p
- line
), f
)) != NULL
804 && strlen (q
) == linelen
- (p
- line
) - 1
805 && line
[linelen
- 2] != '\n')
807 line
= xrealloc (line
, 2 * linelen
);
808 p
= line
+ linelen
- 1;
812 if (q
== NULL
&& p
== line
)
815 p
= strchr (line
, '\n');
819 /* Because the file format does not know any form of quoting we
820 can search forward for the next '#' character and if found
821 make it terminating the line. */
822 p
= strchr (line
, '#');
826 /* Remove leading whitespace. NUL is no whitespace character. */
828 while (*p
== ' ' || *p
== '\f' || *p
== '\r' || *p
== '\t' || *p
== '\v')
831 /* If the line is blank it is ignored. */
835 if (CONST_STRNEQ (p
, "include") && (p
[7] == ' ' || p
[7] == '\t'))
841 while (*p
== ' ' || *p
== '\t')
849 while (*p
!= ' ' && *p
!= '\t' && *p
)
855 ldelf_parse_ld_so_conf_include (info
, filename
, dir
);
862 while (*p
&& *p
!= '=' && *p
!= ' ' && *p
!= '\t' && *p
!= '\f'
863 && *p
!= '\r' && *p
!= '\v')
866 while (p
!= dir
&& p
[-1] == '/')
868 if (info
->path
== NULL
)
870 info
->alloc
= p
- dir
+ 1 + 256;
871 info
->path
= xmalloc (info
->alloc
);
876 if (info
->len
+ 1 + (p
- dir
) >= info
->alloc
)
878 info
->alloc
+= p
- dir
+ 256;
879 info
->path
= xrealloc (info
->path
, info
->alloc
);
881 info
->path
[info
->len
++] = config
.rpath_separator
;
883 memcpy (info
->path
+ info
->len
, dir
, p
- dir
);
884 info
->len
+= p
- dir
;
885 info
->path
[info
->len
] = '\0';
895 ldelf_check_ld_so_conf (const struct bfd_link_needed_list
*l
, int force
,
898 static bfd_boolean initialized
;
899 static const char *ld_so_conf
;
900 struct dt_needed needed
;
905 struct ldelf_ld_so_conf info
;
908 info
.len
= info
.alloc
= 0;
909 tmppath
= concat (ld_sysroot
, "${prefix}/etc/ld.so.conf",
910 (const char *) NULL
);
911 if (!ldelf_parse_ld_so_conf (&info
, tmppath
))
914 tmppath
= concat (ld_sysroot
, "/etc/ld.so.conf",
915 (const char *) NULL
);
916 ldelf_parse_ld_so_conf (&info
, tmppath
);
922 ld_so_conf
= ldelf_add_sysroot (info
.path
);
928 if (ld_so_conf
== NULL
)
933 needed
.name
= l
->name
;
934 return ldelf_search_needed (ld_so_conf
, &needed
, force
, TRUE
, elfsize
);
937 /* See if an input file matches a DT_NEEDED entry by name. */
940 ldelf_check_needed (lang_input_statement_type
*s
)
944 /* Stop looking if we've found a loaded lib. */
945 if (global_found
!= NULL
946 && (bfd_elf_get_dyn_lib_class (global_found
->the_bfd
)
947 & DYN_AS_NEEDED
) == 0)
950 if (s
->filename
== NULL
|| s
->the_bfd
== NULL
)
953 /* Don't look for a second non-loaded as-needed lib. */
954 if (global_found
!= NULL
955 && (bfd_elf_get_dyn_lib_class (s
->the_bfd
) & DYN_AS_NEEDED
) != 0)
958 if (filename_cmp (s
->filename
, global_needed
->name
) == 0)
964 if (s
->flags
.search_dirs
)
966 const char *f
= strrchr (s
->filename
, '/');
968 && filename_cmp (f
+ 1, global_needed
->name
) == 0)
975 soname
= bfd_elf_get_dt_soname (s
->the_bfd
);
977 && filename_cmp (soname
, global_needed
->name
) == 0)
984 /* This is called after all the input files have been opened. */
987 ldelf_after_open (int use_libpath
, int native
, int is_linux
, int is_freebsd
,
990 struct bfd_link_needed_list
*needed
, *l
;
991 struct elf_link_hash_table
*htab
;
995 after_open_default ();
997 htab
= elf_hash_table (&link_info
);
998 if (!is_elf_hash_table (htab
))
1001 if (command_line
.out_implib_filename
)
1003 unlink_if_ordinary (command_line
.out_implib_filename
);
1004 link_info
.out_implib_bfd
1005 = bfd_openw (command_line
.out_implib_filename
,
1006 bfd_get_target (link_info
.output_bfd
));
1008 if (link_info
.out_implib_bfd
== NULL
)
1010 einfo (_("%F%P: %s: can't open for writing: %E\n"),
1011 command_line
.out_implib_filename
);
1015 if (ldelf_emit_note_gnu_build_id
!= NULL
)
1017 /* Find an ELF input. */
1018 for (abfd
= link_info
.input_bfds
;
1019 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
1020 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1021 && bfd_count_sections (abfd
) != 0
1022 && !bfd_input_just_syms (abfd
))
1025 /* PR 10555: If there are no ELF input files do not try to
1026 create a .note.gnu-build-id section. */
1028 || !ldelf_setup_build_id (abfd
))
1030 free ((char *) ldelf_emit_note_gnu_build_id
);
1031 ldelf_emit_note_gnu_build_id
= NULL
;
1035 get_elf_backend_data (link_info
.output_bfd
)->setup_gnu_properties (&link_info
);
1037 if (bfd_link_relocatable (&link_info
))
1039 if (link_info
.execstack
== !link_info
.noexecstack
)
1041 /* PR ld/16744: If "-z [no]execstack" has been specified on the
1042 command line and we are perfoming a relocatable link then no
1043 PT_GNU_STACK segment will be created and so the
1044 linkinfo.[no]execstack values set in _handle_option() will have no
1045 effect. Instead we create a .note.GNU-stack section in much the
1046 same way as the assembler does with its --[no]execstack option. */
1047 flagword flags
= SEC_READONLY
| (link_info
.execstack
? SEC_CODE
: 0);
1048 (void) bfd_make_section_with_flags (link_info
.input_bfds
,
1049 ".note.GNU-stack", flags
);
1054 if (!link_info
.traditional_format
)
1057 bfd_boolean warn_eh_frame
= FALSE
;
1060 for (abfd
= link_info
.input_bfds
; abfd
; abfd
= abfd
->link
.next
)
1064 if (bfd_input_just_syms (abfd
))
1067 for (s
= abfd
->sections
; s
&& type
< COMPACT_EH_HDR
; s
= s
->next
)
1069 const char *name
= bfd_section_name (s
);
1071 if (bfd_is_abs_section (s
->output_section
))
1073 if (CONST_STRNEQ (name
, ".eh_frame_entry"))
1074 type
= COMPACT_EH_HDR
;
1075 else if (strcmp (name
, ".eh_frame") == 0 && s
->size
> 8)
1076 type
= DWARF2_EH_HDR
;
1085 else if (seen_type
!= type
)
1087 einfo (_("%F%P: compact frame descriptions incompatible with"
1088 " DWARF2 .eh_frame from %pB\n"),
1089 type
== DWARF2_EH_HDR
? abfd
: elfbfd
);
1094 && (type
== COMPACT_EH_HDR
1095 || link_info
.eh_frame_hdr_type
!= 0))
1097 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
1100 warn_eh_frame
= TRUE
;
1104 if (seen_type
== COMPACT_EH_HDR
)
1105 link_info
.eh_frame_hdr_type
= COMPACT_EH_HDR
;
1109 const struct elf_backend_data
*bed
;
1111 bed
= get_elf_backend_data (elfbfd
);
1112 s
= bfd_make_section_with_flags (elfbfd
, ".eh_frame_hdr",
1113 bed
->dynamic_sec_flags
1116 && bfd_set_section_alignment (s
, 2))
1118 htab
->eh_info
.hdr_sec
= s
;
1119 warn_eh_frame
= FALSE
;
1123 einfo (_("%P: warning: cannot create .eh_frame_hdr section,"
1124 " --eh-frame-hdr ignored\n"));
1127 /* Get the list of files which appear in DT_NEEDED entries in
1128 dynamic objects included in the link (often there will be none).
1129 For each such file, we want to track down the corresponding
1130 library, and include the symbol table in the link. This is what
1131 the runtime dynamic linker will do. Tracking the files down here
1132 permits one dynamic object to include another without requiring
1133 special action by the person doing the link. Note that the
1134 needed list can actually grow while we are stepping through this
1136 needed
= bfd_elf_get_needed_list (link_info
.output_bfd
, &link_info
);
1137 for (l
= needed
; l
!= NULL
; l
= l
->next
)
1139 struct bfd_link_needed_list
*ll
;
1140 struct dt_needed n
, nn
;
1143 /* If the lib that needs this one was --as-needed and wasn't
1144 found to be needed, then this lib isn't needed either. */
1146 && (bfd_elf_get_dyn_lib_class (l
->by
) & DYN_AS_NEEDED
) != 0)
1149 /* Skip the lib if --no-copy-dt-needed-entries and
1150 --allow-shlib-undefined is in effect. */
1152 && link_info
.unresolved_syms_in_shared_libs
== RM_IGNORE
1153 && (bfd_elf_get_dyn_lib_class (l
->by
) & DYN_NO_ADD_NEEDED
) != 0)
1156 /* If we've already seen this file, skip it. */
1157 for (ll
= needed
; ll
!= l
; ll
= ll
->next
)
1159 || (bfd_elf_get_dyn_lib_class (ll
->by
) & DYN_AS_NEEDED
) == 0)
1160 && strcmp (ll
->name
, l
->name
) == 0)
1165 /* See if this file was included in the link explicitly. */
1167 global_found
= NULL
;
1168 lang_for_each_input_file (ldelf_check_needed
);
1169 if (global_found
!= NULL
1170 && (bfd_elf_get_dyn_lib_class (global_found
->the_bfd
)
1171 & DYN_AS_NEEDED
) == 0)
1178 info_msg (_("%s needed by %pB\n"), l
->name
, l
->by
);
1180 /* As-needed libs specified on the command line (or linker script)
1181 take priority over libs found in search dirs. */
1182 if (global_found
!= NULL
)
1184 nn
.name
= global_found
->filename
;
1185 if (ldelf_try_needed (&nn
, TRUE
, is_linux
))
1189 /* We need to find this file and include the symbol table. We
1190 want to search for the file in the same way that the dynamic
1191 linker will search. That means that we want to use
1192 rpath_link, rpath, then the environment variable
1193 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
1194 entries (native only), then the linker script LIB_SEARCH_DIRS.
1195 We do not search using the -L arguments.
1197 We search twice. The first time, we skip objects which may
1198 introduce version mismatches. The second time, we force
1199 their use. See ldelf_vercheck comment. */
1200 for (force
= 0; force
< 2; force
++)
1203 search_dirs_type
*search
;
1205 struct bfd_link_needed_list
*rp
;
1208 if (ldelf_search_needed (command_line
.rpath_link
, &n
, force
,
1214 path
= command_line
.rpath
;
1217 path
= ldelf_add_sysroot (path
);
1218 found
= ldelf_search_needed (path
, &n
, force
,
1220 free ((char *) path
);
1227 if (command_line
.rpath_link
== NULL
1228 && command_line
.rpath
== NULL
)
1230 path
= (const char *) getenv ("LD_RUN_PATH");
1232 && ldelf_search_needed (path
, &n
, force
,
1236 path
= (const char *) getenv ("LD_LIBRARY_PATH");
1238 && ldelf_search_needed (path
, &n
, force
,
1245 rp
= bfd_elf_get_runpath_list (link_info
.output_bfd
, &link_info
);
1246 for (; !found
&& rp
!= NULL
; rp
= rp
->next
)
1248 path
= ldelf_add_sysroot (rp
->name
);
1249 found
= (rp
->by
== l
->by
1250 && ldelf_search_needed (path
, &n
, force
,
1251 is_linux
, elfsize
));
1252 free ((char *) path
);
1258 && ldelf_check_ld_elf_hints (l
, force
, elfsize
))
1262 && ldelf_check_ld_so_conf (l
, force
, elfsize
))
1266 len
= strlen (l
->name
);
1267 for (search
= search_head
; search
!= NULL
; search
= search
->next
)
1271 if (search
->cmdline
)
1273 filename
= (char *) xmalloc (strlen (search
->name
) + len
+ 2);
1274 sprintf (filename
, "%s/%s", search
->name
, l
->name
);
1276 if (ldelf_try_needed (&nn
, force
, is_linux
))
1287 einfo (_("%P: warning: %s, needed by %pB, not found "
1288 "(try using -rpath or -rpath-link)\n"),
1292 if (link_info
.eh_frame_hdr_type
== COMPACT_EH_HDR
)
1293 if (!bfd_elf_parse_eh_frame_entries (NULL
, &link_info
))
1294 einfo (_("%F%P: failed to parse EH frame entries\n"));
1297 static bfd_size_type
1298 id_note_section_size (bfd
*abfd ATTRIBUTE_UNUSED
)
1300 const char *style
= ldelf_emit_note_gnu_build_id
;
1302 bfd_size_type build_id_size
;
1304 size
= offsetof (Elf_External_Note
, name
[sizeof "GNU"]);
1305 size
= (size
+ 3) & -(bfd_size_type
) 4;
1307 build_id_size
= compute_build_id_size (style
);
1309 size
+= build_id_size
;
1317 write_build_id (bfd
*abfd
)
1319 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1320 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1323 Elf_Internal_Shdr
*i_shdr
;
1324 unsigned char *contents
, *id_bits
;
1327 Elf_External_Note
*e_note
;
1329 style
= t
->o
->build_id
.style
;
1330 asec
= t
->o
->build_id
.sec
;
1331 if (bfd_is_abs_section (asec
->output_section
))
1333 einfo (_("%P: warning: .note.gnu.build-id section discarded,"
1334 " --build-id ignored\n"));
1337 i_shdr
= &elf_section_data (asec
->output_section
)->this_hdr
;
1339 if (i_shdr
->contents
== NULL
)
1341 if (asec
->contents
== NULL
)
1342 asec
->contents
= (unsigned char *) xmalloc (asec
->size
);
1343 contents
= asec
->contents
;
1346 contents
= i_shdr
->contents
+ asec
->output_offset
;
1348 e_note
= (Elf_External_Note
*) contents
;
1349 size
= offsetof (Elf_External_Note
, name
[sizeof "GNU"]);
1350 size
= (size
+ 3) & -(bfd_size_type
) 4;
1351 id_bits
= contents
+ size
;
1352 size
= asec
->size
- size
;
1354 bfd_h_put_32 (abfd
, sizeof "GNU", &e_note
->namesz
);
1355 bfd_h_put_32 (abfd
, size
, &e_note
->descsz
);
1356 bfd_h_put_32 (abfd
, NT_GNU_BUILD_ID
, &e_note
->type
);
1357 memcpy (e_note
->name
, "GNU", sizeof "GNU");
1359 generate_build_id (abfd
, style
, bed
->s
->checksum_contents
, id_bits
, size
);
1361 position
= i_shdr
->sh_offset
+ asec
->output_offset
;
1363 return (bfd_seek (abfd
, position
, SEEK_SET
) == 0
1364 && bfd_bwrite (contents
, size
, abfd
) == size
);
1367 /* Make .note.gnu.build-id section, and set up elf_tdata->build_id. */
1370 ldelf_setup_build_id (bfd
*ibfd
)
1376 size
= id_note_section_size (ibfd
);
1379 einfo (_("%P: warning: unrecognized --build-id style ignored\n"));
1383 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_IN_MEMORY
1384 | SEC_LINKER_CREATED
| SEC_READONLY
| SEC_DATA
);
1385 s
= bfd_make_section_with_flags (ibfd
, ".note.gnu.build-id", flags
);
1386 if (s
!= NULL
&& bfd_set_section_alignment (s
, 2))
1388 struct elf_obj_tdata
*t
= elf_tdata (link_info
.output_bfd
);
1389 t
->o
->build_id
.after_write_object_contents
= &write_build_id
;
1390 t
->o
->build_id
.style
= ldelf_emit_note_gnu_build_id
;
1391 t
->o
->build_id
.sec
= s
;
1392 elf_section_type (s
) = SHT_NOTE
;
1397 einfo (_("%P: warning: cannot create .note.gnu.build-id section,"
1398 " --build-id ignored\n"));
1402 /* Look through an expression for an assignment statement. */
1405 ldelf_find_exp_assignment (etree_type
*exp
)
1407 bfd_boolean provide
= FALSE
;
1409 switch (exp
->type
.node_class
)
1412 case etree_provided
:
1416 /* We call record_link_assignment even if the symbol is defined.
1417 This is because if it is defined by a dynamic object, we
1418 actually want to use the value defined by the linker script,
1419 not the value from the dynamic object (because we are setting
1420 symbols like etext). If the symbol is defined by a regular
1421 object, then, as it happens, calling record_link_assignment
1423 if (strcmp (exp
->assign
.dst
, ".") != 0)
1425 if (!bfd_elf_record_link_assignment (link_info
.output_bfd
,
1427 exp
->assign
.dst
, provide
,
1428 exp
->assign
.hidden
))
1429 einfo (_("%F%P: failed to record assignment to %s: %E\n"),
1432 ldelf_find_exp_assignment (exp
->assign
.src
);
1436 ldelf_find_exp_assignment (exp
->binary
.lhs
);
1437 ldelf_find_exp_assignment (exp
->binary
.rhs
);
1441 ldelf_find_exp_assignment (exp
->trinary
.cond
);
1442 ldelf_find_exp_assignment (exp
->trinary
.lhs
);
1443 ldelf_find_exp_assignment (exp
->trinary
.rhs
);
1447 ldelf_find_exp_assignment (exp
->unary
.child
);
1455 /* This is called by the before_allocation routine via
1456 lang_for_each_statement. It locates any assignment statements, and
1457 tells the ELF backend about them, in case they are assignments to
1458 symbols which are referred to by dynamic objects. */
1461 ldelf_find_statement_assignment (lang_statement_union_type
*s
)
1463 if (s
->header
.type
== lang_assignment_statement_enum
)
1464 ldelf_find_exp_assignment (s
->assignment_statement
.exp
);
1467 /* Used by before_allocation and handle_option. */
1470 ldelf_append_to_separated_string (char **to
, char *op_arg
)
1473 *to
= xstrdup (op_arg
);
1476 size_t to_len
= strlen (*to
);
1477 size_t op_arg_len
= strlen (op_arg
);
1481 /* First see whether OPTARG is already in the path. */
1484 if (strncmp (op_arg
, cp
, op_arg_len
) == 0
1485 && (cp
[op_arg_len
] == 0
1486 || cp
[op_arg_len
] == config
.rpath_separator
))
1490 /* Not yet found. */
1491 cp
= strchr (cp
, config
.rpath_separator
);
1499 buf
= xmalloc (to_len
+ op_arg_len
+ 2);
1500 sprintf (buf
, "%s%c%s", *to
,
1501 config
.rpath_separator
, op_arg
);
1508 /* This is called after the sections have been attached to output
1509 sections, but before any sizes or addresses have been set. */
1512 ldelf_before_allocation (char *audit
, char *depaudit
,
1513 const char *default_interpreter_name
)
1518 struct bfd_link_hash_entry
*ehdr_start
= NULL
;
1519 unsigned char ehdr_start_save_type
= 0;
1520 char ehdr_start_save_u
[sizeof ehdr_start
->u
1521 - sizeof ehdr_start
->u
.def
.next
] = "";
1523 if (is_elf_hash_table (link_info
.hash
))
1525 _bfd_elf_tls_setup (link_info
.output_bfd
, &link_info
);
1527 /* Make __ehdr_start hidden if it has been referenced, to
1528 prevent the symbol from being dynamic. */
1529 if (!bfd_link_relocatable (&link_info
))
1531 struct elf_link_hash_table
*htab
= elf_hash_table (&link_info
);
1532 struct elf_link_hash_entry
*h
1533 = elf_link_hash_lookup (htab
, "__ehdr_start", FALSE
, FALSE
, TRUE
);
1535 /* Only adjust the export class if the symbol was referenced
1536 and not defined, otherwise leave it alone. */
1538 && (h
->root
.type
== bfd_link_hash_new
1539 || h
->root
.type
== bfd_link_hash_undefined
1540 || h
->root
.type
== bfd_link_hash_undefweak
1541 || h
->root
.type
== bfd_link_hash_common
))
1543 const struct elf_backend_data
*bed
;
1544 bed
= get_elf_backend_data (link_info
.output_bfd
);
1545 (*bed
->elf_backend_hide_symbol
) (&link_info
, h
, TRUE
);
1546 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
1547 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
1548 /* Don't leave the symbol undefined. Undefined hidden
1549 symbols typically won't have dynamic relocations, but
1550 we most likely will need dynamic relocations for
1551 __ehdr_start if we are building a PIE or shared
1553 ehdr_start
= &h
->root
;
1554 ehdr_start_save_type
= ehdr_start
->type
;
1555 memcpy (ehdr_start_save_u
,
1556 (char *) &ehdr_start
->u
+ sizeof ehdr_start
->u
.def
.next
,
1557 sizeof ehdr_start_save_u
);
1558 ehdr_start
->type
= bfd_link_hash_defined
;
1559 ehdr_start
->u
.def
.section
= bfd_abs_section_ptr
;
1560 ehdr_start
->u
.def
.value
= 0;
1564 /* If we are going to make any variable assignments, we need to
1565 let the ELF backend know about them in case the variables are
1566 referred to by dynamic objects. */
1567 lang_for_each_statement (ldelf_find_statement_assignment
);
1570 /* Let the ELF backend work out the sizes of any sections required
1571 by dynamic linking. */
1572 rpath
= command_line
.rpath
;
1574 rpath
= (const char *) getenv ("LD_RUN_PATH");
1576 for (abfd
= link_info
.input_bfds
; abfd
; abfd
= abfd
->link
.next
)
1577 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
1579 const char *audit_libs
= elf_dt_audit (abfd
);
1581 /* If the input bfd contains an audit entry, we need to add it as
1582 a dep audit entry. */
1583 if (audit_libs
&& *audit_libs
!= '\0')
1585 char *cp
= xstrdup (audit_libs
);
1589 char *cp2
= strchr (cp
, config
.rpath_separator
);
1597 if (cp
!= NULL
&& *cp
!= '\0')
1598 ldelf_append_to_separated_string (&depaudit
, cp
);
1600 cp
= more
? ++cp2
: NULL
;
1606 if (! (bfd_elf_size_dynamic_sections
1607 (link_info
.output_bfd
, command_line
.soname
, rpath
,
1608 command_line
.filter_shlib
, audit
, depaudit
,
1609 (const char * const *) command_line
.auxiliary_filters
,
1610 &link_info
, &sinterp
)))
1611 einfo (_("%F%P: failed to set dynamic section sizes: %E\n"));
1613 if (sinterp
!= NULL
)
1615 /* Let the user override the dynamic linker we are using. */
1616 if (command_line
.interpreter
!= NULL
)
1617 default_interpreter_name
= command_line
.interpreter
;
1618 if (default_interpreter_name
!= NULL
)
1620 sinterp
->contents
= (bfd_byte
*) default_interpreter_name
;
1621 sinterp
->size
= strlen ((char *) sinterp
->contents
) + 1;
1625 /* Look for any sections named .gnu.warning. As a GNU extensions,
1626 we treat such sections as containing warning messages. We print
1627 out the warning message, and then zero out the section size so
1628 that it does not get copied into the output file. */
1631 LANG_FOR_EACH_INPUT_STATEMENT (is
)
1637 if (is
->flags
.just_syms
)
1640 s
= bfd_get_section_by_name (is
->the_bfd
, ".gnu.warning");
1645 msg
= (char *) xmalloc ((size_t) (sz
+ 1));
1646 if (! bfd_get_section_contents (is
->the_bfd
, s
, msg
,
1648 einfo (_("%F%P: %pB: can't read contents of section .gnu.warning: %E\n"),
1651 (*link_info
.callbacks
->warning
) (&link_info
, msg
,
1652 (const char *) NULL
, is
->the_bfd
,
1653 (asection
*) NULL
, (bfd_vma
) 0);
1656 /* Clobber the section size, so that we don't waste space
1657 copying the warning into the output file. If we've already
1658 sized the output section, adjust its size. The adjustment
1659 is on rawsize because targets that size sections early will
1660 have called lang_reset_memory_regions after sizing. */
1661 if (s
->output_section
!= NULL
1662 && s
->output_section
->rawsize
>= s
->size
)
1663 s
->output_section
->rawsize
-= s
->size
;
1667 /* Also set SEC_EXCLUDE, so that local symbols defined in the
1668 warning section don't get copied to the output. */
1669 s
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
1673 before_allocation_default ();
1675 if (!bfd_elf_size_dynsym_hash_dynstr (link_info
.output_bfd
, &link_info
))
1676 einfo (_("%F%P: failed to set dynamic section sizes: %E\n"));
1678 if (ehdr_start
!= NULL
)
1680 /* If we twiddled __ehdr_start to defined earlier, put it back
1682 ehdr_start
->type
= ehdr_start_save_type
;
1683 memcpy ((char *) &ehdr_start
->u
+ sizeof ehdr_start
->u
.def
.next
,
1685 sizeof ehdr_start_save_u
);
1688 /* Try to open a dynamic archive. This is where we know that ELF
1689 dynamic libraries have an extension of .so (or .sl on oddball systems
1693 ldelf_open_dynamic_archive (const char *arch
, search_dirs_type
*search
,
1694 lang_input_statement_type
*entry
)
1696 const char *filename
;
1699 bfd_boolean opened
= FALSE
;
1701 if (! entry
->flags
.maybe_archive
)
1704 filename
= entry
->filename
;
1705 len
= strlen (search
->name
) + strlen (filename
);
1706 if (entry
->flags
.full_name_provided
)
1709 string
= (char *) xmalloc (len
);
1710 sprintf (string
, "%s/%s", search
->name
, filename
);
1716 len
+= strlen (arch
) + sizeof "/lib.so";
1717 #ifdef EXTRA_SHLIB_EXTENSION
1718 xlen
= (strlen (EXTRA_SHLIB_EXTENSION
) > 3
1719 ? strlen (EXTRA_SHLIB_EXTENSION
) - 3
1722 string
= (char *) xmalloc (len
+ xlen
);
1723 sprintf (string
, "%s/lib%s%s.so", search
->name
, filename
, arch
);
1724 #ifdef EXTRA_SHLIB_EXTENSION
1725 /* Try the .so extension first. If that fails build a new filename
1726 using EXTRA_SHLIB_EXTENSION. */
1727 opened
= ldfile_try_open_bfd (string
, entry
);
1729 strcpy (string
+ len
- 4, EXTRA_SHLIB_EXTENSION
);
1733 if (!opened
&& !ldfile_try_open_bfd (string
, entry
))
1739 entry
->filename
= string
;
1741 /* We have found a dynamic object to include in the link. The ELF
1742 backend linker will create a DT_NEEDED entry in the .dynamic
1743 section naming this file. If this file includes a DT_SONAME
1744 entry, it will be used. Otherwise, the ELF linker will just use
1745 the name of the file. For an archive found by searching, like
1746 this one, the DT_NEEDED entry should consist of just the name of
1747 the file, without the path information used to find it. Note
1748 that we only need to do this if we have a dynamic object; an
1749 archive will never be referenced by a DT_NEEDED entry.
1751 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1752 very pretty. I haven't been able to think of anything that is
1754 if (bfd_check_format (entry
->the_bfd
, bfd_object
)
1755 && (entry
->the_bfd
->flags
& DYNAMIC
) != 0)
1757 ASSERT (entry
->flags
.maybe_archive
&& entry
->flags
.search_dirs
);
1759 /* Rather than duplicating the logic above. Just use the
1760 filename we recorded earlier. */
1762 if (!entry
->flags
.full_name_provided
)
1763 filename
= lbasename (entry
->filename
);
1764 bfd_elf_set_dt_needed_name (entry
->the_bfd
, filename
);
1770 /* A variant of lang_output_section_find used by place_orphan. */
1772 static lang_output_section_statement_type
*
1773 output_rel_find (int isdyn
, int rela
)
1775 lang_output_section_statement_type
*lookup
;
1776 lang_output_section_statement_type
*last
= NULL
;
1777 lang_output_section_statement_type
*last_alloc
= NULL
;
1778 lang_output_section_statement_type
*last_ro_alloc
= NULL
;
1779 lang_output_section_statement_type
*last_rel
= NULL
;
1780 lang_output_section_statement_type
*last_rel_alloc
= NULL
;
1782 for (lookup
= &lang_os_list
.head
->output_section_statement
;
1784 lookup
= lookup
->next
)
1786 if (lookup
->constraint
>= 0
1787 && CONST_STRNEQ (lookup
->name
, ".rel"))
1789 int lookrela
= lookup
->name
[4] == 'a';
1791 /* .rel.dyn must come before all other reloc sections, to suit
1796 /* Don't place after .rel.plt as doing so results in wrong
1798 if (strcmp (".plt", lookup
->name
+ 4 + lookrela
) == 0)
1801 if (rela
== lookrela
|| last_rel
== NULL
)
1803 if ((rela
== lookrela
|| last_rel_alloc
== NULL
)
1804 && lookup
->bfd_section
!= NULL
1805 && (lookup
->bfd_section
->flags
& SEC_ALLOC
) != 0)
1806 last_rel_alloc
= lookup
;
1810 if (lookup
->bfd_section
!= NULL
1811 && (lookup
->bfd_section
->flags
& SEC_ALLOC
) != 0)
1813 last_alloc
= lookup
;
1814 if ((lookup
->bfd_section
->flags
& SEC_READONLY
) != 0)
1815 last_ro_alloc
= lookup
;
1820 return last_rel_alloc
;
1826 return last_ro_alloc
;
1834 /* Return whether IN is suitable to be part of OUT. */
1837 elf_orphan_compatible (asection
*in
, asection
*out
)
1839 /* Non-zero sh_info implies a section with SHF_INFO_LINK with
1840 unknown semantics for the generic linker, or a SHT_REL/SHT_RELA
1841 section where sh_info specifies a symbol table. (We won't see
1842 SHT_GROUP, SHT_SYMTAB or SHT_DYNSYM sections here.) We clearly
1843 can't merge SHT_REL/SHT_RELA using differing symbol tables, and
1844 shouldn't merge sections with differing unknown semantics. */
1845 if (elf_section_data (out
)->this_hdr
.sh_info
1846 != elf_section_data (in
)->this_hdr
.sh_info
)
1848 /* We can't merge with member of output section group nor merge two
1849 sections with differing SHF_EXCLUDE when doing a relocatable link.
1851 if (bfd_link_relocatable (&link_info
)
1852 && (elf_next_in_group (out
) != NULL
1853 || ((elf_section_flags (out
) ^ elf_section_flags (in
))
1854 & SHF_EXCLUDE
) != 0))
1856 return _bfd_elf_match_sections_by_type (link_info
.output_bfd
, out
,
1860 /* Place an orphan section. We use this to put random SHF_ALLOC
1861 sections in the right segment. */
1863 lang_output_section_statement_type
*
1864 ldelf_place_orphan (asection
*s
, const char *secname
, int constraint
)
1866 static struct orphan_save hold
[] =
1869 SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
,
1872 SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_DATA
,
1875 SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_THREAD_LOCAL
,
1878 SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_DATA
,
1884 SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_DATA
,
1887 SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_DATA
,
1890 SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_SMALL_DATA
,
1896 enum orphan_save_index
1908 static int orphan_init_done
= 0;
1909 struct orphan_save
*place
;
1910 lang_output_section_statement_type
*after
;
1911 lang_output_section_statement_type
*os
;
1912 lang_output_section_statement_type
*match_by_name
= NULL
;
1914 int elfinput
= s
->owner
->xvec
->flavour
== bfd_target_elf_flavour
;
1915 int elfoutput
= link_info
.output_bfd
->xvec
->flavour
== bfd_target_elf_flavour
;
1916 unsigned int sh_type
= elfinput
? elf_section_type (s
) : SHT_NULL
;
1920 if (!bfd_link_relocatable (&link_info
)
1921 && link_info
.combreloc
1922 && (s
->flags
& SEC_ALLOC
))
1928 secname
= ".rela.dyn";
1932 secname
= ".rel.dyn";
1938 else if (CONST_STRNEQ (secname
, ".rel"))
1940 secname
= secname
[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1945 if (!bfd_link_relocatable (&link_info
)
1948 && (s
->flags
& SEC_ALLOC
) != 0
1949 && (elf_tdata (s
->owner
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0
1950 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
1952 /* Find the output mbind section with the same type, attributes
1953 and sh_info field. */
1954 for (os
= &lang_os_list
.head
->output_section_statement
;
1957 if (os
->bfd_section
!= NULL
1958 && !bfd_is_abs_section (os
->bfd_section
)
1959 && (elf_section_flags (os
->bfd_section
) & SHF_GNU_MBIND
) != 0
1960 && ((s
->flags
& (SEC_ALLOC
1965 == (os
->bfd_section
->flags
& (SEC_ALLOC
1970 && (elf_section_data (os
->bfd_section
)->this_hdr
.sh_info
1971 == elf_section_data (s
)->this_hdr
.sh_info
))
1973 lang_add_section (&os
->children
, s
, NULL
, os
);
1977 /* Create the output mbind section with the ".mbind." prefix
1979 if ((s
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
1980 secname
= ".mbind.bss";
1981 else if ((s
->flags
& SEC_READONLY
) == 0)
1982 secname
= ".mbind.data";
1983 else if ((s
->flags
& SEC_CODE
) == 0)
1984 secname
= ".mbind.rodata";
1986 secname
= ".mbind.text";
1987 elf_tdata (link_info
.output_bfd
)->has_gnu_osabi
|= elf_gnu_osabi_mbind
;
1990 /* Look through the script to see where to place this section. The
1991 script includes entries added by previous lang_insert_orphan
1992 calls, so this loop puts multiple compatible orphans of the same
1993 name into a single output section. */
1994 if (constraint
== 0)
1995 for (os
= lang_output_section_find (secname
);
1997 os
= next_matching_output_section_statement (os
, 0))
1999 /* If we don't match an existing output section, tell
2000 lang_insert_orphan to create a new output section. */
2001 constraint
= SPECIAL
;
2003 /* Check to see if we already have an output section statement
2004 with this name, and its bfd section has compatible flags.
2005 If the section already exists but does not have any flags
2006 set, then it has been created by the linker, possibly as a
2007 result of a --section-start command line switch. */
2008 if (os
->bfd_section
!= NULL
2009 && (os
->bfd_section
->flags
== 0
2010 || (((s
->flags
^ os
->bfd_section
->flags
)
2011 & (SEC_LOAD
| SEC_ALLOC
)) == 0
2014 || elf_orphan_compatible (s
, os
->bfd_section
)))))
2016 lang_add_section (&os
->children
, s
, NULL
, os
);
2020 /* Save unused output sections in case we can match them
2021 against orphans later. */
2022 if (os
->bfd_section
== NULL
)
2026 /* If we didn't match an active output section, see if we matched an
2027 unused one and use that. */
2030 lang_add_section (&match_by_name
->children
, s
, NULL
, match_by_name
);
2031 return match_by_name
;
2034 if (!orphan_init_done
)
2036 struct orphan_save
*ho
;
2038 for (ho
= hold
; ho
< hold
+ sizeof (hold
) / sizeof (hold
[0]); ++ho
)
2039 if (ho
->name
!= NULL
)
2041 ho
->os
= lang_output_section_find (ho
->name
);
2042 if (ho
->os
!= NULL
&& ho
->os
->flags
== 0)
2043 ho
->os
->flags
= ho
->flags
;
2045 orphan_init_done
= 1;
2048 /* If this is a final link, then always put .gnu.warning.SYMBOL
2049 sections into the .text section to get them out of the way. */
2050 if (bfd_link_executable (&link_info
)
2051 && CONST_STRNEQ (s
->name
, ".gnu.warning.")
2052 && hold
[orphan_text
].os
!= NULL
)
2054 os
= hold
[orphan_text
].os
;
2055 lang_add_section (&os
->children
, s
, NULL
, os
);
2060 if (!bfd_link_relocatable (&link_info
))
2063 while ((nexts
= bfd_get_next_section_by_name (nexts
->owner
, nexts
))
2065 if (nexts
->output_section
== NULL
2066 && (nexts
->flags
& SEC_EXCLUDE
) == 0
2067 && ((nexts
->flags
^ flags
) & (SEC_LOAD
| SEC_ALLOC
)) == 0
2068 && (nexts
->owner
->flags
& DYNAMIC
) == 0
2069 && !bfd_input_just_syms (nexts
->owner
)
2070 && _bfd_elf_match_sections_by_type (nexts
->owner
, nexts
,
2072 flags
= (((flags
^ SEC_READONLY
)
2073 | (nexts
->flags
^ SEC_READONLY
))
2077 /* Decide which segment the section should go in based on the
2078 section name and section flags. We put loadable .note sections
2079 right after the .interp section, so that the PT_NOTE segment is
2080 stored right after the program headers where the OS can read it
2081 in the first page. */
2084 if ((flags
& (SEC_ALLOC
| SEC_DEBUGGING
)) == 0)
2085 place
= &hold
[orphan_nonalloc
];
2086 else if ((flags
& SEC_ALLOC
) == 0)
2088 else if ((flags
& SEC_LOAD
) != 0
2090 ? sh_type
== SHT_NOTE
2091 : CONST_STRNEQ (secname
, ".note")))
2092 place
= &hold
[orphan_interp
];
2093 else if ((flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_THREAD_LOCAL
)) == 0)
2094 place
= &hold
[orphan_bss
];
2095 else if ((flags
& SEC_SMALL_DATA
) != 0)
2096 place
= &hold
[orphan_sdata
];
2097 else if ((flags
& SEC_THREAD_LOCAL
) != 0)
2098 place
= &hold
[orphan_tdata
];
2099 else if ((flags
& SEC_READONLY
) == 0)
2100 place
= &hold
[orphan_data
];
2101 else if ((flags
& SEC_LOAD
) != 0
2103 ? sh_type
== SHT_RELA
|| sh_type
== SHT_REL
2104 : CONST_STRNEQ (secname
, ".rel")))
2105 place
= &hold
[orphan_rel
];
2106 else if ((flags
& SEC_CODE
) == 0)
2107 place
= &hold
[orphan_rodata
];
2109 place
= &hold
[orphan_text
];
2114 if (place
->os
== NULL
)
2116 if (place
->name
!= NULL
)
2117 place
->os
= lang_output_section_find (place
->name
);
2120 int rela
= elfinput
? sh_type
== SHT_RELA
: secname
[4] == 'a';
2121 place
->os
= output_rel_find (isdyn
, rela
);
2127 = lang_output_section_find_by_flags (s
, flags
, &place
->os
,
2128 _bfd_elf_match_sections_by_type
);
2130 /* *ABS* is always the first output section statement. */
2131 after
= &lang_os_list
.head
->output_section_statement
;
2134 return lang_insert_orphan (s
, secname
, constraint
, after
, place
, NULL
, NULL
);