d5ee9af18ed0c115fb59f60a515c7bd163073883
[deliverable/binutils-gdb.git] / ld / emultempl / elf32.em
1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 # This file is now misnamed, because it supports both 32 bit and 64 bit
4 # ELF emulations.
5 test -z "${ELFSIZE}" && ELFSIZE=32
6 cat >e${EMULATION_NAME}.c <<EOF
7 /* This file is is generated by a shell script. DO NOT EDIT! */
8
9 /* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
10 Copyright (C) 1991, 93, 94, 95, 96, 97, 98, 1999
11 Free Software Foundation, Inc.
12 Written by Steve Chamberlain <sac@cygnus.com>
13 ELF support by Ian Lance Taylor <ian@cygnus.com>
14
15 This file is part of GLD, the Gnu Linker.
16
17 This program is free software; you can redistribute it and/or modify
18 it under the terms of the GNU General Public License as published by
19 the Free Software Foundation; either version 2 of the License, or
20 (at your option) any later version.
21
22 This program is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 GNU General Public License for more details.
26
27 You should have received a copy of the GNU General Public License
28 along with this program; if not, write to the Free Software
29 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30
31 #define TARGET_IS_${EMULATION_NAME}
32
33 #include "bfd.h"
34 #include "sysdep.h"
35
36 #include <ctype.h>
37
38 #include "bfdlink.h"
39
40 #include "ld.h"
41 #include "ldmain.h"
42 #include "ldemul.h"
43 #include "ldfile.h"
44 #include "ldmisc.h"
45 #include "ldexp.h"
46 #include "ldlang.h"
47 #include "ldgram.h"
48
49 static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
50 static boolean gld${EMULATION_NAME}_open_dynamic_archive
51 PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
52 static void gld${EMULATION_NAME}_after_open PARAMS ((void));
53 static void gld${EMULATION_NAME}_check_needed
54 PARAMS ((lang_input_statement_type *));
55 static void gld${EMULATION_NAME}_stat_needed
56 PARAMS ((lang_input_statement_type *));
57 static boolean gld${EMULATION_NAME}_search_needed
58 PARAMS ((const char *, const char *, int));
59 static boolean gld${EMULATION_NAME}_try_needed PARAMS ((const char *, int));
60 static void gld${EMULATION_NAME}_vercheck
61 PARAMS ((lang_input_statement_type *));
62 static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
63 static void gld${EMULATION_NAME}_find_statement_assignment
64 PARAMS ((lang_statement_union_type *));
65 static void gld${EMULATION_NAME}_find_exp_assignment PARAMS ((etree_type *));
66 static boolean gld${EMULATION_NAME}_place_orphan
67 PARAMS ((lang_input_statement_type *, asection *));
68 static void gld${EMULATION_NAME}_place_section
69 PARAMS ((lang_statement_union_type *));
70 static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile));
71
72 static void
73 gld${EMULATION_NAME}_before_parse()
74 {
75 ldfile_output_architecture = bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`;
76 config.dynamic_link = ${DYNAMIC_LINK-true};
77 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo true ; else echo false ; fi`;
78 }
79
80 /* Try to open a dynamic archive. This is where we know that ELF
81 dynamic libraries have an extension of .so (or .sl on oddball systems
82 like hpux). */
83
84 static boolean
85 gld${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
86 const char *arch;
87 search_dirs_type *search;
88 lang_input_statement_type *entry;
89 {
90 const char *filename;
91 char *string;
92
93 if (! entry->is_archive)
94 return false;
95
96 filename = entry->filename;
97
98 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
99 is defined, but it does not seem worth the headache to optimize
100 away those two bytes of space. */
101 string = (char *) xmalloc (strlen (search->name)
102 + strlen (filename)
103 + strlen (arch)
104 #ifdef EXTRA_SHLIB_EXTENSION
105 + strlen (EXTRA_SHLIB_EXTENSION)
106 #endif
107 + sizeof "/lib.so");
108
109 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
110
111 #ifdef EXTRA_SHLIB_EXTENSION
112 /* Try the .so extension first. If that fails build a new filename
113 using EXTRA_SHLIB_EXTENSION. */
114 if (! ldfile_try_open_bfd (string, entry))
115 sprintf (string, "%s/lib%s%s%s", search->name,
116 filename, arch, EXTRA_SHLIB_EXTENSION);
117 #endif
118
119 if (! ldfile_try_open_bfd (string, entry))
120 {
121 free (string);
122 return false;
123 }
124
125 entry->filename = string;
126
127 /* We have found a dynamic object to include in the link. The ELF
128 backend linker will create a DT_NEEDED entry in the .dynamic
129 section naming this file. If this file includes a DT_SONAME
130 entry, it will be used. Otherwise, the ELF linker will just use
131 the name of the file. For an archive found by searching, like
132 this one, the DT_NEEDED entry should consist of just the name of
133 the file, without the path information used to find it. Note
134 that we only need to do this if we have a dynamic object; an
135 archive will never be referenced by a DT_NEEDED entry.
136
137 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
138 very pretty. I haven't been able to think of anything that is
139 pretty, though. */
140 if (bfd_check_format (entry->the_bfd, bfd_object)
141 && (entry->the_bfd->flags & DYNAMIC) != 0)
142 {
143 char *needed_name;
144
145 ASSERT (entry->is_archive && entry->search_dirs_flag);
146
147 /* Rather than duplicating the logic above. Just use the
148 filename we recorded earlier.
149
150 First strip off everything before the last '/'. */
151 filename = strrchr (entry->filename, '/');
152 filename++;
153
154 needed_name = (char *) xmalloc (strlen (filename) + 1);
155 strcpy (needed_name, filename);
156 bfd_elf_set_dt_needed_name (entry->the_bfd, needed_name);
157 }
158
159 return true;
160 }
161
162 EOF
163 if [ "x${host}" = "x${target}" ] ; then
164 case " ${EMULATION_LIBPATH} " in
165 *" ${EMULATION_NAME} "*)
166 cat >>e${EMULATION_NAME}.c <<EOF
167
168 /* For a native linker, check the file /etc/ld.so.conf for directories
169 in which we may find shared libraries. /etc/ld.so.conf is really
170 only meaningful on Linux, but we check it on other systems anyhow. */
171
172 static boolean gld${EMULATION_NAME}_check_ld_so_conf
173 PARAMS ((const char *, int));
174
175 static boolean
176 gld${EMULATION_NAME}_check_ld_so_conf (name, force)
177 const char *name;
178 int force;
179 {
180 static boolean initialized;
181 static char *ld_so_conf;
182
183 if (! initialized)
184 {
185 FILE *f;
186
187 f = fopen ("/etc/ld.so.conf", FOPEN_RT);
188 if (f != NULL)
189 {
190 char *b;
191 size_t len, alloc;
192 int c;
193
194 len = 0;
195 alloc = 100;
196 b = (char *) xmalloc (alloc);
197
198 while ((c = getc (f)) != EOF)
199 {
200 if (len + 1 >= alloc)
201 {
202 alloc *= 2;
203 b = (char *) xrealloc (b, alloc);
204 }
205 if (c != ':'
206 && c != ' '
207 && c != '\t'
208 && c != '\n'
209 && c != ',')
210 {
211 b[len] = c;
212 ++len;
213 }
214 else
215 {
216 if (len > 0 && b[len - 1] != ':')
217 {
218 b[len] = ':';
219 ++len;
220 }
221 }
222 }
223
224 if (len > 0 && b[len - 1] == ':')
225 --len;
226
227 if (len > 0)
228 b[len] = '\0';
229 else
230 {
231 free (b);
232 b = NULL;
233 }
234
235 fclose (f);
236
237 ld_so_conf = b;
238 }
239
240 initialized = true;
241 }
242
243 if (ld_so_conf == NULL)
244 return false;
245
246 return gld${EMULATION_NAME}_search_needed (ld_so_conf, name, force);
247 }
248
249 EOF
250 ;;
251 esac
252 fi
253 cat >>e${EMULATION_NAME}.c <<EOF
254
255 /* These variables are required to pass information back and forth
256 between after_open and check_needed and stat_needed and vercheck. */
257
258 static struct bfd_link_needed_list *global_needed;
259 static struct stat global_stat;
260 static boolean global_found;
261 static struct bfd_link_needed_list *global_vercheck_needed;
262 static boolean global_vercheck_failed;
263
264 /* This is called after all the input files have been opened. */
265
266 static void
267 gld${EMULATION_NAME}_after_open ()
268 {
269 struct bfd_link_needed_list *needed, *l;
270
271 /* We only need to worry about this when doing a final link. */
272 if (link_info.relocateable || link_info.shared)
273 return;
274
275 /* Get the list of files which appear in DT_NEEDED entries in
276 dynamic objects included in the link (often there will be none).
277 For each such file, we want to track down the corresponding
278 library, and include the symbol table in the link. This is what
279 the runtime dynamic linker will do. Tracking the files down here
280 permits one dynamic object to include another without requiring
281 special action by the person doing the link. Note that the
282 needed list can actually grow while we are stepping through this
283 loop. */
284 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
285 for (l = needed; l != NULL; l = l->next)
286 {
287 struct bfd_link_needed_list *ll;
288 int force;
289
290 /* If we've already seen this file, skip it. */
291 for (ll = needed; ll != l; ll = ll->next)
292 if (strcmp (ll->name, l->name) == 0)
293 break;
294 if (ll != l)
295 continue;
296
297 /* See if this file was included in the link explicitly. */
298 global_needed = l;
299 global_found = false;
300 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
301 if (global_found)
302 continue;
303
304 /* We need to find this file and include the symbol table. We
305 want to search for the file in the same way that the dynamic
306 linker will search. That means that we want to use
307 rpath_link, rpath, then the environment variable
308 LD_LIBRARY_PATH (native only), then the linker script
309 LIB_SEARCH_DIRS. We do not search using the -L arguments.
310
311 We search twice. The first time, we skip objects which may
312 introduce version mismatches. The second time, we force
313 their use. See gld${EMULATION_NAME}_vercheck comment. */
314 for (force = 0; force < 2; force++)
315 {
316 const char *lib_path;
317 size_t len;
318 search_dirs_type *search;
319
320 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
321 l->name, force))
322 break;
323 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
324 l->name, force))
325 break;
326 if (command_line.rpath_link == NULL
327 && command_line.rpath == NULL)
328 {
329 lib_path = (const char *) getenv ("LD_RUN_PATH");
330 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name,
331 force))
332 break;
333 }
334 EOF
335 if [ "x${host}" = "x${target}" ] ; then
336 case " ${EMULATION_LIBPATH} " in
337 *" ${EMULATION_NAME} "*)
338 cat >>e${EMULATION_NAME}.c <<EOF
339 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
340 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, force))
341 break;
342 EOF
343 ;;
344 esac
345 fi
346 cat >>e${EMULATION_NAME}.c <<EOF
347 len = strlen (l->name);
348 for (search = search_head; search != NULL; search = search->next)
349 {
350 char *filename;
351
352 if (search->cmdline)
353 continue;
354 filename = (char *) xmalloc (strlen (search->name) + len + 2);
355 sprintf (filename, "%s/%s", search->name, l->name);
356 if (gld${EMULATION_NAME}_try_needed (filename, force))
357 break;
358 free (filename);
359 }
360 if (search != NULL)
361 break;
362 EOF
363 if [ "x${host}" = "x${target}" ] ; then
364 case " ${EMULATION_LIBPATH} " in
365 *" ${EMULATION_NAME} "*)
366 cat >>e${EMULATION_NAME}.c <<EOF
367 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
368 break;
369 EOF
370 ;;
371 esac
372 fi
373 cat >>e${EMULATION_NAME}.c <<EOF
374 }
375
376 if (force < 2)
377 continue;
378
379 einfo ("%P: warning: %s, needed by %B, not found (try using --rpath)\n",
380 l->name, l->by);
381 }
382 }
383
384 /* Search for a needed file in a path. */
385
386 static boolean
387 gld${EMULATION_NAME}_search_needed (path, name, force)
388 const char *path;
389 const char *name;
390 int force;
391 {
392 const char *s;
393 size_t len;
394
395 if (path == NULL || *path == '\0')
396 return false;
397 len = strlen (name);
398 while (1)
399 {
400 char *filename, *sset;
401
402 s = strchr (path, ':');
403 if (s == NULL)
404 s = path + strlen (path);
405
406 filename = (char *) xmalloc (s - path + len + 2);
407 if (s == path)
408 sset = filename;
409 else
410 {
411 memcpy (filename, path, s - path);
412 filename[s - path] = '/';
413 sset = filename + (s - path) + 1;
414 }
415 strcpy (sset, name);
416
417 if (gld${EMULATION_NAME}_try_needed (filename, force))
418 return true;
419
420 free (filename);
421
422 if (*s == '\0')
423 break;
424 path = s + 1;
425 }
426
427 return false;
428 }
429
430 /* This function is called for each possible name for a dynamic object
431 named by a DT_NEEDED entry. The FORCE parameter indicates whether
432 to skip the check for a conflicting version. */
433
434 static boolean
435 gld${EMULATION_NAME}_try_needed (name, force)
436 const char *name;
437 int force;
438 {
439 bfd *abfd;
440
441 abfd = bfd_openr (name, bfd_get_target (output_bfd));
442 if (abfd == NULL)
443 return false;
444 if (! bfd_check_format (abfd, bfd_object))
445 {
446 (void) bfd_close (abfd);
447 return false;
448 }
449 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
450 {
451 (void) bfd_close (abfd);
452 return false;
453 }
454
455 /* Check whether this object would include any conflicting library
456 versions. If FORCE is set, then we skip this check; we use this
457 the second time around, if we couldn't find any compatible
458 instance of the shared library. */
459
460 if (! force)
461 {
462 struct bfd_link_needed_list *needed;
463
464 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
465 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
466
467 if (needed != NULL)
468 {
469 global_vercheck_needed = needed;
470 global_vercheck_failed = false;
471 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
472 if (global_vercheck_failed)
473 {
474 (void) bfd_close (abfd);
475 /* Return false to force the caller to move on to try
476 another file on the search path. */
477 return false;
478 }
479
480 /* But wait! It gets much worse. On Linux, if a shared
481 library does not use libc at all, we are supposed to skip
482 it the first time around in case we encounter a shared
483 library later on with the same name which does use the
484 version of libc that we want. This is much too horrible
485 to use on any system other than Linux. */
486
487 EOF
488 case ${target} in
489 *-*-linux-gnu*)
490 cat >>e${EMULATION_NAME}.c <<EOF
491 {
492 struct bfd_link_needed_list *l;
493
494 for (l = needed; l != NULL; l = l->next)
495 if (strncmp (l->name, "libc.so", 7) == 0)
496 break;
497 if (l == NULL)
498 {
499 (void) bfd_close (abfd);
500 return false;
501 }
502 }
503
504 EOF
505 ;;
506 esac
507 cat >>e${EMULATION_NAME}.c <<EOF
508 }
509 }
510
511 /* We've found a dynamic object matching the DT_NEEDED entry. */
512
513 /* We have already checked that there is no other input file of the
514 same name. We must now check again that we are not including the
515 same file twice. We need to do this because on many systems
516 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
517 reference libc.so.1. If we have already included libc.so, we
518 don't want to include libc.so.1 if they are the same file, and we
519 can only check that using stat. */
520
521 if (bfd_stat (abfd, &global_stat) != 0)
522 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
523 global_found = false;
524 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
525 if (global_found)
526 {
527 /* Return true to indicate that we found the file, even though
528 we aren't going to do anything with it. */
529 return true;
530 }
531
532 /* Tell the ELF backend that don't want the output file to have a
533 DT_NEEDED entry for this file. */
534 bfd_elf_set_dt_needed_name (abfd, "");
535
536 /* Add this file into the symbol table. */
537 if (! bfd_link_add_symbols (abfd, &link_info))
538 einfo ("%F%B: could not read symbols: %E\n", abfd);
539
540 return true;
541 }
542
543 /* See if an input file matches a DT_NEEDED entry by name. */
544
545 static void
546 gld${EMULATION_NAME}_check_needed (s)
547 lang_input_statement_type *s;
548 {
549 if (global_found)
550 return;
551
552 if (s->filename != NULL
553 && strcmp (s->filename, global_needed->name) == 0)
554 {
555 global_found = true;
556 return;
557 }
558
559 if (s->the_bfd != NULL)
560 {
561 const char *soname;
562
563 soname = bfd_elf_get_dt_soname (s->the_bfd);
564 if (soname != NULL
565 && strcmp (soname, global_needed->name) == 0)
566 {
567 global_found = true;
568 return;
569 }
570 }
571
572 if (s->search_dirs_flag
573 && s->filename != NULL
574 && strchr (global_needed->name, '/') == NULL)
575 {
576 const char *f;
577
578 f = strrchr (s->filename, '/');
579 if (f != NULL
580 && strcmp (f + 1, global_needed->name) == 0)
581 {
582 global_found = true;
583 return;
584 }
585 }
586 }
587
588 /* See if an input file matches a DT_NEEDED entry by running stat on
589 the file. */
590
591 static void
592 gld${EMULATION_NAME}_stat_needed (s)
593 lang_input_statement_type *s;
594 {
595 struct stat st;
596 const char *suffix;
597 const char *soname;
598 const char *f;
599
600 if (global_found)
601 return;
602 if (s->the_bfd == NULL)
603 return;
604
605 if (bfd_stat (s->the_bfd, &st) != 0)
606 {
607 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
608 return;
609 }
610
611 if (st.st_dev == global_stat.st_dev
612 && st.st_ino == global_stat.st_ino)
613 {
614 global_found = true;
615 return;
616 }
617
618 /* We issue a warning if it looks like we are including two
619 different versions of the same shared library. For example,
620 there may be a problem if -lc picks up libc.so.6 but some other
621 shared library has a DT_NEEDED entry of libc.so.5. This is a
622 hueristic test, and it will only work if the name looks like
623 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
624 If we really want to issue warnings about mixing version numbers
625 of shared libraries, we need to find a better way. */
626
627 if (strchr (global_needed->name, '/') != NULL)
628 return;
629 suffix = strstr (global_needed->name, ".so.");
630 if (suffix == NULL)
631 return;
632 suffix += sizeof ".so." - 1;
633
634 soname = bfd_elf_get_dt_soname (s->the_bfd);
635 if (soname == NULL)
636 soname = s->filename;
637
638 f = strrchr (soname, '/');
639 if (f != NULL)
640 ++f;
641 else
642 f = soname;
643
644 if (strncmp (f, global_needed->name, suffix - global_needed->name) == 0)
645 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
646 global_needed->name, global_needed->by, f);
647 }
648
649 /* On Linux, it's possible to have different versions of the same
650 shared library linked against different versions of libc. The
651 dynamic linker somehow tags which libc version to use in
652 /etc/ld.so.cache, and, based on the libc that it sees in the
653 executable, chooses which version of the shared library to use.
654
655 We try to do a similar check here by checking whether this shared
656 library needs any other shared libraries which may conflict with
657 libraries we have already included in the link. If it does, we
658 skip it, and try to find another shared library farther on down the
659 link path.
660
661 This is called via lang_for_each_input_file.
662 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
663 which we ar checking. This sets GLOBAL_VERCHECK_FAILED if we find
664 a conflicting version. */
665
666 static void
667 gld${EMULATION_NAME}_vercheck (s)
668 lang_input_statement_type *s;
669 {
670 const char *soname, *f;
671 struct bfd_link_needed_list *l;
672
673 if (global_vercheck_failed)
674 return;
675 if (s->the_bfd == NULL
676 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
677 return;
678
679 soname = bfd_elf_get_dt_soname (s->the_bfd);
680 if (soname == NULL)
681 soname = bfd_get_filename (s->the_bfd);
682
683 f = strrchr (soname, '/');
684 if (f != NULL)
685 ++f;
686 else
687 f = soname;
688
689 for (l = global_vercheck_needed; l != NULL; l = l->next)
690 {
691 const char *suffix;
692
693 if (strcmp (f, l->name) == 0)
694 {
695 /* Probably can't happen, but it's an easy check. */
696 continue;
697 }
698
699 if (strchr (l->name, '/') != NULL)
700 continue;
701
702 suffix = strstr (l->name, ".so.");
703 if (suffix == NULL)
704 continue;
705
706 suffix += sizeof ".so." - 1;
707
708 if (strncmp (f, l->name, suffix - l->name) == 0)
709 {
710 /* Here we know that S is a dynamic object FOO.SO.VER1, and
711 the object we are considering needs a dynamic object
712 FOO.SO.VER2, and VER1 and VER2 are different. This
713 appears to be a version mismatch, so we tell the caller
714 to try a different version of this library. */
715 global_vercheck_failed = true;
716 return;
717 }
718 }
719 }
720
721 /* This is called after the sections have been attached to output
722 sections, but before any sizes or addresses have been set. */
723
724 static void
725 gld${EMULATION_NAME}_before_allocation ()
726 {
727 const char *rpath;
728 asection *sinterp;
729
730 /* If we are going to make any variable assignments, we need to let
731 the ELF backend know about them in case the variables are
732 referred to by dynamic objects. */
733 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
734
735 /* Let the ELF backend work out the sizes of any sections required
736 by dynamic linking. */
737 rpath = command_line.rpath;
738 if (rpath == NULL)
739 rpath = (const char *) getenv ("LD_RUN_PATH");
740 if (! (bfd_elf${ELFSIZE}_size_dynamic_sections
741 (output_bfd, command_line.soname, rpath,
742 command_line.export_dynamic, command_line.filter_shlib,
743 (const char * const *) command_line.auxiliary_filters,
744 &link_info, &sinterp, lang_elf_version_info)))
745 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
746
747 /* Let the user override the dynamic linker we are using. */
748 if (command_line.interpreter != NULL
749 && sinterp != NULL)
750 {
751 sinterp->contents = (bfd_byte *) command_line.interpreter;
752 sinterp->_raw_size = strlen (command_line.interpreter) + 1;
753 }
754
755 /* Look for any sections named .gnu.warning. As a GNU extensions,
756 we treat such sections as containing warning messages. We print
757 out the warning message, and then zero out the section size so
758 that it does not get copied into the output file. */
759
760 {
761 LANG_FOR_EACH_INPUT_STATEMENT (is)
762 {
763 asection *s;
764 bfd_size_type sz;
765 char *msg;
766 boolean ret;
767
768 if (is->just_syms_flag)
769 continue;
770
771 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
772 if (s == NULL)
773 continue;
774
775 sz = bfd_section_size (is->the_bfd, s);
776 msg = xmalloc ((size_t) sz + 1);
777 if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
778 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
779 is->the_bfd);
780 msg[sz] = '\0';
781 ret = link_info.callbacks->warning (&link_info, msg,
782 (const char *) NULL,
783 is->the_bfd, (asection *) NULL,
784 (bfd_vma) 0);
785 ASSERT (ret);
786 free (msg);
787
788 /* Clobber the section size, so that we don't waste copying the
789 warning into the output file. */
790 s->_raw_size = 0;
791 }
792 }
793 }
794
795 /* This is called by the before_allocation routine via
796 lang_for_each_statement. It locates any assignment statements, and
797 tells the ELF backend about them, in case they are assignments to
798 symbols which are referred to by dynamic objects. */
799
800 static void
801 gld${EMULATION_NAME}_find_statement_assignment (s)
802 lang_statement_union_type *s;
803 {
804 if (s->header.type == lang_assignment_statement_enum)
805 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
806 }
807
808 /* Look through an expression for an assignment statement. */
809
810 static void
811 gld${EMULATION_NAME}_find_exp_assignment (exp)
812 etree_type *exp;
813 {
814 struct bfd_link_hash_entry *h;
815
816 switch (exp->type.node_class)
817 {
818 case etree_provide:
819 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
820 false, false, false);
821 if (h == NULL)
822 break;
823
824 /* We call record_link_assignment even if the symbol is defined.
825 This is because if it is defined by a dynamic object, we
826 actually want to use the value defined by the linker script,
827 not the value from the dynamic object (because we are setting
828 symbols like etext). If the symbol is defined by a regular
829 object, then, as it happens, calling record_link_assignment
830 will do no harm. */
831
832 /* Fall through. */
833 case etree_assign:
834 if (strcmp (exp->assign.dst, ".") != 0)
835 {
836 if (! (bfd_elf${ELFSIZE}_record_link_assignment
837 (output_bfd, &link_info, exp->assign.dst,
838 exp->type.node_class == etree_provide ? true : false)))
839 einfo ("%P%F: failed to record assignment to %s: %E\n",
840 exp->assign.dst);
841 }
842 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
843 break;
844
845 case etree_binary:
846 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
847 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
848 break;
849
850 case etree_trinary:
851 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
852 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
853 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
854 break;
855
856 case etree_unary:
857 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
858 break;
859
860 default:
861 break;
862 }
863 }
864
865 /* Place an orphan section. We use this to put random SHF_ALLOC
866 sections in the right segment. */
867
868 static asection *hold_section;
869 static lang_output_section_statement_type *hold_use;
870
871 struct orphan_save
872 {
873 lang_output_section_statement_type *os;
874 asection **section;
875 lang_statement_union_type **stmt;
876 };
877 static struct orphan_save hold_text;
878 static struct orphan_save hold_rodata;
879 static struct orphan_save hold_data;
880 static struct orphan_save hold_bss;
881 static struct orphan_save hold_rel;
882 static struct orphan_save hold_interp;
883
884 /*ARGSUSED*/
885 static boolean
886 gld${EMULATION_NAME}_place_orphan (file, s)
887 lang_input_statement_type *file;
888 asection *s;
889 {
890 struct orphan_save *place;
891 lang_statement_list_type *old;
892 lang_statement_list_type add;
893 etree_type *address;
894 const char *secname, *ps;
895 const char *outsecname;
896 lang_output_section_statement_type *os;
897
898 /* Look through the script to see where to place this section. */
899 hold_section = s;
900 hold_use = NULL;
901 lang_for_each_statement (gld${EMULATION_NAME}_place_section);
902
903 if (hold_use != NULL)
904 {
905 /* We have already placed a section with this name. */
906 wild_doit (&hold_use->children, s, hold_use, file);
907 return true;
908 }
909
910 secname = bfd_get_section_name (s->owner, s);
911
912 /* If this is a final link, then always put .gnu.warning.SYMBOL
913 sections into the .text section to get them out of the way. */
914 if (! link_info.shared
915 && ! link_info.relocateable
916 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
917 && hold_text.os != NULL)
918 {
919 wild_doit (&hold_text.os->children, s, hold_text.os, file);
920 return true;
921 }
922
923 /* Decide which segment the section should go in based on the
924 section name and section flags. We put loadable .note sections
925 right after the .interp section, so that the PT_NOTE segment is
926 stored right after the program headers where the OS can read it
927 in the first page. */
928 if (s->flags & SEC_EXCLUDE)
929 return false;
930 else if ((s->flags & SEC_ALLOC) == 0)
931 place = NULL;
932 else if ((s->flags & SEC_LOAD) != 0
933 && strncmp (secname, ".note", 4) == 0
934 && hold_interp.os != NULL)
935 place = &hold_interp;
936 else if ((s->flags & SEC_HAS_CONTENTS) == 0
937 && hold_bss.os != NULL)
938 place = &hold_bss;
939 else if ((s->flags & SEC_READONLY) == 0
940 && hold_data.os != NULL)
941 place = &hold_data;
942 else if (strncmp (secname, ".rel", 4) == 0
943 && hold_rel.os != NULL)
944 place = &hold_rel;
945 else if ((s->flags & SEC_CODE) == 0
946 && (s->flags & SEC_READONLY) != 0
947 && hold_rodata.os != NULL)
948 place = &hold_rodata;
949 else if ((s->flags & SEC_READONLY) != 0
950 && hold_text.os != NULL)
951 place = &hold_text;
952 else
953 place = NULL;
954
955 /* Choose a unique name for the section. This will be needed if the
956 same section name appears in the input file with different
957 loadable or allocateable characteristics. */
958 outsecname = secname;
959 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
960 {
961 unsigned int len;
962 char *newname;
963 unsigned int i;
964
965 len = strlen (outsecname);
966 newname = xmalloc (len + 5);
967 strcpy (newname, outsecname);
968 i = 0;
969 do
970 {
971 sprintf (newname + len, "%d", i);
972 ++i;
973 }
974 while (bfd_get_section_by_name (output_bfd, newname) != NULL);
975
976 outsecname = newname;
977 }
978
979 if (place != NULL)
980 {
981 /* Start building a list of statements for this section. */
982 old = stat_ptr;
983 stat_ptr = &add;
984 lang_list_init (stat_ptr);
985
986 /* If the name of the section is representable in C, then create
987 symbols to mark the start and the end of the section. */
988 for (ps = outsecname; *ps != '\0'; ps++)
989 if (! isalnum ((unsigned char) *ps) && *ps != '_')
990 break;
991 if (*ps == '\0' && config.build_constructors)
992 {
993 char *symname;
994 etree_type *e_align;
995
996 symname = (char *) xmalloc (ps - outsecname + sizeof "__start_");
997 sprintf (symname, "__start_%s", outsecname);
998 e_align = exp_unop (ALIGN_K,
999 exp_intop ((bfd_vma) 1 << s->alignment_power));
1000 lang_add_assignment (exp_assop ('=', symname, e_align));
1001 }
1002 }
1003
1004 if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1005 address = exp_intop ((bfd_vma) 0);
1006 else
1007 address = NULL;
1008
1009 lang_enter_output_section_statement (outsecname, address, 0,
1010 (bfd_vma) 0,
1011 (etree_type *) NULL,
1012 (etree_type *) NULL,
1013 (etree_type *) NULL);
1014
1015 os = lang_output_section_statement_lookup (outsecname);
1016 wild_doit (&os->children, s, os, file);
1017
1018 if (place != NULL)
1019 {
1020 asection *snew, **pps;
1021
1022 lang_leave_output_section_statement
1023 ((bfd_vma) 0, "*default*",
1024 (struct lang_output_section_phdr_list *) NULL, "*default*");
1025 stat_ptr = &add;
1026
1027 if (*ps == '\0' && config.build_constructors)
1028 {
1029 char *symname;
1030
1031 symname = (char *) xmalloc (ps - outsecname + sizeof "__stop_");
1032 sprintf (symname, "__stop_%s", outsecname);
1033 lang_add_assignment (exp_assop ('=', symname,
1034 exp_nameop (NAME, ".")));
1035 }
1036 stat_ptr = old;
1037
1038 snew = os->bfd_section;
1039 if (place->os->bfd_section != NULL || place->section != NULL)
1040 {
1041 /* Shuffle the section to make the output file look neater. */
1042 if (place->section == NULL)
1043 {
1044 #if 0
1045 /* Finding the end of the list is a little tricky. We
1046 make a wild stab at it by comparing section flags. */
1047 flagword first_flags = place->os->bfd_section->flags;
1048 for (pps = &place->os->bfd_section->next;
1049 *pps != NULL && (*pps)->flags == first_flags;
1050 pps = &(*pps)->next)
1051 ;
1052 place->section = pps;
1053 #else
1054 /* Put orphans after the first section on the list. */
1055 place->section = &place->os->bfd_section->next;
1056 #endif
1057 }
1058
1059 /* Unlink the section. */
1060 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1061 ;
1062 *pps = snew->next;
1063
1064 /* Now tack it on to the "place->os" section list. */
1065 snew->next = *place->section;
1066 *place->section = snew;
1067 }
1068 place->section = &snew->next; /* Save the end of this list. */
1069
1070 if (place->stmt == NULL)
1071 {
1072 /* Put the new statement list right at the head. */
1073 *add.tail = place->os->header.next;
1074 place->os->header.next = add.head;
1075 }
1076 else
1077 {
1078 /* Put it after the last orphan statement we added. */
1079 *add.tail = *place->stmt;
1080 *place->stmt = add.head;
1081 }
1082 place->stmt = add.tail; /* Save the end of this list. */
1083 }
1084
1085 return true;
1086 }
1087
1088 static void
1089 gld${EMULATION_NAME}_place_section (s)
1090 lang_statement_union_type *s;
1091 {
1092 lang_output_section_statement_type *os;
1093
1094 if (s->header.type != lang_output_section_statement_enum)
1095 return;
1096
1097 os = &s->output_section_statement;
1098
1099 if (strcmp (os->name, hold_section->name) == 0
1100 && os->bfd_section != NULL
1101 && ((hold_section->flags & (SEC_LOAD | SEC_ALLOC))
1102 == (os->bfd_section->flags & (SEC_LOAD | SEC_ALLOC))))
1103 hold_use = os;
1104
1105 if (strcmp (os->name, ".text") == 0)
1106 hold_text.os = os;
1107 else if (strcmp (os->name, ".rodata") == 0)
1108 hold_rodata.os = os;
1109 else if (strcmp (os->name, ".data") == 0)
1110 hold_data.os = os;
1111 else if (strcmp (os->name, ".bss") == 0)
1112 hold_bss.os = os;
1113 else if (hold_rel.os == NULL
1114 && os->bfd_section != NULL
1115 && (os->bfd_section->flags & SEC_ALLOC) != 0
1116 && strncmp (os->name, ".rel", 4) == 0)
1117 hold_rel.os = os;
1118 else if (strcmp (os->name, ".interp") == 0)
1119 hold_interp.os = os;
1120 }
1121
1122 static char *
1123 gld${EMULATION_NAME}_get_script(isfile)
1124 int *isfile;
1125 EOF
1126
1127 if test -n "$COMPILE_IN"
1128 then
1129 # Scripts compiled in.
1130
1131 # sed commands to quote an ld script as a C string.
1132 sc="-f stringify.sed"
1133
1134 cat >>e${EMULATION_NAME}.c <<EOF
1135 {
1136 *isfile = 0;
1137
1138 if (link_info.relocateable == true && config.build_constructors == true)
1139 return
1140 EOF
1141 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1142 echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1143 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1144 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1145 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1146 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1147 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1148
1149 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1150 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1151 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1152 fi
1153
1154 echo ' ; else return' >> e${EMULATION_NAME}.c
1155 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1156 echo '; }' >> e${EMULATION_NAME}.c
1157
1158 else
1159 # Scripts read from the filesystem.
1160
1161 cat >>e${EMULATION_NAME}.c <<EOF
1162 {
1163 *isfile = 1;
1164
1165 if (link_info.relocateable == true && config.build_constructors == true)
1166 return "ldscripts/${EMULATION_NAME}.xu";
1167 else if (link_info.relocateable == true)
1168 return "ldscripts/${EMULATION_NAME}.xr";
1169 else if (!config.text_read_only)
1170 return "ldscripts/${EMULATION_NAME}.xbn";
1171 else if (!config.magic_demand_paged)
1172 return "ldscripts/${EMULATION_NAME}.xn";
1173 else if (link_info.shared)
1174 return "ldscripts/${EMULATION_NAME}.xs";
1175 else
1176 return "ldscripts/${EMULATION_NAME}.x";
1177 }
1178 EOF
1179
1180 fi
1181
1182 if test -n "$PARSE_AND_LIST_ARGS" ; then
1183 cat >>e${EMULATION_NAME}.c <<EOF
1184 static int gld_${EMULATION_NAME}_parse_args PARAMS ((int, char **));
1185 static void gld_${EMULATION_NAME}_list_options PARAMS ((FILE * file));
1186
1187 $PARSE_AND_LIST_ARGS
1188 EOF
1189 else
1190
1191 cat >>e${EMULATION_NAME}.c <<EOF
1192 #define gld_${EMULATION_NAME}_parse_args NULL
1193 #define gld_${EMULATION_NAME}_list_options NULL
1194 EOF
1195
1196 fi
1197
1198 cat >>e${EMULATION_NAME}.c <<EOF
1199
1200 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1201 {
1202 gld${EMULATION_NAME}_before_parse,
1203 syslib_default,
1204 hll_default,
1205 after_parse_default,
1206 gld${EMULATION_NAME}_after_open,
1207 after_allocation_default,
1208 set_output_arch_default,
1209 ldemul_default_target,
1210 gld${EMULATION_NAME}_before_allocation,
1211 gld${EMULATION_NAME}_get_script,
1212 "${EMULATION_NAME}",
1213 "${OUTPUT_FORMAT}",
1214 NULL, /* finish */
1215 NULL, /* create output section statements */
1216 gld${EMULATION_NAME}_open_dynamic_archive,
1217 gld${EMULATION_NAME}_place_orphan,
1218 NULL, /* set_symbols */
1219 gld_${EMULATION_NAME}_parse_args,
1220 NULL, /* unrecognized_file */
1221 gld_${EMULATION_NAME}_list_options,
1222 NULL, /* recognized_file */
1223 NULL /* find_potential_libraries */
1224 };
1225 EOF
This page took 0.05496 seconds and 4 git commands to generate.