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 lang_for_each_input_file (gld${EMULATION_NAME}_find_so);
88 /* Search the directory for a .so file for each library search. */
91 gld${EMULATION_NAME}_find_so (inp)
92 lang_input_statement_type *inp;
94 search_dirs_type *search;
100 int max_maj, max_min;
104 if (! inp->search_dirs_flag
105 || ! inp->is_archive)
108 ASSERT (strncmp (inp->local_sym_name, "-l", 2) == 0);
110 filename = inp->filename;
112 dot = strchr (filename, '.');
114 len = strlen (filename);
117 len = dot - filename;
118 alc = (char *) alloca (len + 1);
119 strncpy (alc, filename, len);
125 max_maj = max_min = 0;
126 for (search = search_head; search != NULL; search = search->next)
129 struct dirent *entry;
131 dir = opendir (search->name);
135 while ((entry = readdir (dir)) != NULL)
137 int found_maj, found_min;
139 if (strncmp (entry->d_name, "lib", 3) != 0
140 || strncmp (entry->d_name + 3, inp->filename, len) != 0
141 || strncmp (entry->d_name + 3 + len, ".so", 3) != 0)
144 /* We've found a .so file. Work out the major and minor
148 sscanf (entry->d_name + 3 + len, ".so.%d.%d",
149 &found_maj, &found_min);
151 if (force_maj != -1 && force_maj != found_maj)
154 /* We've found a match for the name we are searching for.
155 See if this is the version we should use. If the major
156 and minor versions match, we use the last entry in
157 alphabetical order; I don't know if this is how SunOS
158 distinguishes libc.so.1.8 from libc.so.1.8.1, but it
161 || (found_maj > max_maj)
162 || (found_maj == max_maj
163 && (found_min > max_min
164 || (found_min == max_min
165 && strcmp (entry->d_name, found) > 0))))
169 found = (char *) xmalloc (strlen (entry->d_name) + 1);
170 strcpy (found, entry->d_name);
184 /* We did not find a matching .so file. This isn't an error,
185 since there might still be a matching .a file, which will be
186 found by the usual search. */
190 /* Replace the filename with the one we have found. */
191 alc = (char *) xmalloc (strlen (search->name) + strlen (found) + 2);
192 sprintf (alc, "%s/%s", search->name, found);
195 /* Turn off the search_dirs_flag to prevent ldfile_open_file from
196 searching for this file again. */
197 inp->search_dirs_flag = false;
201 /* Now look for the same file name, but with .sa instead of .so. If
202 found, add it to the list of input files. */
203 alc = (char *) alloca (strlen (inp->filename) + 1);
204 strcpy (alc, inp->filename);
205 strstr (alc, ".so.")[2] = 'a';
206 if (stat (alc, &st) == 0)
208 lang_input_statement_type *sa;
211 /* Add the .sa file to the statement list just after the .so
212 file. This is really a hack. */
213 sa = ((lang_input_statement_type *)
214 xmalloc (sizeof (lang_input_statement_type)));
215 sa->header.next = inp->header.next;
216 sa->header.type = lang_input_statement_enum;
217 a = (char *) xmalloc (strlen (alc) + 1);
220 sa->local_sym_name = a;
223 sa->symbol_count = 0;
225 sa->next_real_file = inp->next_real_file;
226 sa->is_archive = false;
227 sa->search_dirs_flag = false;
228 sa->just_syms_flag = false;
231 sa->complained = false;
233 /* Put the new statement next on the list of statements and next
234 on the list of input files. */
235 inp->header.next = (lang_statement_union_type *) sa;
236 inp->next_real_file = (lang_statement_union_type *) sa;
240 /* We need to use static variables to pass information around the call
241 to lang_for_each_input_file. Ick. */
243 static bfd_size_type need_size;
244 static bfd_size_type need_entries;
245 static bfd_byte *need_contents;
246 static bfd_byte *need_pinfo;
247 static bfd_byte *need_pnames;
249 /* The size of one entry in the .need section, not including the file
252 #define NEED_ENTRY_SIZE (16)
254 /* This is called after the sections have been attached to output
255 sections, but before any sizes or addresses have been set. */
258 gld${EMULATION_NAME}_before_allocation ()
260 struct bfd_link_hash_entry *h = NULL;
265 /* We need to create a __DYNAMIC symbol. We don't do this in the
266 linker script because we want to set the value to the start of
267 the dynamic section if there is one, or to zero if there isn't
268 one. We need to create the symbol before calling
269 size_dynamic_sections, although we can't set the value until
271 if (! link_info.relocateable)
273 h = bfd_link_hash_lookup (link_info.hash, "__DYNAMIC", true, false,
276 einfo ("%P%F: bfd_link_hash_lookup: %E\n");
277 if (! bfd_sunos_record_link_assignment (output_bfd, &link_info,
279 einfo ("%P%F: failed to record assignment to __DYNAMIC: %E\n");
282 /* If we are going to make any variable assignments, we need to let
283 the backend linker know about them in case the variables are
284 referred to by dynamic objects. */
285 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
287 /* Let the backend linker work out the sizes of any sections
288 required by dynamic linking. */
289 if (! bfd_sunos_size_dynamic_sections (output_bfd, &link_info, &sdyn,
291 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
295 /* Set up the .need section. See the description of the ld_need
296 field in include/sun4/aout.h. */
301 lang_for_each_input_file (gld${EMULATION_NAME}_count_need);
303 /* We should only have a .need section if we have at least one
305 ASSERT (need_entries != 0);
307 sneed->_raw_size = need_size;
308 sneed->contents = (bfd_byte *) xmalloc (need_size);
310 need_contents = sneed->contents;
311 need_pinfo = sneed->contents;
312 need_pnames = sneed->contents + need_entries * 16;
314 lang_for_each_input_file (gld${EMULATION_NAME}_set_need);
316 ASSERT (need_pnames - sneed->contents == need_size);
322 search_dirs_type *search;
324 /* Set up the .rules section. This is just a PATH like string
325 of the -L arguments given on the command line. */
327 for (search = search_head; search != NULL; search = search->next)
329 size += strlen (search->name) + 1;
330 srules->_raw_size = size;
335 srules->contents = (bfd_byte *) xmalloc (size);
336 p = (char *) srules->contents;
338 for (search = search_head; search != NULL; search = search->next)
342 if (p != (char *) srules->contents)
344 strcpy (p, search->name);
351 /* We must assign a value to __DYNAMIC. It should be zero if we are
352 not doing a dynamic link, or the start of the .dynamic section if
354 if (! link_info.relocateable)
356 h->type = bfd_link_hash_defined;
359 h->u.def.section = sdyn;
361 h->u.def.section = &bfd_abs_section;
365 /* This is called by the before_allocation routine via
366 lang_for_each_statement. It locates any assignment statements, and
367 tells the backend linker about them, in case they are assignments
368 to symbols which are referred to by dynamic objects. */
371 gld${EMULATION_NAME}_find_statement_assignment (s)
372 lang_statement_union_type *s;
374 if (s->header.type == lang_assignment_statement_enum)
375 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
378 /* Look through an expression for an assignment statement. */
381 gld${EMULATION_NAME}_find_exp_assignment (exp)
384 switch (exp->type.node_class)
387 if (strcmp (exp->assign.dst, ".") != 0)
389 if (! bfd_sunos_record_link_assignment (output_bfd, &link_info,
391 einfo ("%P%F: failed to record assignment to %s: %E\n",
394 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
398 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
399 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
403 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
404 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
405 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
409 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
417 /* Work out the size of the .need section, and the number of entries.
418 The backend will set the ld_need field of the dynamic linking
419 information to point to the .need section. See include/aout/sun4.h
420 for more information. */
423 gld${EMULATION_NAME}_count_need (inp)
424 lang_input_statement_type *inp;
426 if (inp->the_bfd != NULL
427 && (inp->the_bfd->flags & DYNAMIC) != 0)
430 need_size += NEED_ENTRY_SIZE;
431 if (! inp->is_archive)
432 need_size += strlen (inp->filename) + 1;
435 ASSERT (inp->local_sym_name[0] == '-'
436 && inp->local_sym_name[1] == 'l');
437 need_size += strlen (inp->local_sym_name + 2) + 1;
442 /* Fill in the contents of the .need section. */
445 gld${EMULATION_NAME}_set_need (inp)
446 lang_input_statement_type *inp;
448 if (inp->the_bfd != NULL
449 && (inp->the_bfd->flags & DYNAMIC) != 0)
453 /* To really fill in the .need section contents, we need to know
454 the final file position of the section, but we don't.
455 Instead, we use offsets, and rely on the BFD backend to
456 finish the section up correctly. FIXME: Talk about lack of
457 referential locality. */
458 bfd_put_32 (output_bfd, need_pnames - need_contents, need_pinfo);
459 if (! inp->is_archive)
461 bfd_put_32 (output_bfd, (bfd_vma) 0, need_pinfo + 4);
462 bfd_put_16 (output_bfd, (bfd_vma) 0, need_pinfo + 8);
463 bfd_put_16 (output_bfd, (bfd_vma) 0, need_pinfo + 10);
464 strcpy (need_pnames, inp->filename);
471 bfd_put_32 (output_bfd, (bfd_vma) 0x80000000, need_pinfo + 4);
474 verstr = strstr (inp->filename, ".so.");
476 sscanf (verstr, ".so.%d.%d", &maj, &min);
477 bfd_put_16 (output_bfd, (bfd_vma) maj, need_pinfo + 8);
478 bfd_put_16 (output_bfd, (bfd_vma) min, need_pinfo + 10);
479 strcpy (need_pnames, inp->local_sym_name + 2);
482 c = (need_pinfo - need_contents) / NEED_ENTRY_SIZE;
483 if (c + 1 >= need_entries)
484 bfd_put_32 (output_bfd, (bfd_vma) 0, need_pinfo + 12);
486 bfd_put_32 (output_bfd, (bfd_vma) (c + 1) * NEED_ENTRY_SIZE,
489 need_pinfo += NEED_ENTRY_SIZE;
490 need_pnames += strlen (need_pnames) + 1;
495 gld${EMULATION_NAME}_get_script(isfile)
499 if test -n "$COMPILE_IN"
501 # Scripts compiled in.
503 # sed commands to quote an ld script as a C string.
510 cat >>e${EMULATION_NAME}.c <<EOF
514 if (link_info.relocateable == true && config.build_constructors == true)
515 return `sed "$sc" ldscripts/${EMULATION_NAME}.xu`;
516 else if (link_info.relocateable == true)
517 return `sed "$sc" ldscripts/${EMULATION_NAME}.xr`;
518 else if (!config.text_read_only)
519 return `sed "$sc" ldscripts/${EMULATION_NAME}.xbn`;
520 else if (!config.magic_demand_paged)
521 return `sed "$sc" ldscripts/${EMULATION_NAME}.xn`;
523 return `sed "$sc" ldscripts/${EMULATION_NAME}.x`;
528 # Scripts read from the filesystem.
530 cat >>e${EMULATION_NAME}.c <<EOF
534 if (link_info.relocateable == true && config.build_constructors == true)
535 return "ldscripts/${EMULATION_NAME}.xu";
536 else if (link_info.relocateable == true)
537 return "ldscripts/${EMULATION_NAME}.xr";
538 else if (!config.text_read_only)
539 return "ldscripts/${EMULATION_NAME}.xbn";
540 else if (!config.magic_demand_paged)
541 return "ldscripts/${EMULATION_NAME}.xn";
543 return "ldscripts/${EMULATION_NAME}.x";
549 cat >>e${EMULATION_NAME}.c <<EOF
551 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
553 gld${EMULATION_NAME}_before_parse,
557 after_allocation_default,
558 set_output_arch_default,
559 ldemul_default_target,
560 gld${EMULATION_NAME}_before_allocation,
561 gld${EMULATION_NAME}_get_script,
565 gld${EMULATION_NAME}_create_output_section_statements