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