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
|
413 fi
414fi
415cat >>e${EMULATION_NAME}.c <<EOF
416 }
417
418 if (force < 2)
419 continue;
420
421 einfo ("%P: warning: %s, needed by %B, not found (try using --rpath)\n",
422 l->name, l->by);
423 }
424}
425
426/* Search for a needed file in a path. */
427
428static boolean
429gld${EMULATION_NAME}_search_needed (path, name, force)
430 const char *path;
431 const char *name;
432 int force;
433{
434 const char *s;
435 size_t len;
436
437 if (path == NULL || *path == '\0')
438 return false;
439 len = strlen (name);
440 while (1)
441 {
442 char *filename, *sset;
443
444 s = strchr (path, ':');
445 if (s == NULL)
446 s = path + strlen (path);
447
448 filename = (char *) xmalloc (s - path + len + 2);
449 if (s == path)
450 sset = filename;
451 else
452 {
453 memcpy (filename, path, s - path);
454 filename[s - path] = '/';
455 sset = filename + (s - path) + 1;
456 }
457 strcpy (sset, name);
458
459 if (gld${EMULATION_NAME}_try_needed (filename, force))
460 return true;
461
462 free (filename);
463
464 if (*s == '\0')
465 break;
466 path = s + 1;
467 }
468
469 return false;
470}
471
472/* This function is called for each possible name for a dynamic object
473 named by a DT_NEEDED entry. The FORCE parameter indicates whether
474 to skip the check for a conflicting version. */
475
476static boolean
477gld${EMULATION_NAME}_try_needed (name, force)
478 const char *name;
479 int force;
480{
481 bfd *abfd;
482
483 abfd = bfd_openr (name, bfd_get_target (output_bfd));
484 if (abfd == NULL)
485 return false;
486 if (! bfd_check_format (abfd, bfd_object))
487 {
488 (void) bfd_close (abfd);
489 return false;
490 }
491 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
492 {
493 (void) bfd_close (abfd);
494 return false;
495 }
496
497 /* Check whether this object would include any conflicting library
498 versions. If FORCE is set, then we skip this check; we use this
499 the second time around, if we couldn't find any compatible
500 instance of the shared library. */
501
502 if (! force)
503 {
504 struct bfd_link_needed_list *needed;
505
506 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
507 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
508
509 if (needed != NULL)
510 {
511 global_vercheck_needed = needed;
512 global_vercheck_failed = false;
513 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
514 if (global_vercheck_failed)
515 {
516 (void) bfd_close (abfd);
517 /* Return false to force the caller to move on to try
518 another file on the search path. */
519 return false;
520 }
521
522 /* But wait! It gets much worse. On Linux, if a shared
523 library does not use libc at all, we are supposed to skip
524 it the first time around in case we encounter a shared
525 library later on with the same name which does use the
526 version of libc that we want. This is much too horrible
527 to use on any system other than Linux. */
528
529EOF
530case ${target} in
531 *-*-linux-gnu*)
532 cat >>e${EMULATION_NAME}.c <<EOF
533 {
534 struct bfd_link_needed_list *l;
535
536 for (l = needed; l != NULL; l = l->next)
537 if (strncmp (l->name, "libc.so", 7) == 0)
538 break;
539 if (l == NULL)
540 {
541 (void) bfd_close (abfd);
542 return false;
543 }
544 }
545
546EOF
547 ;;
548esac
549cat >>e${EMULATION_NAME}.c <<EOF
550 }
551 }
552
553 /* We've found a dynamic object matching the DT_NEEDED entry. */
554
555 /* We have already checked that there is no other input file of the
556 same name. We must now check again that we are not including the
557 same file twice. We need to do this because on many systems
558 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
559 reference libc.so.1. If we have already included libc.so, we
560 don't want to include libc.so.1 if they are the same file, and we
561 can only check that using stat. */
562
563 if (bfd_stat (abfd, &global_stat) != 0)
564 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
565 global_found = false;
566 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
567 if (global_found)
568 {
569 /* Return true to indicate that we found the file, even though
570 we aren't going to do anything with it. */
571 return true;
572 }
573
574 /* Tell the ELF backend that don't want the output file to have a
575 DT_NEEDED entry for this file. */
576 bfd_elf_set_dt_needed_name (abfd, "");
577
578 /* Add this file into the symbol table. */
579 if (! bfd_link_add_symbols (abfd, &link_info))
580 einfo ("%F%B: could not read symbols: %E\n", abfd);
581
582 return true;
583}
584
585/* See if an input file matches a DT_NEEDED entry by name. */
586
587static void
588gld${EMULATION_NAME}_check_needed (s)
589 lang_input_statement_type *s;
590{
591 if (global_found)
592 return;
593
594 if (s->filename != NULL
595 && strcmp (s->filename, global_needed->name) == 0)
596 {
597 global_found = true;
598 return;
599 }
600
601 if (s->the_bfd != NULL)
602 {
603 const char *soname;
604
605 soname = bfd_elf_get_dt_soname (s->the_bfd);
606 if (soname != NULL
607 && strcmp (soname, global_needed->name) == 0)
608 {
609 global_found = true;
610 return;
611 }
612 }
613
614 if (s->search_dirs_flag
615 && s->filename != NULL
616 && strchr (global_needed->name, '/') == NULL)
617 {
618 const char *f;
619
620 f = strrchr (s->filename, '/');
621 if (f != NULL
622 && strcmp (f + 1, global_needed->name) == 0)
623 {
624 global_found = true;
625 return;
626 }
627 }
628}
629
630/* See if an input file matches a DT_NEEDED entry by running stat on
631 the file. */
632
633static void
634gld${EMULATION_NAME}_stat_needed (s)
635 lang_input_statement_type *s;
636{
637 struct stat st;
638 const char *suffix;
639 const char *soname;
640 const char *f;
641
642 if (global_found)
643 return;
644 if (s->the_bfd == NULL)
645 return;
646
647 if (bfd_stat (s->the_bfd, &st) != 0)
648 {
649 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
650 return;
651 }
652
653 if (st.st_dev == global_stat.st_dev
654 && st.st_ino == global_stat.st_ino)
655 {
656 global_found = true;
657 return;
658 }
659
660 /* We issue a warning if it looks like we are including two
661 different versions of the same shared library. For example,
662 there may be a problem if -lc picks up libc.so.6 but some other
663 shared library has a DT_NEEDED entry of libc.so.5. This is a
664 hueristic test, and it will only work if the name looks like
665 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
666 If we really want to issue warnings about mixing version numbers
667 of shared libraries, we need to find a better way. */
668
669 if (strchr (global_needed->name, '/') != NULL)
670 return;
671 suffix = strstr (global_needed->name, ".so.");
672 if (suffix == NULL)
673 return;
674 suffix += sizeof ".so." - 1;
675
676 soname = bfd_elf_get_dt_soname (s->the_bfd);
677 if (soname == NULL)
678 soname = s->filename;
679
680 f = strrchr (soname, '/');
681 if (f != NULL)
682 ++f;
683 else
684 f = soname;
685
686 if (strncmp (f, global_needed->name, suffix - global_needed->name) == 0)
687 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
688 global_needed->name, global_needed->by, f);
689}
690
691/* On Linux, it's possible to have different versions of the same
692 shared library linked against different versions of libc. The
693 dynamic linker somehow tags which libc version to use in
694 /etc/ld.so.cache, and, based on the libc that it sees in the
695 executable, chooses which version of the shared library to use.
696
697 We try to do a similar check here by checking whether this shared
698 library needs any other shared libraries which may conflict with
699 libraries we have already included in the link. If it does, we
700 skip it, and try to find another shared library farther on down the
701 link path.
702
703 This is called via lang_for_each_input_file.
704 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
705 which we ar checking. This sets GLOBAL_VERCHECK_FAILED if we find
706 a conflicting version. */
707
708static void
709gld${EMULATION_NAME}_vercheck (s)
710 lang_input_statement_type *s;
711{
712 const char *soname, *f;
713 struct bfd_link_needed_list *l;
714
715 if (global_vercheck_failed)
716 return;
717 if (s->the_bfd == NULL
718 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
719 return;
720
721 soname = bfd_elf_get_dt_soname (s->the_bfd);
722 if (soname == NULL)
723 soname = bfd_get_filename (s->the_bfd);
724
725 f = strrchr (soname, '/');
726 if (f != NULL)
727 ++f;
728 else
729 f = soname;
730
731 for (l = global_vercheck_needed; l != NULL; l = l->next)
732 {
733 const char *suffix;
734
735 if (strcmp (f, l->name) == 0)
736 {
737 /* Probably can't happen, but it's an easy check. */
738 continue;
739 }
740
741 if (strchr (l->name, '/') != NULL)
742 continue;
743
744 suffix = strstr (l->name, ".so.");
745 if (suffix == NULL)
746 continue;
747
748 suffix += sizeof ".so." - 1;
749
750 if (strncmp (f, l->name, suffix - l->name) == 0)
751 {
752 /* Here we know that S is a dynamic object FOO.SO.VER1, and
753 the object we are considering needs a dynamic object
754 FOO.SO.VER2, and VER1 and VER2 are different. This
755 appears to be a version mismatch, so we tell the caller
756 to try a different version of this library. */
757 global_vercheck_failed = true;
758 return;
759 }
760 }
761}
762
763/* This is called after the sections have been attached to output
764 sections, but before any sizes or addresses have been set. */
765
766static void
767gld${EMULATION_NAME}_before_allocation ()
768{
769 const char *rpath;
770 asection *sinterp;
771
772 /* If we are going to make any variable assignments, we need to let
773 the ELF backend know about them in case the variables are
774 referred to by dynamic objects. */
775 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
776
777 /* Let the ELF backend work out the sizes of any sections required
778 by dynamic linking. */
779 rpath = command_line.rpath;
780 if (rpath == NULL)
781 rpath = (const char *) getenv ("LD_RUN_PATH");
782 if (! (bfd_elf${ELFSIZE}_size_dynamic_sections
783 (output_bfd, command_line.soname, rpath,
784 command_line.export_dynamic, command_line.filter_shlib,
785 (const char * const *) command_line.auxiliary_filters,
786 &link_info, &sinterp, lang_elf_version_info)))
787 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
788
789 /* Let the user override the dynamic linker we are using. */
790 if (command_line.interpreter != NULL
791 && sinterp != NULL)
792 {
793 sinterp->contents = (bfd_byte *) command_line.interpreter;
794 sinterp->_raw_size = strlen (command_line.interpreter) + 1;
795 }
796
797 /* Look for any sections named .gnu.warning. As a GNU extensions,
798 we treat such sections as containing warning messages. We print
799 out the warning message, and then zero out the section size so
800 that it does not get copied into the output file. */
801
802 {
803 LANG_FOR_EACH_INPUT_STATEMENT (is)
804 {
805 asection *s;
806 bfd_size_type sz;
807 char *msg;
808 boolean ret;
809
810 if (is->just_syms_flag)
811 continue;
812
813 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
814 if (s == NULL)
815 continue;
816
817 sz = bfd_section_size (is->the_bfd, s);
818 msg = xmalloc ((size_t) sz + 1);
819 if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
820 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
821 is->the_bfd);
822 msg[sz] = '\0';
823 ret = link_info.callbacks->warning (&link_info, msg,
824 (const char *) NULL,
825 is->the_bfd, (asection *) NULL,
826 (bfd_vma) 0);
827 ASSERT (ret);
828 free (msg);
829
830 /* Clobber the section size, so that we don't waste copying the
831 warning into the output file. */
832 s->_raw_size = 0;
833 }
834 }
835
836#if defined (TARGET_IS_elf32bmip) || defined (TARGET_IS_elf32lmip)
837 /* For MIPS ELF the .reginfo section requires special handling.
838 Each input section is 24 bytes, and the final output section must
839 also be 24 bytes. We handle this by clobbering all but the first
840 input section size to 0. The .reginfo section is handled
841 specially by the backend code anyhow. */
842 {
843 boolean found = false;
844 LANG_FOR_EACH_INPUT_STATEMENT (is)
845 {
846 asection *s;
847
848 if (is->just_syms_flag)
849 continue;
850
851 s = bfd_get_section_by_name (is->the_bfd, ".reginfo");
852 if (s == NULL)
853 continue;
854
855 if (! found)
856 {
857 found = true;
858 continue;
859 }
860
861 s->_raw_size = 0;
862 s->_cooked_size = 0;
863 }
864 }
865#endif
866}
867
868/* This is called by the before_allocation routine via
869 lang_for_each_statement. It locates any assignment statements, and
870 tells the ELF backend about them, in case they are assignments to
871 symbols which are referred to by dynamic objects. */
872
873static void
874gld${EMULATION_NAME}_find_statement_assignment (s)
875 lang_statement_union_type *s;
876{
877 if (s->header.type == lang_assignment_statement_enum)
878 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
879}
880
881/* Look through an expression for an assignment statement. */
882
883static void
884gld${EMULATION_NAME}_find_exp_assignment (exp)
885 etree_type *exp;
886{
887 struct bfd_link_hash_entry *h;
888
889 switch (exp->type.node_class)
890 {
891 case etree_provide:
892 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
893 false, false, false);
894 if (h == NULL)
895 break;
896
897 /* We call record_link_assignment even if the symbol is defined.
898 This is because if it is defined by a dynamic object, we
899 actually want to use the value defined by the linker script,
900 not the value from the dynamic object (because we are setting
901 symbols like etext). If the symbol is defined by a regular
902 object, then, as it happens, calling record_link_assignment
903 will do no harm. */
904
905 /* Fall through. */
906 case etree_assign:
907 if (strcmp (exp->assign.dst, ".") != 0)
908 {
909 if (! (bfd_elf${ELFSIZE}_record_link_assignment
910 (output_bfd, &link_info, exp->assign.dst,
911 exp->type.node_class == etree_provide ? true : false)))
912 einfo ("%P%F: failed to record assignment to %s: %E\n",
913 exp->assign.dst);
914 }
915 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
916 break;
917
918 case etree_binary:
919 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
920 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
921 break;
922
923 case etree_trinary:
924 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
925 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
926 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
927 break;
928
929 case etree_unary:
930 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
931 break;
932
933 default:
934 break;
935 }
936}
937
938/* Place an orphan section. We use this to put random SHF_ALLOC
939 sections in the right segment. */
940
941static asection *hold_section;
942static lang_output_section_statement_type *hold_use;
943static lang_output_section_statement_type *hold_text;
944static lang_output_section_statement_type *hold_rodata;
945static lang_output_section_statement_type *hold_data;
946static lang_output_section_statement_type *hold_bss;
947static lang_output_section_statement_type *hold_rel;
948static lang_output_section_statement_type *hold_interp;
949
950/*ARGSUSED*/
951static boolean
952gld${EMULATION_NAME}_place_orphan (file, s)
953 lang_input_statement_type *file;
954 asection *s;
955{
956 lang_output_section_statement_type *place;
957 asection *snew, **pps;
958 lang_statement_list_type *old;
959 lang_statement_list_type add;
960 etree_type *address;
961 const char *secname, *ps;
962 const char *outsecname;
963 lang_output_section_statement_type *os;
964
965 if ((s->flags & SEC_ALLOC) == 0)
966 return false;
967
968 /* Look through the script to see where to place this section. */
969 hold_section = s;
970 hold_use = NULL;
971 lang_for_each_statement (gld${EMULATION_NAME}_place_section);
972
973 if (hold_use != NULL)
974 {
975 /* We have already placed a section with this name. */
976 wild_doit (&hold_use->children, s, hold_use, file);
977 return true;
978 }
979
980 secname = bfd_get_section_name (s->owner, s);
981
982 /* If this is a final link, then always put .gnu.warning.SYMBOL
983 sections into the .text section to get them out of the way. */
984 if (! link_info.shared
985 && ! link_info.relocateable
986 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
987 && hold_text != NULL)
988 {
989 wild_doit (&hold_text->children, s, hold_text, file);
990 return true;
991 }
992
993 /* Decide which segment the section should go in based on the
994 section name and section flags. We put loadable .note sections
995 right after the .interp section, so that the PT_NOTE segment is
996 stored right after the program headers where the OS can read it
997 in the first page. */
998 place = NULL;
999 if ((s->flags & SEC_LOAD) != 0
1000 && strncmp (secname, ".note", 4) == 0
1001 && hold_interp != NULL)
1002 place = hold_interp;
1003 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1004 && hold_bss != NULL)
1005 place = hold_bss;
1006 else if ((s->flags & SEC_READONLY) == 0
1007 && hold_data != NULL)
1008 place = hold_data;
1009 else if (strncmp (secname, ".rel", 4) == 0
1010 && hold_rel != NULL)
1011 place = hold_rel;
1012 else if ((s->flags & SEC_CODE) == 0
1013 && (s->flags & SEC_READONLY) != 0
1014 && hold_rodata != NULL)
1015 place = hold_rodata;
1016 else if ((s->flags & SEC_READONLY) != 0
1017 && hold_text != NULL)
1018 place = hold_text;
1019 if (place == NULL)
1020 return false;
1021
1022 /* Choose a unique name for the section. This will be needed if the
1023 same section name appears in the input file with different
1024 loadable or allocateable characteristics. */
1025 outsecname = secname;
1026 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1027 {
1028 unsigned int len;
1029 char *newname;
1030 unsigned int i;
1031
1032 len = strlen (outsecname);
1033 newname = xmalloc (len + 5);
1034 strcpy (newname, outsecname);
1035 i = 0;
1036 do
1037 {
1038 sprintf (newname + len, "%d", i);
1039 ++i;
1040 }
1041 while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1042
1043 outsecname = newname;
1044 }
1045
1046 /* Create the section in the output file, and put it in the right
1047 place. This shuffling is to make the output file look neater. */
1048 snew = bfd_make_section (output_bfd, outsecname);
1049 if (snew == NULL)
1050 einfo ("%P%F: output format %s cannot represent section called %s\n",
1051 output_bfd->xvec->name, outsecname);
1052 if (place->bfd_section != NULL)
1053 {
1054 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1055 ;
1056 *pps = snew->next;
1057 snew->next = place->bfd_section->next;
1058 place->bfd_section->next = snew;
1059 }
1060
1061 /* Start building a list of statements for this section. */
1062 old = stat_ptr;
1063 stat_ptr = &add;
1064 lang_list_init (stat_ptr);
1065
1066 /* If the name of the section is representable in C, then create
1067 symbols to mark the start and the end of the section. */
1068 for (ps = outsecname; *ps != '\0'; ps++)
1069 if (! isalnum ((unsigned char) *ps) && *ps != '_')
1070 break;
1071 if (*ps == '\0' && config.build_constructors)
1072 {
1073 char *symname;
1074
1075 symname = (char *) xmalloc (ps - outsecname + sizeof "__start_");
1076 sprintf (symname, "__start_%s", outsecname);
1077 lang_add_assignment (exp_assop ('=', symname,
1078 exp_unop (ALIGN_K,
1079 exp_intop ((bfd_vma) 1
1080 << s->alignment_power))));
1081 }
1082
1083 if (! link_info.relocateable)
1084 address = NULL;
1085 else
1086 address = exp_intop ((bfd_vma) 0);
1087
1088 lang_enter_output_section_statement (outsecname, address, 0,
1089 (bfd_vma) 0,
1090 (etree_type *) NULL,
1091 (etree_type *) NULL,
1092 (etree_type *) NULL);
1093
1094 os = lang_output_section_statement_lookup (outsecname);
1095 wild_doit (&os->children, s, os, file);
1096
1097 lang_leave_output_section_statement
1098 ((bfd_vma) 0, "*default*", (struct lang_output_section_phdr_list *) NULL);
1099 stat_ptr = &add;
1100
1101 if (*ps == '\0' && config.build_constructors)
1102 {
1103 char *symname;
1104
1105 symname = (char *) xmalloc (ps - outsecname + sizeof "__stop_");
1106 sprintf (symname, "__stop_%s", outsecname);
1107 lang_add_assignment (exp_assop ('=', symname,
1108 exp_nameop (NAME, ".")));
1109 }
1110
1111 /* Now stick the new statement list right after PLACE. */
1112 *add.tail = place->header.next;
1113 place->header.next = add.head;
1114
1115 stat_ptr = old;
1116
1117 return true;
1118}
1119
1120static void
1121gld${EMULATION_NAME}_place_section (s)
1122 lang_statement_union_type *s;
1123{
1124 lang_output_section_statement_type *os;
1125
1126 if (s->header.type != lang_output_section_statement_enum)
1127 return;
1128
1129 os = &s->output_section_statement;
1130
1131 if (strcmp (os->name, hold_section->name) == 0
1132 && os->bfd_section != NULL
1133 && ((hold_section->flags & (SEC_LOAD | SEC_ALLOC))
1134 == (os->bfd_section->flags & (SEC_LOAD | SEC_ALLOC))))
1135 hold_use = os;
1136
1137 if (strcmp (os->name, ".text") == 0)
1138 hold_text = os;
1139 else if (strcmp (os->name, ".rodata") == 0)
1140 hold_rodata = os;
1141 else if (strcmp (os->name, ".data") == 0)
1142 hold_data = os;
1143 else if (strcmp (os->name, ".bss") == 0)
1144 hold_bss = os;
1145 else if (hold_rel == NULL
1146 && os->bfd_section != NULL
1147 && (os->bfd_section->flags & SEC_ALLOC) != 0
1148 && strncmp (os->name, ".rel", 4) == 0)
1149 hold_rel = os;
1150 else if (strcmp (os->name, ".interp") == 0)
1151 hold_interp = os;
1152}
1153
1154static char *
1155gld${EMULATION_NAME}_get_script(isfile)
1156 int *isfile;
1157EOF
1158
1159if test -n "$COMPILE_IN"
1160then
1161# Scripts compiled in.
1162
1163# sed commands to quote an ld script as a C string.
1164sc='s/["\\]/\\&/g
1165s/$/\\n\\/
11661s/^/"/
1167$s/$/n"/
1168'
1169
1170cat >>e${EMULATION_NAME}.c <<EOF
1171{
1172 *isfile = 0;
1173
1174 if (link_info.relocateable == true && config.build_constructors == true)
1175 return `sed "$sc" ldscripts/${EMULATION_NAME}.xu`;
1176 else if (link_info.relocateable == true)
1177 return `sed "$sc" ldscripts/${EMULATION_NAME}.xr`;
1178 else if (!config.text_read_only)
1179 return `sed "$sc" ldscripts/${EMULATION_NAME}.xbn`;
1180 else if (!config.magic_demand_paged)
1181 return `sed "$sc" ldscripts/${EMULATION_NAME}.xn`;
1182 else if (link_info.shared)
1183 return `sed "$sc" ldscripts/${EMULATION_NAME}.xs`;
1184 else
1185 return `sed "$sc" ldscripts/${EMULATION_NAME}.x`;
1186}
1187EOF
1188
1189else
1190# Scripts read from the filesystem.
1191
1192cat >>e${EMULATION_NAME}.c <<EOF
1193{
1194 *isfile = 1;
1195
1196 if (link_info.relocateable == true && config.build_constructors == true)
1197 return "ldscripts/${EMULATION_NAME}.xu";
1198 else if (link_info.relocateable == true)
1199 return "ldscripts/${EMULATION_NAME}.xr";
1200 else if (!config.text_read_only)
1201 return "ldscripts/${EMULATION_NAME}.xbn";
1202 else if (!config.magic_demand_paged)
1203 return "ldscripts/${EMULATION_NAME}.xn";
1204 else if (link_info.shared)
1205 return "ldscripts/${EMULATION_NAME}.xs";
1206 else
1207 return "ldscripts/${EMULATION_NAME}.x";
1208}
1209EOF
1210
1211fi
1212
1213cat >>e${EMULATION_NAME}.c <<EOF
1214
1215struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1216{
1217 gld${EMULATION_NAME}_before_parse,
1218 syslib_default,
1219 hll_default,
1220 after_parse_default,
1221 gld${EMULATION_NAME}_after_open,
1222 after_allocation_default,
1223 set_output_arch_default,
1224 ldemul_default_target,
1225 gld${EMULATION_NAME}_before_allocation,
1226 gld${EMULATION_NAME}_get_script,
1227 "${EMULATION_NAME}",
1228 "${OUTPUT_FORMAT}",
1229 NULL,
1230 NULL,
1231 gld${EMULATION_NAME}_open_dynamic_archive,
1232 gld${EMULATION_NAME}_place_orphan
1233};
1234EOF
|