1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 cat >e${EMULATION_NAME}.c <<EOF
4 /* This file is is generated by a shell script. DO NOT EDIT! */
6 /* SunOS emulation code for ${EMULATION_NAME}
7 Copyright (C) 1991, 1993, 1994 Free Software Foundation, Inc.
8 Written by Steve Chamberlain <sac@cygnus.com>
9 SunOS shared library support by Ian Lance Taylor <ian@cygnus.com>
11 This file is part of GLD, the Gnu Linker.
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.
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.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
27 #define TARGET_IS_${EMULATION_NAME}
29 #include <sys/types.h>
32 /* FIXME: On some hosts we will need to include a different file.
33 This is correct for SunOS, which is the only place this file will
34 typically be compiled. However, if somebody configures the linker
35 for all targets, they will run into trouble here. */
51 static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
52 static void gld${EMULATION_NAME}_create_output_section_statements
54 static void gld${EMULATION_NAME}_find_so
55 PARAMS ((lang_input_statement_type *));
56 static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
57 static void gld${EMULATION_NAME}_find_statement_assignment
58 PARAMS ((lang_statement_union_type *));
59 static void gld${EMULATION_NAME}_find_exp_assignment PARAMS ((etree_type *));
60 static void gld${EMULATION_NAME}_count_need
61 PARAMS ((lang_input_statement_type *));
62 static void gld${EMULATION_NAME}_set_need
63 PARAMS ((lang_input_statement_type *));
64 static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile));
67 gld${EMULATION_NAME}_before_parse()
69 ldfile_output_architecture = bfd_arch_${ARCH};
70 config.dynamic_link = true;
73 /* Despite the name, we use this routine to search for dynamic
74 libraries. On SunOS this requires a directory search. We need to
75 find the .so file with the highest version number. The user may
76 restrict the major version by saying, e.g., -lc.1. Also, if we
77 find a .so file, we need to look for a the same file after
78 replacing .so with .sa; if it exists, it will be an archive which
79 provide some initializations for data symbols, and we need to
80 search it after including the .so file. */
83 gld${EMULATION_NAME}_create_output_section_statements ()
85 if (config.dynamic_link)
86 lang_for_each_input_file (gld${EMULATION_NAME}_find_so);
89 /* Search the directory for a .so file for each library search. */
92 gld${EMULATION_NAME}_find_so (inp)
93 lang_input_statement_type *inp;
95 search_dirs_type *search;
101 int max_maj, max_min;
105 if (! inp->search_dirs_flag
106 || ! inp->is_archive)
109 ASSERT (strncmp (inp->local_sym_name, "-l", 2) == 0);
111 filename = inp->filename;
113 dot = strchr (filename, '.');
115 len = strlen (filename);
118 len = dot - filename;
119 alc = (char *) alloca (len + 1);
120 strncpy (alc, filename, len);
126 max_maj = max_min = 0;
127 for (search = search_head; search != NULL; search = search->next)
130 struct dirent *entry;
132 dir = opendir (search->name);
136 while ((entry = readdir (dir)) != NULL)
138 int found_maj, found_min;
140 if (strncmp (entry->d_name, "lib", 3) != 0
141 || strncmp (entry->d_name + 3, inp->filename, len) != 0
142 || strncmp (entry->d_name + 3 + len, ".so", 3) != 0)
145 /* We've found a .so file. Work out the major and minor
149 sscanf (entry->d_name + 3 + len, ".so.%d.%d",
150 &found_maj, &found_min);
152 if (force_maj != -1 && force_maj != found_maj)
155 /* We've found a match for the name we are searching for.
156 See if this is the version we should use. If the major
157 and minor versions match, we use the last entry in
158 alphabetical order; I don't know if this is how SunOS
159 distinguishes libc.so.1.8 from libc.so.1.8.1, but it
162 || (found_maj > max_maj)
163 || (found_maj == max_maj
164 && (found_min > max_min
165 || (found_min == max_min
166 && strcmp (entry->d_name, found) > 0))))
170 found = (char *) xmalloc (strlen (entry->d_name) + 1);
171 strcpy (found, entry->d_name);
185 /* We did not find a matching .so file. This isn't an error,
186 since there might still be a matching .a file, which will be
187 found by the usual search. */
191 /* Replace the filename with the one we have found. */
192 alc = (char *) xmalloc (strlen (search->name) + strlen (found) + 2);
193 sprintf (alc, "%s/%s", search->name, found);
196 /* Turn off the search_dirs_flag to prevent ldfile_open_file from
197 searching for this file again. */
198 inp->search_dirs_flag = false;
202 /* Now look for the same file name, but with .sa instead of .so. If
203 found, add it to the list of input files. */
204 alc = (char *) alloca (strlen (inp->filename) + 1);
205 strcpy (alc, inp->filename);
206 strstr (alc, ".so.")[2] = 'a';
207 if (stat (alc, &st) == 0)
209 lang_input_statement_type *sa;
212 /* Add the .sa file to the statement list just after the .so
213 file. This is really a hack. */
214 sa = ((lang_input_statement_type *)
215 xmalloc (sizeof (lang_input_statement_type)));
216 sa->header.next = inp->header.next;
217 sa->header.type = lang_input_statement_enum;
218 a = (char *) xmalloc (strlen (alc) + 1);
221 sa->local_sym_name = a;
224 sa->symbol_count = 0;
226 sa->next_real_file = inp->next_real_file;
227 sa->is_archive = false;
228 sa->search_dirs_flag = false;
229 sa->just_syms_flag = false;
232 sa->complained = false;
234 /* Put the new statement next on the list of statements and next
235 on the list of input files. */
236 inp->header.next = (lang_statement_union_type *) sa;
237 inp->next_real_file = (lang_statement_union_type *) sa;
241 /* We need to use static variables to pass information around the call
242 to lang_for_each_input_file. Ick. */
244 static bfd_size_type need_size;
245 static bfd_size_type need_entries;
246 static bfd_byte *need_contents;
247 static bfd_byte *need_pinfo;
248 static bfd_byte *need_pnames;
250 /* The size of one entry in the .need section, not including the file
253 #define NEED_ENTRY_SIZE (16)
255 /* This is called after the sections have been attached to output
256 sections, but before any sizes or addresses have been set. */
259 gld${EMULATION_NAME}_before_allocation ()
261 struct bfd_link_hash_entry *h = NULL;
266 /* We need to create a __DYNAMIC symbol. We don't do this in the
267 linker script because we want to set the value to the start of
268 the dynamic section if there is one, or to zero if there isn't
269 one. We need to create the symbol before calling
270 size_dynamic_sections, although we can't set the value until
272 if (! link_info.relocateable)
274 h = bfd_link_hash_lookup (link_info.hash, "__DYNAMIC", true, false,
277 einfo ("%P%F: bfd_link_hash_lookup: %E\n");
278 if (! bfd_sunos_record_link_assignment (output_bfd, &link_info,
280 einfo ("%P%F: failed to record assignment to __DYNAMIC: %E\n");
283 /* If we are going to make any variable assignments, we need to let
284 the backend linker know about them in case the variables are
285 referred to by dynamic objects. */
286 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
288 /* Let the backend linker work out the sizes of any sections
289 required by dynamic linking. */
290 if (! bfd_sunos_size_dynamic_sections (output_bfd, &link_info, &sdyn,
292 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
296 /* Set up the .need section. See the description of the ld_need
297 field in include/aout/sun4.h. */
302 lang_for_each_input_file (gld${EMULATION_NAME}_count_need);
304 /* We should only have a .need section if we have at least one
306 ASSERT (need_entries != 0);
308 sneed->_raw_size = need_size;
309 sneed->contents = (bfd_byte *) xmalloc (need_size);
311 need_contents = sneed->contents;
312 need_pinfo = sneed->contents;
313 need_pnames = sneed->contents + need_entries * 16;
315 lang_for_each_input_file (gld${EMULATION_NAME}_set_need);
317 ASSERT (need_pnames - sneed->contents == need_size);
323 search_dirs_type *search;
325 /* Set up the .rules section. This is just a PATH like string
326 of the -L arguments given on the command line. */
328 for (search = search_head; search != NULL; search = search->next)
330 size += strlen (search->name) + 1;
331 srules->_raw_size = size;
336 srules->contents = (bfd_byte *) xmalloc (size);
337 p = (char *) srules->contents;
339 for (search = search_head; search != NULL; search = search->next)
343 if (p != (char *) srules->contents)
345 strcpy (p, search->name);
352 /* We must assign a value to __DYNAMIC. It should be zero if we are
353 not doing a dynamic link, or the start of the .dynamic section if
355 if (! link_info.relocateable)
357 h->type = bfd_link_hash_defined;
360 h->u.def.section = sdyn;
362 h->u.def.section = &bfd_abs_section;
366 /* This is called by the before_allocation routine via
367 lang_for_each_statement. It locates any assignment statements, and
368 tells the backend linker about them, in case they are assignments
369 to symbols which are referred to by dynamic objects. */
372 gld${EMULATION_NAME}_find_statement_assignment (s)
373 lang_statement_union_type *s;
375 if (s->header.type == lang_assignment_statement_enum)
376 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
379 /* Look through an expression for an assignment statement. */
382 gld${EMULATION_NAME}_find_exp_assignment (exp)
385 switch (exp->type.node_class)
388 if (strcmp (exp->assign.dst, ".") != 0)
390 if (! bfd_sunos_record_link_assignment (output_bfd, &link_info,
392 einfo ("%P%F: failed to record assignment to %s: %E\n",
395 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
399 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
400 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
404 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
405 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
406 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
410 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
418 /* Work out the size of the .need section, and the number of entries.
419 The backend will set the ld_need field of the dynamic linking
420 information to point to the .need section. See include/aout/sun4.h
421 for more information. */
424 gld${EMULATION_NAME}_count_need (inp)
425 lang_input_statement_type *inp;
427 if (inp->the_bfd != NULL
428 && (inp->the_bfd->flags & DYNAMIC) != 0)
431 need_size += NEED_ENTRY_SIZE;
432 if (! inp->is_archive)
433 need_size += strlen (inp->filename) + 1;
436 ASSERT (inp->local_sym_name[0] == '-'
437 && inp->local_sym_name[1] == 'l');
438 need_size += strlen (inp->local_sym_name + 2) + 1;
443 /* Fill in the contents of the .need section. */
446 gld${EMULATION_NAME}_set_need (inp)
447 lang_input_statement_type *inp;
449 if (inp->the_bfd != NULL
450 && (inp->the_bfd->flags & DYNAMIC) != 0)
454 /* To really fill in the .need section contents, we need to know
455 the final file position of the section, but we don't.
456 Instead, we use offsets, and rely on the BFD backend to
457 finish the section up correctly. FIXME: Talk about lack of
458 referential locality. */
459 bfd_put_32 (output_bfd, need_pnames - need_contents, need_pinfo);
460 if (! inp->is_archive)
462 bfd_put_32 (output_bfd, (bfd_vma) 0, need_pinfo + 4);
463 bfd_put_16 (output_bfd, (bfd_vma) 0, need_pinfo + 8);
464 bfd_put_16 (output_bfd, (bfd_vma) 0, need_pinfo + 10);
465 strcpy (need_pnames, inp->filename);
472 bfd_put_32 (output_bfd, (bfd_vma) 0x80000000, need_pinfo + 4);
475 verstr = strstr (inp->filename, ".so.");
477 sscanf (verstr, ".so.%d.%d", &maj, &min);
478 bfd_put_16 (output_bfd, (bfd_vma) maj, need_pinfo + 8);
479 bfd_put_16 (output_bfd, (bfd_vma) min, need_pinfo + 10);
480 strcpy (need_pnames, inp->local_sym_name + 2);
483 c = (need_pinfo - need_contents) / NEED_ENTRY_SIZE;
484 if (c + 1 >= need_entries)
485 bfd_put_32 (output_bfd, (bfd_vma) 0, need_pinfo + 12);
487 bfd_put_32 (output_bfd, (bfd_vma) (c + 1) * NEED_ENTRY_SIZE,
490 need_pinfo += NEED_ENTRY_SIZE;
491 need_pnames += strlen (need_pnames) + 1;
496 gld${EMULATION_NAME}_get_script(isfile)
500 if test -n "$COMPILE_IN"
502 # Scripts compiled in.
504 # sed commands to quote an ld script as a C string.
511 cat >>e${EMULATION_NAME}.c <<EOF
515 if (link_info.relocateable == true && config.build_constructors == true)
516 return `sed "$sc" ldscripts/${EMULATION_NAME}.xu`;
517 else if (link_info.relocateable == true)
518 return `sed "$sc" ldscripts/${EMULATION_NAME}.xr`;
519 else if (!config.text_read_only)
520 return `sed "$sc" ldscripts/${EMULATION_NAME}.xbn`;
521 else if (!config.magic_demand_paged)
522 return `sed "$sc" ldscripts/${EMULATION_NAME}.xn`;
524 return `sed "$sc" ldscripts/${EMULATION_NAME}.x`;
529 # Scripts read from the filesystem.
531 cat >>e${EMULATION_NAME}.c <<EOF
535 if (link_info.relocateable == true && config.build_constructors == true)
536 return "ldscripts/${EMULATION_NAME}.xu";
537 else if (link_info.relocateable == true)
538 return "ldscripts/${EMULATION_NAME}.xr";
539 else if (!config.text_read_only)
540 return "ldscripts/${EMULATION_NAME}.xbn";
541 else if (!config.magic_demand_paged)
542 return "ldscripts/${EMULATION_NAME}.xn";
544 return "ldscripts/${EMULATION_NAME}.x";
550 cat >>e${EMULATION_NAME}.c <<EOF
552 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
554 gld${EMULATION_NAME}_before_parse,
558 after_allocation_default,
559 set_output_arch_default,
560 ldemul_default_target,
561 gld${EMULATION_NAME}_before_allocation,
562 gld${EMULATION_NAME}_get_script,
566 gld${EMULATION_NAME}_create_output_section_statements