1# This shell script emits a C file. -*- C -*- 2# It does some substitutions. 3if [ -z "$MACHINE" ]; then 4 OUTPUT_ARCH=${ARCH} 5else 6 OUTPUT_ARCH=${ARCH}:${MACHINE} 7fi 8fragment <<EOF 9/* This file is is generated by a shell script. DO NOT EDIT! */ 10 11/* SunOS emulation code for ${EMULATION_NAME} 12 Copyright (C) 1991-2014 Free Software Foundation, Inc. 13 Written by Steve Chamberlain <sac@cygnus.com> 14 SunOS shared library support by Ian Lance Taylor <ian@cygnus.com> 15 16 This file is part of the GNU Binutils. 17 18 This program is free software; you can redistribute it and/or modify 19 it under the terms of the GNU General Public License as published by 20 the Free Software Foundation; either version 3 of the License, or 21 (at your option) any later version. 22 23 This program is distributed in the hope that it will be useful, 24 but WITHOUT ANY WARRANTY; without even the implied warranty of 25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 26 GNU General Public License for more details. 27 28 You should have received a copy of the GNU General Public License 29 along with this program; if not, write to the Free Software 30 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 31 MA 02110-1301, USA. */ 32 33#define TARGET_IS_${EMULATION_NAME} 34 35#include "sysdep.h" 36#include "bfd.h" 37#include "bfdlink.h" 38#include "libiberty.h" 39#include "safe-ctype.h" 40 41#include "ld.h" 42#include "ldmain.h" 43#include "ldmisc.h" 44#include "ldexp.h" 45#include "ldlang.h" 46#include "ldfile.h" 47#include "ldemul.h" 48 49#ifdef HAVE_DIRENT_H 50# include <dirent.h> 51#else 52# define dirent direct 53# ifdef HAVE_SYS_NDIR_H 54# include <sys/ndir.h> 55# endif 56# ifdef HAVE_SYS_DIR_H 57# include <sys/dir.h> 58# endif 59# ifdef HAVE_NDIR_H 60# include <ndir.h> 61# endif 62#endif 63 64static void gld${EMULATION_NAME}_find_so 65 (lang_input_statement_type *); 66static char *gld${EMULATION_NAME}_search_dir 67 (const char *, const char *, bfd_boolean *); 68static void gld${EMULATION_NAME}_check_needed 69 (lang_input_statement_type *); 70static bfd_boolean gld${EMULATION_NAME}_search_needed 71 (const char *, const char *); 72static bfd_boolean gld${EMULATION_NAME}_try_needed 73 (const char *, const char *); 74static void gld${EMULATION_NAME}_find_assignment 75 (lang_statement_union_type *); 76static void gld${EMULATION_NAME}_find_exp_assignment 77 (etree_type *); 78static void gld${EMULATION_NAME}_count_need 79 (lang_input_statement_type *); 80static void gld${EMULATION_NAME}_set_need 81 (lang_input_statement_type *); 82 83static void 84gld${EMULATION_NAME}_before_parse (void) 85{ 86 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`); 87 input_flags.dynamic = TRUE; 88 config.has_shared = TRUE; 89} 90 91/* This is called after the command line arguments have been parsed, 92 but before the linker script has been read. If this is a native 93 linker, we add the directories in LD_LIBRARY_PATH to the search 94 list. */ 95 96static void 97gld${EMULATION_NAME}_set_symbols (void) 98{ 99EOF 100if [ "x${host}" = "x${target}" ] ; then 101 case " ${EMULATION_LIBPATH} " in 102 *" ${EMULATION_NAME} "*) 103fragment <<EOF 104 const char *env; 105 106 env = (const char *) getenv ("LD_LIBRARY_PATH"); 107 if (env != NULL) 108 { 109 char *l; 110 111 l = xstrdup (env); 112 while (1) 113 { 114 char *c; 115 116 c = strchr (l, ':'); 117 if (c != NULL) 118 *c++ = '\0'; 119 if (*l != '\0') 120 ldfile_add_library_path (l, FALSE); 121 if (c == NULL) 122 break; 123 l = c; 124 } 125 } 126EOF 127 ;; 128 esac 129fi 130fragment <<EOF 131} 132 133/* Despite the name, we use this routine to search for dynamic 134 libraries. On SunOS this requires a directory search. We need to 135 find the .so file with the highest version number. The user may 136 restrict the major version by saying, e.g., -lc.1. Also, if we 137 find a .so file, we need to look for a the same file after 138 replacing .so with .sa; if it exists, it will be an archive which 139 provide some initializations for data symbols, and we need to 140 search it after including the .so file. */ 141 142static void 143gld${EMULATION_NAME}_create_output_section_statements (void) 144{ 145 lang_for_each_input_file (gld${EMULATION_NAME}_find_so); 146} 147 148/* Search the directory for a .so file for each library search. */ 149 150static void 151gld${EMULATION_NAME}_find_so (lang_input_statement_type *inp) 152{ 153 search_dirs_type *search; 154 char *found = NULL; 155 char *alc; 156 struct stat st; 157 158 if (! inp->flags.search_dirs 159 || ! inp->flags.maybe_archive 160 || ! inp->flags.dynamic) 161 return; 162 163 ASSERT (CONST_STRNEQ (inp->local_sym_name, "-l")); 164 165 for (search = search_head; search != NULL; search = search->next) 166 { 167 bfd_boolean found_static; 168 169 found = gld${EMULATION_NAME}_search_dir (search->name, inp->filename, 170 &found_static); 171 if (found != NULL || found_static) 172 break; 173 } 174 175 if (found == NULL) 176 { 177 /* We did not find a matching .so file. This isn't an error, 178 since there might still be a matching .a file, which will be 179 found by the usual search. */ 180 return; 181 } 182 183 /* Replace the filename with the one we have found. */ 184 alc = (char *) xmalloc (strlen (search->name) + strlen (found) + 2); 185 sprintf (alc, "%s/%s", search->name, found); 186 inp->filename = alc; 187 188 /* Turn off the search_dirs_flag to prevent ldfile_open_file from 189 searching for this file again. */ 190 inp->flags.search_dirs = FALSE; 191 192 free (found); 193 194 /* Now look for the same file name, but with .sa instead of .so. If 195 found, add it to the list of input files. */ 196 alc = (char *) xmalloc (strlen (inp->filename) + 1); 197 strcpy (alc, inp->filename); 198 strstr (alc + strlen (search->name), ".so")[2] = 'a'; 199 if (stat (alc, &st) != 0) 200 free (alc); 201 else 202 { 203 lang_input_statement_type *sa; 204 205 /* Add the .sa file to the statement list just before the .so 206 file. This is really a hack. */ 207 sa = ((lang_input_statement_type *) 208 xmalloc (sizeof (lang_input_statement_type))); 209 *sa = *inp; 210 211 inp->filename = alc; 212 inp->local_sym_name = alc; 213 214 inp->header.next = (lang_statement_union_type *) sa; 215 inp->next_real_file = (lang_statement_union_type *) sa; 216 } 217} 218 219/* Search a directory for a .so file. */ 220 221static char * 222gld${EMULATION_NAME}_search_dir 223 (const char *dirname, const char *filename, bfd_boolean *found_static) 224{ 225 int force_maj, force_min; 226 const char *dot; 227 unsigned int len; 228 char *alc; 229 char *found; 230 int max_maj, max_min; 231 DIR *dir; 232 struct dirent *entry; 233 unsigned int dirnamelen; 234 char *full_path; 235 int statval; 236 struct stat st; 237 238 *found_static = FALSE; 239 240 force_maj = -1; 241 force_min = -1; 242 dot = strchr (filename, '.'); 243 if (dot == NULL) 244 { 245 len = strlen (filename); 246 alc = NULL; 247 } 248 else 249 { 250 force_maj = atoi (dot + 1); 251 252 len = dot - filename; 253 alc = (char *) xmalloc (len + 1); 254 strncpy (alc, filename, len); 255 alc[len] = '\0'; 256 filename = alc; 257 258 dot = strchr (dot + 1, '.'); 259 if (dot != NULL) 260 force_min = atoi (dot + 1); 261 } 262 263 found = NULL; 264 max_maj = max_min = 0; 265 266 dir = opendir (dirname); 267 if (dir == NULL) 268 return NULL; 269 dirnamelen = strlen (dirname); 270 271 while ((entry = readdir (dir)) != NULL) 272 { 273 const char *s; 274 int found_maj, found_min; 275 276 if (! CONST_STRNEQ (entry->d_name, "lib") 277 || strncmp (entry->d_name + 3, filename, len) != 0) 278 continue; 279 280 if (dot == NULL 281 && strcmp (entry->d_name + 3 + len, ".a") == 0) 282 { 283 *found_static = TRUE; 284 continue; 285 } 286 287 /* We accept libfoo.so without a version number, even though the 288 native linker does not. This is more convenient for packages 289 which just generate .so files for shared libraries, as on ELF 290 systems. */ 291 if (! CONST_STRNEQ (entry->d_name + 3 + len, ".so")) 292 continue; 293 if (entry->d_name[6 + len] == '\0') 294 ; 295 else if (entry->d_name[6 + len] == '.' 296 && ISDIGIT (entry->d_name[7 + len])) 297 ; 298 else 299 continue; 300 301 for (s = entry->d_name + 6 + len; *s != '\0'; s++) 302 if (*s != '.' && ! ISDIGIT (*s)) 303 break; 304 if (*s != '\0') 305 continue; 306 307 /* We've found a .so file. Work out the major and minor 308 version numbers. */ 309 found_maj = 0; 310 found_min = 0; 311 sscanf (entry->d_name + 3 + len, ".so.%d.%d", 312 &found_maj, &found_min); 313 314 if ((force_maj != -1 && force_maj != found_maj) 315 || (force_min != -1 && force_min != found_min)) 316 continue; 317 318 /* Make sure the file really exists (ignore broken symlinks). */ 319 full_path = xmalloc (dirnamelen + 1 + strlen (entry->d_name) + 1); 320 sprintf (full_path, "%s/%s", dirname, entry->d_name); 321 statval = stat (full_path, &st); 322 free (full_path); 323 if (statval != 0) 324 continue; 325 326 /* We've found a match for the name we are searching for. See 327 if this is the version we should use. If the major and minor 328 versions match, we use the last entry in alphabetical order; 329 I don't know if this is how SunOS distinguishes libc.so.1.8 330 from libc.so.1.8.1, but it ought to suffice. */ 331 if (found == NULL 332 || (found_maj > max_maj) 333 || (found_maj == max_maj 334 && (found_min > max_min 335 || (found_min == max_min 336 && strcmp (entry->d_name, found) > 0)))) 337 { 338 if (found != NULL) 339 free (found); 340 found = (char *) xmalloc (strlen (entry->d_name) + 1); 341 strcpy (found, entry->d_name); 342 max_maj = found_maj; 343 max_min = found_min; 344 } 345 } 346 347 closedir (dir); 348 349 if (alc != NULL) 350 free (alc); 351 352 return found; 353} 354 355/* These variables are required to pass information back and forth 356 between after_open and check_needed. */ 357 358static struct bfd_link_needed_list *global_needed; 359static bfd_boolean global_found; 360 361/* This is called after all the input files have been opened. */ 362 363static void 364gld${EMULATION_NAME}_after_open (void) 365{ 366 struct bfd_link_needed_list *needed, *l; 367 368 after_open_default (); 369 370 /* We only need to worry about this when doing a final link. */ 371 if (link_info.relocatable || link_info.shared) 372 return; 373 374 /* Get the list of files which appear in ld_need entries in dynamic 375 objects included in the link. For each such file, we want to 376 track down the corresponding library, and include the symbol 377 table in the link. This is what the runtime dynamic linker will 378 do. Tracking the files down here permits one dynamic object to 379 include another without requiring special action by the person 380 doing the link. Note that the needed list can actually grow 381 while we are stepping through this loop. */ 382 needed = bfd_sunos_get_needed_list (link_info.output_bfd, &link_info); 383 for (l = needed; l != NULL; l = l->next) 384 { 385 struct bfd_link_needed_list *ll; 386 const char *lname; 387 search_dirs_type *search; 388 389 lname = l->name; 390 391 /* If we've already seen this file, skip it. */ 392 for (ll = needed; ll != l; ll = ll->next) 393 if (strcmp (ll->name, lname) == 0) 394 break; 395 if (ll != l) 396 continue; 397 398 /* See if this file was included in the link explicitly. */ 399 global_needed = l; 400 global_found = FALSE; 401 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed); 402 if (global_found) 403 continue; 404 405 if (! CONST_STRNEQ (lname, "-l")) 406 { 407 bfd *abfd; 408 409 abfd = bfd_openr (lname, bfd_get_target (link_info.output_bfd)); 410 if (abfd != NULL) 411 { 412 if (! bfd_check_format (abfd, bfd_object)) 413 { 414 (void) bfd_close (abfd); 415 abfd = NULL; 416 } 417 } 418 if (abfd != NULL) 419 { 420 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0) 421 { 422 (void) bfd_close (abfd); 423 abfd = NULL; 424 } 425 } 426 if (abfd != NULL) 427 { 428 /* We've found the needed dynamic object. */ 429 if (! bfd_link_add_symbols (abfd, &link_info)) 430 einfo ("%F%B: error adding symbols: %E\n", abfd); 431 } 432 else 433 { 434 einfo ("%P: warning: %s, needed by %B, not found\n", 435 lname, l->by); 436 } 437 438 continue; 439 } 440 441 lname += 2; 442 443 /* We want to search for the file in the same way that the 444 dynamic linker will search. That means that we want to use 445 rpath_link, rpath or -L, then the environment variable 446 LD_LIBRARY_PATH (native only), then (if rpath was used) the 447 linker script LIB_SEARCH_DIRS. */ 448 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link, 449 lname)) 450 continue; 451 if (command_line.rpath != NULL) 452 { 453 if (gld${EMULATION_NAME}_search_needed (command_line.rpath, lname)) 454 continue; 455 } 456 else 457 { 458 for (search = search_head; search != NULL; search = search->next) 459 if (gld${EMULATION_NAME}_try_needed (search->name, lname)) 460 break; 461 if (search != NULL) 462 continue; 463 } 464EOF 465if [ "x${host}" = "x${target}" ] ; then 466 case " ${EMULATION_LIBPATH} " in 467 *" ${EMULATION_NAME} "*) 468fragment <<EOF 469 { 470 const char *lib_path; 471 472 lib_path = (const char *) getenv ("LD_LIBRARY_PATH"); 473 if (gld${EMULATION_NAME}_search_needed (lib_path, lname)) 474 continue; 475 } 476EOF 477 ;; 478 esac 479fi 480fragment <<EOF 481 if (command_line.rpath != NULL) 482 { 483 for (search = search_head; search != NULL; search = search->next) 484 { 485 if (search->cmdline) 486 continue; 487 if (gld${EMULATION_NAME}_try_needed (search->name, lname)) 488 break; 489 } 490 if (search != NULL) 491 continue; 492 } 493 494 einfo ("%P: warning: %s, needed by %B, not found\n", 495 l->name, l->by); 496 } 497} 498 499/* Search for a needed file in a path. */ 500 501static bfd_boolean 502gld${EMULATION_NAME}_search_needed (const char *path, const char *name) 503{ 504 const char *s; 505 506 if (path == NULL || *path == '\0') 507 return FALSE; 508 while (1) 509 { 510 const char *dir; 511 char *dircopy; 512 513 s = strchr (path, ':'); 514 if (s == NULL) 515 { 516 dircopy = NULL; 517 dir = path; 518 } 519 else 520 { 521 dircopy = (char *) xmalloc (s - path + 1); 522 memcpy (dircopy, path, s - path); 523 dircopy[s - path] = '\0'; 524 dir = dircopy; 525 } 526 527 if (gld${EMULATION_NAME}_try_needed (dir, name)) 528 return TRUE; 529 530 if (dircopy != NULL) 531 free (dircopy); 532 533 if (s == NULL) 534 break; 535 path = s + 1; 536 } 537 538 return FALSE; 539} 540 541/* This function is called for each possible directory for a needed 542 dynamic object. */ 543 544static bfd_boolean 545gld${EMULATION_NAME}_try_needed (const char *dir, const char *name) 546{ 547 char *file; 548 char *alc; 549 bfd_boolean ignore; 550 bfd *abfd; 551 552 file = gld${EMULATION_NAME}_search_dir (dir, name, &ignore); 553 if (file == NULL) 554 return FALSE; 555 556 alc = (char *) xmalloc (strlen (dir) + strlen (file) + 2); 557 sprintf (alc, "%s/%s", dir, file); 558 free (file); 559 abfd = bfd_openr (alc, bfd_get_target (link_info.output_bfd)); 560 if (abfd == NULL) 561 return FALSE; 562 if (! bfd_check_format (abfd, bfd_object)) 563 { 564 (void) bfd_close (abfd); 565 return FALSE; 566 } 567 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0) 568 { 569 (void) bfd_close (abfd); 570 return FALSE; 571 } 572 573 /* We've found the needed dynamic object. */ 574 575 /* Add this file into the symbol table. */ 576 if (! bfd_link_add_symbols (abfd, &link_info)) 577 einfo ("%F%B: error adding symbols: %E\n", abfd); 578 579 return TRUE; 580} 581 582/* See if we have already included a needed object in the link. This 583 does not have to be precise, as it does no harm to include a 584 dynamic object more than once. */ 585 586static void 587gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s) 588{ 589 if (s->filename == NULL) 590 return; 591 if (! CONST_STRNEQ (global_needed->name, "-l")) 592 { 593 if (strcmp (s->filename, global_needed->name) == 0) 594 global_found = TRUE; 595 } 596 else 597 { 598 const char *sname, *lname; 599 const char *sdot, *ldot; 600 int lmaj, lmin, smaj, smin; 601 602 lname = global_needed->name + 2; 603 604 sname = strrchr (s->filename, '/'); 605 if (sname == NULL) 606 sname = s->filename; 607 else 608 ++sname; 609 610 if (! CONST_STRNEQ (sname, "lib")) 611 return; 612 sname += 3; 613 614 ldot = strchr (lname, '.'); 615 if (ldot == NULL) 616 ldot = lname + strlen (lname); 617 618 sdot = strstr (sname, ".so."); 619 if (sdot == NULL) 620 return; 621 622 if (sdot - sname != ldot - lname 623 || strncmp (lname, sname, sdot - sname) != 0) 624 return; 625 626 lmaj = lmin = -1; 627 sscanf (ldot, ".%d.%d", &lmaj, &lmin); 628 smaj = smin = -1; 629 sscanf (sdot, ".so.%d.%d", &smaj, &smin); 630 if ((smaj != lmaj && smaj != -1 && lmaj != -1) 631 || (smin != lmin && smin != -1 && lmin != -1)) 632 return; 633 634 global_found = TRUE; 635 } 636} 637 638/* We need to use static variables to pass information around the call 639 to lang_for_each_statement. Ick. */ 640 641static const char *find_assign; 642static bfd_boolean found_assign; 643 644/* We need to use static variables to pass information around the call 645 to lang_for_each_input_file. Ick. */ 646 647static bfd_size_type need_size; 648static bfd_size_type need_entries; 649static bfd_byte *need_contents; 650static bfd_byte *need_pinfo; 651static bfd_byte *need_pnames; 652 653/* The size of one entry in the .need section, not including the file 654 name. */ 655 656#define NEED_ENTRY_SIZE (16) 657 658/* This is called after the sections have been attached to output 659 sections, but before any sizes or addresses have been set. */ 660 661static void 662gld${EMULATION_NAME}_before_allocation (void) 663{ 664 struct bfd_link_hash_entry *hdyn = NULL; 665 asection *sneed; 666 asection *srules; 667 asection *sdyn; 668 669 /* The SunOS native linker creates a shared library whenever there 670 are any undefined symbols in a link, unless -e is used. This is 671 pretty weird, but we are compatible. */ 672 if (! link_info.shared && ! link_info.relocatable && ! entry_from_cmdline) 673 { 674 struct bfd_link_hash_entry *h; 675 676 for (h = link_info.hash->undefs; h != NULL; h = h->u.undef.next) 677 { 678 if (h->type == bfd_link_hash_undefined 679 && h->u.undef.abfd != NULL 680 && (h->u.undef.abfd->flags & DYNAMIC) == 0 681 && strcmp (h->root.string, "__DYNAMIC") != 0 682 && strcmp (h->root.string, "__GLOBAL_OFFSET_TABLE_") != 0) 683 { 684 find_assign = h->root.string; 685 found_assign = FALSE; 686 lang_for_each_statement (gld${EMULATION_NAME}_find_assignment); 687 if (! found_assign) 688 { 689 link_info.shared = TRUE; 690 break; 691 } 692 } 693 } 694 } 695 696 if (link_info.shared) 697 { 698 lang_output_section_statement_type *os; 699 700 /* Set the .text section to start at 0x20, not 0x2020. FIXME: 701 This is too magical. */ 702 os = lang_output_section_statement_lookup (".text", 0, TRUE); 703 if (os->addr_tree == NULL) 704 os->addr_tree = exp_intop (0x20); 705 } 706 707 /* We need to create a __DYNAMIC symbol. We don't do this in the 708 linker script because we want to set the value to the start of 709 the dynamic section if there is one, or to zero if there isn't 710 one. We need to create the symbol before calling 711 size_dynamic_sections, although we can't set the value until 712 afterward. */ 713 if (! link_info.relocatable) 714 { 715 hdyn = bfd_link_hash_lookup (link_info.hash, "__DYNAMIC", TRUE, FALSE, 716 FALSE); 717 if (hdyn == NULL) 718 einfo ("%P%F: bfd_link_hash_lookup: %E\n"); 719 if (! bfd_sunos_record_link_assignment (link_info.output_bfd, &link_info, 720 "__DYNAMIC")) 721 einfo ("%P%F: failed to record assignment to __DYNAMIC: %E\n"); 722 } 723 724 /* If we are going to make any variable assignments, we need to let 725 the backend linker know about them in case the variables are 726 referred to by dynamic objects. */ 727 lang_for_each_statement (gld${EMULATION_NAME}_find_assignment); 728 729 /* Let the backend linker work out the sizes of any sections 730 required by dynamic linking. */ 731 if (! bfd_sunos_size_dynamic_sections (link_info.output_bfd, &link_info, 732 &sdyn, &sneed, &srules)) 733 einfo ("%P%F: failed to set dynamic section sizes: %E\n"); 734 735 if (sneed != NULL) 736 { 737 /* Set up the .need section. See the description of the ld_need 738 field in include/aout/sun4.h. */ 739 740 need_entries = 0; 741 need_size = 0; 742 743 lang_for_each_input_file (gld${EMULATION_NAME}_count_need); 744 745 /* We should only have a .need section if we have at least one 746 dynamic object. */ 747 ASSERT (need_entries != 0); 748 749 sneed->size = need_size; 750 sneed->contents = (bfd_byte *) xmalloc (need_size); 751 752 need_contents = sneed->contents; 753 need_pinfo = sneed->contents; 754 need_pnames = sneed->contents + need_entries * 16; 755 756 lang_for_each_input_file (gld${EMULATION_NAME}_set_need); 757 758 ASSERT ((bfd_size_type) (need_pnames - sneed->contents) == need_size); 759 } 760 761 if (srules != NULL) 762 { 763 /* Set up the .rules section. This is just a PATH like string 764 of the -L arguments given on the command line. We permit the 765 user to specify the directories using the -rpath command line 766 option. */ 767 if (command_line.rpath) 768 { 769 srules->size = strlen (command_line.rpath); 770 srules->contents = (bfd_byte *) command_line.rpath; 771 } 772 else 773 { 774 unsigned int size; 775 search_dirs_type *search; 776 777 size = 0; 778 for (search = search_head; search != NULL; search = search->next) 779 if (search->cmdline) 780 size += strlen (search->name) + 1; 781 srules->size = size; 782 if (size > 0) 783 { 784 char *p; 785 786 srules->contents = (bfd_byte *) xmalloc (size); 787 p = (char *) srules->contents; 788 *p = '\0'; 789 for (search = search_head; search != NULL; search = search->next) 790 { 791 if (search->cmdline) 792 { 793 if (p != (char *) srules->contents) 794 *p++ = ':'; 795 strcpy (p, search->name); 796 p += strlen (p); 797 } 798 } 799 } 800 } 801 } 802 803 /* We must assign a value to __DYNAMIC. It should be zero if we are 804 not doing a dynamic link, or the start of the .dynamic section if 805 we are doing one. */ 806 if (! link_info.relocatable) 807 { 808 hdyn->type = bfd_link_hash_defined; 809 hdyn->u.def.value = 0; 810 if (sdyn != NULL) 811 hdyn->u.def.section = sdyn; 812 else 813 hdyn->u.def.section = bfd_abs_section_ptr; 814 } 815 816 before_allocation_default (); 817} 818 819/* This is called by the before_allocation routine via 820 lang_for_each_statement. It does one of two things: if the 821 variable find_assign is set, it sets found_assign if it finds an 822 assignment to that variable; otherwise it tells the backend linker 823 about all assignment statements, in case they are assignments to 824 symbols which are referred to by dynamic objects. */ 825 826static void 827gld${EMULATION_NAME}_find_assignment (lang_statement_union_type *s) 828{ 829 if (s->header.type == lang_assignment_statement_enum 830 && (find_assign == NULL || ! found_assign)) 831 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp); 832} 833 834/* Look through an expression for an assignment statement. */ 835 836static void 837gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp) 838{ 839 switch (exp->type.node_class) 840 { 841 case etree_assign: 842 if (find_assign != NULL) 843 { 844 if (strcmp (find_assign, exp->assign.dst) == 0) 845 found_assign = TRUE; 846 return; 847 } 848 849 if (strcmp (exp->assign.dst, ".") != 0) 850 { 851 if (! bfd_sunos_record_link_assignment (link_info.output_bfd, 852 &link_info, 853 exp->assign.dst)) 854 einfo ("%P%F: failed to record assignment to %s: %E\n", 855 exp->assign.dst); 856 } 857 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src); 858 break; 859 860 case etree_binary: 861 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs); 862 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs); 863 break; 864 865 case etree_trinary: 866 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond); 867 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs); 868 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs); 869 break; 870 871 case etree_unary: 872 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child); 873 break; 874 875 default: 876 break; 877 } 878} 879 880/* Work out the size of the .need section, and the number of entries. 881 The backend will set the ld_need field of the dynamic linking 882 information to point to the .need section. See include/aout/sun4.h 883 for more information. */ 884 885static void 886gld${EMULATION_NAME}_count_need (lang_input_statement_type *inp) 887{ 888 if (inp->the_bfd != NULL 889 && (inp->the_bfd->flags & DYNAMIC) != 0) 890 { 891 ++need_entries; 892 need_size += NEED_ENTRY_SIZE; 893 if (! inp->flags.maybe_archive) 894 need_size += strlen (inp->filename) + 1; 895 else 896 { 897 ASSERT (inp->local_sym_name[0] == '-' 898 && inp->local_sym_name[1] == 'l'); 899 need_size += strlen (inp->local_sym_name + 2) + 1; 900 } 901 } 902} 903 904/* Fill in the contents of the .need section. */ 905 906static void 907gld${EMULATION_NAME}_set_need (lang_input_statement_type *inp) 908{ 909 if (inp->the_bfd != NULL 910 && (inp->the_bfd->flags & DYNAMIC) != 0) 911 { 912 bfd_size_type c; 913 914 /* To really fill in the .need section contents, we need to know 915 the final file position of the section, but we don't. 916 Instead, we use offsets, and rely on the BFD backend to 917 finish the section up correctly. FIXME: Talk about lack of 918 referential locality. */ 919 bfd_put_32 (link_info.output_bfd, need_pnames - need_contents, 920 need_pinfo); 921 if (! inp->flags.maybe_archive) 922 { 923 bfd_put_32 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 4); 924 bfd_put_16 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 8); 925 bfd_put_16 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 10); 926 strcpy ((char *) need_pnames, inp->filename); 927 } 928 else 929 { 930 char *verstr; 931 int maj, min; 932 933 bfd_put_32 (link_info.output_bfd, (bfd_vma) 0x80000000, 934 need_pinfo + 4); 935 maj = 0; 936 min = 0; 937 verstr = strstr (inp->filename, ".so."); 938 if (verstr != NULL) 939 sscanf (verstr, ".so.%d.%d", &maj, &min); 940 bfd_put_16 (link_info.output_bfd, (bfd_vma) maj, need_pinfo + 8); 941 bfd_put_16 (link_info.output_bfd, (bfd_vma) min, need_pinfo + 10); 942 strcpy ((char *) need_pnames, inp->local_sym_name + 2); 943 } 944 945 c = (need_pinfo - need_contents) / NEED_ENTRY_SIZE; 946 if (c + 1 >= need_entries) 947 bfd_put_32 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 12); 948 else 949 bfd_put_32 (link_info.output_bfd, (bfd_vma) (c + 1) * NEED_ENTRY_SIZE, 950 need_pinfo + 12); 951 952 need_pinfo += NEED_ENTRY_SIZE; 953 need_pnames += strlen ((char *) need_pnames) + 1; 954 } 955} 956 957static char * 958gld${EMULATION_NAME}_get_script (int *isfile) 959EOF 960 961if test x"$COMPILE_IN" = xyes 962then 963# Scripts compiled in. 964 965# sed commands to quote an ld script as a C string. 966sc="-f stringify.sed" 967 968fragment <<EOF 969{ 970 *isfile = 0; 971 972 if (link_info.relocatable && config.build_constructors) 973 return 974EOF 975sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c 976echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c 977sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c 978echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c 979sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c 980echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c 981sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c 982echo ' ; else return' >> e${EMULATION_NAME}.c 983sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c 984echo '; }' >> e${EMULATION_NAME}.c 985 986else 987# Scripts read from the filesystem. 988 989fragment <<EOF 990{ 991 *isfile = 1; 992 993 if (link_info.relocatable && config.build_constructors) 994 return "ldscripts/${EMULATION_NAME}.xu"; 995 else if (link_info.relocatable) 996 return "ldscripts/${EMULATION_NAME}.xr"; 997 else if (!config.text_read_only) 998 return "ldscripts/${EMULATION_NAME}.xbn"; 999 else if (!config.magic_demand_paged) 1000 return "ldscripts/${EMULATION_NAME}.xn"; 1001 else 1002 return "ldscripts/${EMULATION_NAME}.x"; 1003} 1004EOF 1005 1006fi 1007 1008fragment <<EOF 1009 1010struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = 1011{ 1012 gld${EMULATION_NAME}_before_parse, 1013 syslib_default, 1014 hll_default, 1015 after_parse_default, 1016 gld${EMULATION_NAME}_after_open, 1017 after_allocation_default, 1018 set_output_arch_default, 1019 ldemul_default_target, 1020 gld${EMULATION_NAME}_before_allocation, 1021 gld${EMULATION_NAME}_get_script, 1022 "${EMULATION_NAME}", 1023 "${OUTPUT_FORMAT}", 1024 finish_default, 1025 gld${EMULATION_NAME}_create_output_section_statements, 1026 NULL, /* open dynamic archive */ 1027 NULL, /* place orphan */ 1028 gld${EMULATION_NAME}_set_symbols, 1029 NULL, /* parse args */ 1030 NULL, /* add_options */ 1031 NULL, /* handle_option */ 1032 NULL, /* unrecognized file */ 1033 NULL, /* list options */ 1034 NULL, /* recognized file */ 1035 NULL, /* find_potential_libraries */ 1036 NULL, /* new_vers_pattern */ 1037 NULL /* extra_map_file_text */ 1038}; 1039EOF 1040