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