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 8cat >e${EMULATION_NAME}.c <<EOF 9/* This file is is generated by a shell script. DO NOT EDIT! */ 10 11/* AIX emulation code for ${EMULATION_NAME} 12 Copyright 1991, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 13 2003, 2004, 2005 14 Free Software Foundation, Inc. 15 Written by Steve Chamberlain <sac@cygnus.com> 16 AIX support by Ian Lance Taylor <ian@cygnus.com> 17 AIX 64 bit support by Tom Rix <trix@redhat.com> 18 19This file is part of GLD, the Gnu Linker. 20 21This program is free software; you can redistribute it and/or modify 22it under the terms of the GNU General Public License as published by 23the Free Software Foundation; either version 2 of the License, or 24(at your option) any later version. 25 26This program is distributed in the hope that it will be useful, 27but WITHOUT ANY WARRANTY; without even the implied warranty of 28MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 29GNU General Public License for more details. 30 31You should have received a copy of the GNU General Public License 32along with this program; if not, write to the Free Software 33Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 34 35#define TARGET_IS_${EMULATION_NAME} 36 37#include "bfd.h" 38#include "sysdep.h" 39#include "libiberty.h" 40#include "safe-ctype.h" 41#include "getopt.h" 42#include "obstack.h" 43#include "bfdlink.h" 44 45#include "ld.h" 46#include "ldmain.h" 47#include "ldmisc.h" 48#include "ldexp.h" 49#include "ldlang.h" 50#include "ldfile.h" 51#include "ldemul.h" 52#include "ldctor.h" 53#include <ldgram.h> 54 55#include "coff/internal.h" 56#include "coff/xcoff.h" 57#include "libcoff.h" 58#include "libxcoff.h" 59 60static void gld${EMULATION_NAME}_read_file (const char *, bfd_boolean); 61static void gld${EMULATION_NAME}_free (void *); 62static void gld${EMULATION_NAME}_find_relocs (lang_statement_union_type *); 63static void gld${EMULATION_NAME}_find_exp_assignment (etree_type *); 64 65 66/* The file alignment required for each section. */ 67static unsigned long file_align; 68 69/* The maximum size the stack is permitted to grow. This is stored in 70 the a.out header. */ 71static unsigned long maxstack; 72 73/* The maximum data size. This is stored in the a.out header. */ 74static unsigned long maxdata; 75 76/* Whether to perform garbage collection. */ 77static int gc = 1; 78 79/* The module type to use. */ 80static unsigned short modtype = ('1' << 8) | 'L'; 81 82/* Whether the .text section must be read-only (i.e., no relocs 83 permitted). */ 84static int textro; 85 86/* Whether to implement Unix like linker semantics. */ 87static int unix_ld; 88 89/* Structure used to hold import file list. */ 90 91struct filelist 92{ 93 struct filelist *next; 94 const char *name; 95}; 96 97/* List of import files. */ 98static struct filelist *import_files; 99 100/* List of export symbols read from the export files. */ 101 102struct export_symbol_list 103{ 104 struct export_symbol_list *next; 105 const char *name; 106}; 107 108static struct export_symbol_list *export_symbols; 109 110/* Maintains the 32 or 64 bit mode state of import file */ 111static unsigned int symbol_mode = 0x04; 112 113/* Which symbol modes are valid */ 114static unsigned int symbol_mode_mask = 0x0d; 115 116/* Whether this is a 64 bit link */ 117static int is_64bit = 0; 118 119/* Which syscalls from import file are valid */ 120static unsigned int syscall_mask = 0x77; 121 122/* fake file for -binitfini support */ 123static lang_input_statement_type *initfini_file; 124 125/* Whether to do run time linking 126 -brtl enables, -bnortl and -bnortllib disable. */ 127static int rtld; 128 129/* Explicit command line library path, -blibpath */ 130static char *command_line_blibpath = NULL; 131 132/* This routine is called before anything else is done. */ 133 134static void 135gld${EMULATION_NAME}_before_parse (void) 136{ 137 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`); 138 139 config.has_shared = TRUE; 140 141 /* The link_info.[init|fini]_functions are initialized in ld/lexsup.c. 142 Override them here so we can use the link_info.init_function as a 143 state flag that lets the backend know that -binitfini has been done. */ 144 145 link_info.init_function = NULL; 146 link_info.fini_function = NULL; 147} 148 149/* Handle AIX specific options. */ 150 151enum 152 { 153 OPTION_IGNORE = 300, 154 OPTION_AUTOIMP, 155 OPTION_ERNOTOK, 156 OPTION_EROK, 157 OPTION_EXPORT, 158 OPTION_IMPORT, 159 OPTION_INITFINI, 160 OPTION_LOADMAP, 161 OPTION_MAXDATA, 162 OPTION_MAXSTACK, 163 OPTION_MODTYPE, 164 OPTION_NOAUTOIMP, 165 OPTION_NOSTRCMPCT, 166 OPTION_PD, 167 OPTION_PT, 168 OPTION_STRCMPCT, 169 OPTION_UNIX, 170 OPTION_32, 171 OPTION_64, 172 OPTION_LIBPATH, 173 OPTION_NOLIBPATH, 174 }; 175 176static void 177gld${EMULATION_NAME}_add_options 178 (int ns, char **shortopts, int nl, struct option **longopts, 179 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED) 180{ 181 static const char xtra_short[] = "D:H:KT:z"; 182 static const struct option xtra_long[] = { 183 /* -binitfini has special handling in the linker backend. The native linker 184 uses the arguemnts to generate a table of init and fini functions for 185 the executable. The important use for this option is to support aix 4.2+ 186 c++ constructors and destructors. This is tied into gcc via collect2.c. 187 188 The function table is accessed by the runtime linker/loader by checking if 189 the first symbol in the loader symbol table is __rtinit. The gnu linker 190 generates this symbol and makes it the first loader symbol. */ 191 192 {"basis", no_argument, NULL, OPTION_IGNORE}, 193 {"bautoimp", no_argument, NULL, OPTION_AUTOIMP}, 194 {"bcomprld", no_argument, NULL, OPTION_IGNORE}, 195 {"bcrld", no_argument, NULL, OPTION_IGNORE}, 196 {"bcror31", no_argument, NULL, OPTION_IGNORE}, 197 {"bD", required_argument, NULL, OPTION_MAXDATA}, 198 {"bE", required_argument, NULL, OPTION_EXPORT}, 199 {"bernotok", no_argument, NULL, OPTION_ERNOTOK}, 200 {"berok", no_argument, NULL, OPTION_EROK}, 201 {"berrmsg", no_argument, NULL, OPTION_IGNORE}, 202 {"bexport", required_argument, NULL, OPTION_EXPORT}, 203 {"bf", no_argument, NULL, OPTION_ERNOTOK}, 204 {"bgc", no_argument, &gc, 1}, 205 {"bh", required_argument, NULL, OPTION_IGNORE}, 206 {"bhalt", required_argument, NULL, OPTION_IGNORE}, 207 {"bI", required_argument, NULL, OPTION_IMPORT}, 208 {"bimport", required_argument, NULL, OPTION_IMPORT}, 209 {"binitfini", required_argument, NULL, OPTION_INITFINI}, 210 {"bl", required_argument, NULL, OPTION_LOADMAP}, 211 {"bloadmap", required_argument, NULL, OPTION_LOADMAP}, 212 {"bmaxdata", required_argument, NULL, OPTION_MAXDATA}, 213 {"bmaxstack", required_argument, NULL, OPTION_MAXSTACK}, 214 {"bM", required_argument, NULL, OPTION_MODTYPE}, 215 {"bmodtype", required_argument, NULL, OPTION_MODTYPE}, 216 {"bnoautoimp", no_argument, NULL, OPTION_NOAUTOIMP}, 217 {"bnodelcsect", no_argument, NULL, OPTION_IGNORE}, 218 {"bnoentry", no_argument, NULL, OPTION_IGNORE}, 219 {"bnogc", no_argument, &gc, 0}, 220 {"bnso", no_argument, NULL, OPTION_NOAUTOIMP}, 221 {"bnostrcmpct", no_argument, NULL, OPTION_NOSTRCMPCT}, 222 {"bnotextro", no_argument, &textro, 0}, 223 {"bnro", no_argument, &textro, 0}, 224 {"bpD", required_argument, NULL, OPTION_PD}, 225 {"bpT", required_argument, NULL, OPTION_PT}, 226 {"bro", no_argument, &textro, 1}, 227 {"brtl", no_argument, &rtld, 1}, 228 {"bnortl", no_argument, &rtld, 0}, 229 {"bnortllib", no_argument, &rtld, 0}, 230 {"bS", required_argument, NULL, OPTION_MAXSTACK}, 231 {"bso", no_argument, NULL, OPTION_AUTOIMP}, 232 {"bstrcmpct", no_argument, NULL, OPTION_STRCMPCT}, 233 {"btextro", no_argument, &textro, 1}, 234 {"b32", no_argument, NULL, OPTION_32}, 235 {"b64", no_argument, NULL, OPTION_64}, 236 {"static", no_argument, NULL, OPTION_NOAUTOIMP}, 237 {"unix", no_argument, NULL, OPTION_UNIX}, 238 {"blibpath", required_argument, NULL, OPTION_LIBPATH}, 239 {"bnolibpath", required_argument, NULL, OPTION_NOLIBPATH}, 240 {NULL, no_argument, NULL, 0} 241 }; 242 243 /* Options supported by the AIX linker which we do not support: -f, 244 -S, -v, -Z, -bbindcmds, -bbinder, -bbindopts, -bcalls, -bcaps, 245 -bcror15, -bdebugopt, -bdbg, -bdelcsect, -bex?, -bfilelist, -bfl, 246 -bgcbypass, -bglink, -binsert, -bi, -bloadmap, -bl, -bmap, -bnl, 247 -bnobind, -bnocomprld, -bnocrld, -bnoerrmsg, -bnoglink, 248 -bnoloadmap, -bnl, -bnoobjreorder, -bnoquiet, -bnoreorder, 249 -bnotypchk, -bnox, -bquiet, -bR, -brename, -breorder, -btypchk, 250 -bx, -bX, -bxref. */ 251 252 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short)); 253 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short)); 254 *longopts = xrealloc (*longopts, 255 nl * sizeof (struct option) + sizeof (xtra_long)); 256 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long)); 257} 258 259static bfd_boolean 260gld${EMULATION_NAME}_parse_args (int argc, char **argv) 261{ 262 int indx; 263 264 /* If the current option starts with -b, change the first : to an =. 265 The AIX linker uses : to separate the option from the argument; 266 changing it to = lets us treat it as a getopt option. */ 267 indx = optind; 268 if (indx == 0) 269 indx = 1; 270 271 if (indx < argc && strncmp (argv[indx], "-b", 2) == 0) 272 { 273 char *s; 274 275 for (s = argv[indx]; *s != '\0'; s++) 276 { 277 if (*s == ':') 278 { 279 *s = '='; 280 break; 281 } 282 } 283 } 284 return FALSE; 285} 286 287static bfd_boolean 288gld${EMULATION_NAME}_handle_option (int optc) 289{ 290 bfd_signed_vma val; 291 const char *end; 292 293 switch (optc) 294 { 295 default: 296 return FALSE; 297 298 case 0: 299 /* Long option which just sets a flag. */ 300 break; 301 302 case 'D': 303 val = bfd_scan_vma (optarg, &end, 0); 304 if (*end != '\0') 305 einfo ("%P: warning: ignoring invalid -D number %s\n", optarg); 306 else if (val != -1) 307 lang_section_start (".data", exp_intop (val), NULL); 308 break; 309 310 case 'H': 311 val = bfd_scan_vma (optarg, &end, 0); 312 if (*end != '\0' || (val & (val - 1)) != 0) 313 einfo ("%P: warning: ignoring invalid -H number %s\n", optarg); 314 else 315 file_align = val; 316 break; 317 318 case 'K': 319 case 'z': 320 /* FIXME: This should use the page size for the target system. */ 321 file_align = 4096; 322 break; 323 324 case 'T': 325 /* On AIX this is the same as GNU ld -Ttext. When we see -T 326 number, we assume the AIX option is intended. Otherwise, we 327 assume the usual GNU ld -T option is intended. We can't just 328 ignore the AIX option, because gcc passes it to the linker. */ 329 val = bfd_scan_vma (optarg, &end, 0); 330 if (*end != '\0') 331 return FALSE; 332 lang_section_start (".text", exp_intop (val), NULL); 333 break; 334 335 case OPTION_IGNORE: 336 break; 337 338 case OPTION_INITFINI: 339 { 340 /* 341 * The aix linker init fini has the format : 342 * 343 * -binitfini:[ Initial][:Termination][:Priority] 344 * 345 * it allows the Termination and Priority to be optional. 346 * 347 * Since we support only one init/fini pair, we ignore the Priority. 348 * 349 * Define the special symbol __rtinit. 350 * 351 * strtok does not correctly handle the case of -binitfini::fini: so 352 * do it by hand 353 */ 354 char *t, *i, *f; 355 356 i = t = optarg; 357 while (*t && ':' != *t) 358 t++; 359 if (*t) 360 *t++ = 0; 361 362 if (0 != strlen (i)) 363 link_info.init_function = i; 364 365 f = t; 366 while (*t && ':' != *t) 367 t++; 368 *t = 0; 369 370 if (0 != strlen (f)) 371 link_info.fini_function = f; 372 } 373 break; 374 375 case OPTION_AUTOIMP: 376 link_info.static_link = FALSE; 377 break; 378 379 case OPTION_ERNOTOK: 380 force_make_executable = FALSE; 381 break; 382 383 case OPTION_EROK: 384 force_make_executable = TRUE; 385 break; 386 387 case OPTION_EXPORT: 388 gld${EMULATION_NAME}_read_file (optarg, FALSE); 389 break; 390 391 case OPTION_IMPORT: 392 { 393 struct filelist *n; 394 struct filelist **flpp; 395 396 n = (struct filelist *) xmalloc (sizeof (struct filelist)); 397 n->next = NULL; 398 n->name = optarg; 399 flpp = &import_files; 400 while (*flpp != NULL) 401 flpp = &(*flpp)->next; 402 *flpp = n; 403 } 404 break; 405 406 case OPTION_LOADMAP: 407 config.map_filename = optarg; 408 break; 409 410 case OPTION_MAXDATA: 411 val = bfd_scan_vma (optarg, &end, 0); 412 if (*end != '\0') 413 einfo ("%P: warning: ignoring invalid -bmaxdata number %s\n", optarg); 414 else 415 maxdata = val; 416 break; 417 418 case OPTION_MAXSTACK: 419 val = bfd_scan_vma (optarg, &end, 0); 420 if (*end != '\0') 421 einfo ("%P: warning: ignoring invalid -bmaxstack number %s\n", 422 optarg); 423 else 424 maxstack = val; 425 break; 426 427 case OPTION_MODTYPE: 428 if (*optarg == 'S') 429 { 430 link_info.shared = TRUE; 431 ++optarg; 432 } 433 if (*optarg == '\0' || optarg[1] == '\0') 434 einfo ("%P: warning: ignoring invalid module type %s\n", optarg); 435 else 436 modtype = (*optarg << 8) | optarg[1]; 437 break; 438 439 case OPTION_NOAUTOIMP: 440 link_info.static_link = TRUE; 441 break; 442 443 case OPTION_NOSTRCMPCT: 444 link_info.traditional_format = TRUE; 445 break; 446 447 case OPTION_PD: 448 /* This sets the page that the .data section is supposed to 449 start on. The offset within the page should still be the 450 offset within the file, so we need to build an appropriate 451 expression. */ 452 val = bfd_scan_vma (optarg, &end, 0); 453 if (*end != '\0') 454 einfo ("%P: warning: ignoring invalid -pD number %s\n", optarg); 455 else 456 { 457 etree_type *t; 458 459 t = exp_binop ('+', 460 exp_intop (val), 461 exp_binop ('&', 462 exp_nameop (NAME, "."), 463 exp_intop (0xfff))); 464 t = exp_binop ('&', 465 exp_binop ('+', t, exp_intop (31)), 466 exp_intop (~(bfd_vma) 31)); 467 lang_section_start (".data", t, NULL); 468 } 469 break; 470 471 case OPTION_PT: 472 /* This set the page that the .text section is supposed to start 473 on. The offset within the page should still be the offset 474 within the file. */ 475 val = bfd_scan_vma (optarg, &end, 0); 476 if (*end != '\0') 477 einfo ("%P: warning: ignoring invalid -pT number %s\n", optarg); 478 else 479 { 480 etree_type *t; 481 482 t = exp_binop ('+', 483 exp_intop (val), 484 exp_nameop (SIZEOF_HEADERS, NULL)); 485 t = exp_binop ('&', 486 exp_binop ('+', t, exp_intop (31)), 487 exp_intop (~(bfd_vma) 31)); 488 lang_section_start (".text", t, NULL); 489 } 490 break; 491 492 case OPTION_STRCMPCT: 493 link_info.traditional_format = FALSE; 494 break; 495 496 case OPTION_UNIX: 497 unix_ld = TRUE; 498 break; 499 500 case OPTION_32: 501 is_64bit = 0; 502 syscall_mask = 0x77; 503 symbol_mode_mask = 0x0d; 504 break; 505 506 case OPTION_64: 507 is_64bit = 1; 508 syscall_mask = 0xcc; 509 symbol_mode_mask = 0x0e; 510 break; 511 512 case OPTION_LIBPATH: 513 command_line_blibpath = optarg; 514 break; 515 516 case OPTION_NOLIBPATH: 517 command_line_blibpath = NULL; 518 break; 519 520 } 521 522 return TRUE; 523} 524 525/* This is called when an input file can not be recognized as a BFD 526 object or an archive. If the file starts with #!, we must treat it 527 as an import file. This is for AIX compatibility. */ 528 529static bfd_boolean 530gld${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry) 531{ 532 FILE *e; 533 bfd_boolean ret; 534 535 e = fopen (entry->filename, FOPEN_RT); 536 if (e == NULL) 537 return FALSE; 538 539 ret = FALSE; 540 541 if (getc (e) == '#' && getc (e) == '!') 542 { 543 struct filelist *n; 544 struct filelist **flpp; 545 546 n = (struct filelist *) xmalloc (sizeof (struct filelist)); 547 n->next = NULL; 548 n->name = entry->filename; 549 flpp = &import_files; 550 while (*flpp != NULL) 551 flpp = &(*flpp)->next; 552 *flpp = n; 553 554 ret = TRUE; 555 entry->loaded = TRUE; 556 } 557 558 fclose (e); 559 560 return ret; 561} 562 563/* This is called after the input files have been opened. */ 564 565static void 566gld${EMULATION_NAME}_after_open (void) 567{ 568 bfd_boolean r; 569 struct set_info *p; 570 571 /* Call ldctor_build_sets, after pretending that this is a 572 relocatable link. We do this because AIX requires relocation 573 entries for all references to symbols, even in a final 574 executable. Of course, we only want to do this if we are 575 producing an XCOFF output file. */ 576 r = link_info.relocatable; 577 if (strstr (bfd_get_target (output_bfd), "xcoff") != NULL) 578 link_info.relocatable = TRUE; 579 ldctor_build_sets (); 580 link_info.relocatable = r; 581 582 /* For each set, record the size, so that the XCOFF backend can 583 output the correct csect length. */ 584 for (p = sets; p != (struct set_info *) NULL; p = p->next) 585 { 586 bfd_size_type size; 587 588 /* If the symbol is defined, we may have been invoked from 589 collect, and the sets may already have been built, so we do 590 not do anything. */ 591 if (p->h->type == bfd_link_hash_defined 592 || p->h->type == bfd_link_hash_defweak) 593 continue; 594 595 if (p->reloc != BFD_RELOC_CTOR) 596 { 597 /* Handle this if we need to. */ 598 abort (); 599 } 600 601 size = (p->count + 2) * 4; 602 if (!bfd_xcoff_link_record_set (output_bfd, &link_info, p->h, size)) 603 einfo ("%F%P: bfd_xcoff_link_record_set failed: %E\n"); 604 } 605} 606 607/* This is called after the sections have been attached to output 608 sections, but before any sizes or addresses have been set. */ 609 610static void 611gld${EMULATION_NAME}_before_allocation (void) 612{ 613 struct filelist *fl; 614 struct export_symbol_list *el; 615 char *libpath; 616 asection *special_sections[XCOFF_NUMBER_OF_SPECIAL_SECTIONS]; 617 int i; 618 619 /* Handle the import and export files, if any. */ 620 for (fl = import_files; fl != NULL; fl = fl->next) 621 gld${EMULATION_NAME}_read_file (fl->name, TRUE); 622 for (el = export_symbols; el != NULL; el = el->next) 623 { 624 struct bfd_link_hash_entry *h; 625 626 h = bfd_link_hash_lookup (link_info.hash, el->name, FALSE, FALSE, FALSE); 627 if (h == NULL) 628 einfo ("%P%F: bfd_link_hash_lookup of export symbol failed: %E\n"); 629 if (!bfd_xcoff_export_symbol (output_bfd, &link_info, h)) 630 einfo ("%P%F: bfd_xcoff_export_symbol failed: %E\n"); 631 } 632 633 /* Track down all relocations called for by the linker script (these 634 are typically constructor/destructor entries created by 635 CONSTRUCTORS) and let the backend know it will need to create 636 .loader relocs for them. */ 637 lang_for_each_statement (gld${EMULATION_NAME}_find_relocs); 638 639 /* Precedence of LIBPATH 640 -blibpath: native support always first 641 -rpath: gnu extension 642 -L build from command line -L's */ 643 if (command_line_blibpath != NULL) 644 libpath = command_line_blibpath; 645 else if (command_line.rpath != NULL) 646 libpath = command_line.rpath; 647 else if (search_head == NULL) 648 libpath = (char *) ""; 649 else 650 { 651 size_t len; 652 search_dirs_type *search; 653 654 len = strlen (search_head->name); 655 libpath = xmalloc (len + 1); 656 strcpy (libpath, search_head->name); 657 for (search = search_head->next; search != NULL; search = search->next) 658 { 659 size_t nlen; 660 661 nlen = strlen (search->name); 662 libpath = xrealloc (libpath, len + nlen + 2); 663 libpath[len] = ':'; 664 strcpy (libpath + len + 1, search->name); 665 len += nlen + 1; 666 } 667 } 668 669 /* Let the XCOFF backend set up the .loader section. */ 670 if (!bfd_xcoff_size_dynamic_sections 671 (output_bfd, &link_info, libpath, entry_symbol.name, file_align, 672 maxstack, maxdata, gc && !unix_ld ? TRUE : FALSE, 673 modtype, textro ? TRUE : FALSE, unix_ld, special_sections, 674 rtld ? TRUE : FALSE)) 675 einfo ("%P%F: failed to set dynamic section sizes: %E\n"); 676 677 /* Look through the special sections, and put them in the right 678 place in the link ordering. This is especially magic. */ 679 for (i = 0; i < XCOFF_NUMBER_OF_SPECIAL_SECTIONS; i++) 680 { 681 asection *sec; 682 lang_output_section_statement_type *os; 683 lang_statement_union_type **pls; 684 lang_input_section_type *is; 685 const char *oname; 686 bfd_boolean start; 687 688 sec = special_sections[i]; 689 if (sec == NULL) 690 continue; 691 692 /* Remove this section from the list of the output section. 693 This assumes we know what the script looks like. */ 694 is = NULL; 695 os = lang_output_section_find (sec->output_section->name); 696 if (os == NULL) 697 einfo ("%P%F: can't find output section %s\n", 698 sec->output_section->name); 699 700 for (pls = &os->children.head; *pls != NULL; pls = &(*pls)->header.next) 701 { 702 if ((*pls)->header.type == lang_input_section_enum 703 && (*pls)->input_section.section == sec) 704 { 705 is = (lang_input_section_type *) * pls; 706 *pls = (*pls)->header.next; 707 break; 708 } 709 710 if ((*pls)->header.type == lang_wild_statement_enum) 711 { 712 lang_statement_union_type **pwls; 713 714 for (pwls = &(*pls)->wild_statement.children.head; 715 *pwls != NULL; pwls = &(*pwls)->header.next) 716 { 717 718 if ((*pwls)->header.type == lang_input_section_enum 719 && (*pwls)->input_section.section == sec) 720 { 721 is = (lang_input_section_type *) * pwls; 722 *pwls = (*pwls)->header.next; 723 break; 724 } 725 } 726 727 if (is != NULL) 728 break; 729 } 730 } 731 732 if (is == NULL) 733 { 734 einfo ("%P%F: can't find %s in output section\n", 735 bfd_get_section_name (sec->owner, sec)); 736 } 737 738 /* Now figure out where the section should go. */ 739 switch (i) 740 { 741 742 default: /* to avoid warnings */ 743 case XCOFF_SPECIAL_SECTION_TEXT: 744 /* _text */ 745 oname = ".text"; 746 start = TRUE; 747 break; 748 749 case XCOFF_SPECIAL_SECTION_ETEXT: 750 /* _etext */ 751 oname = ".text"; 752 start = FALSE; 753 break; 754 755 case XCOFF_SPECIAL_SECTION_DATA: 756 /* _data */ 757 oname = ".data"; 758 start = TRUE; 759 break; 760 761 case XCOFF_SPECIAL_SECTION_EDATA: 762 /* _edata */ 763 oname = ".data"; 764 start = FALSE; 765 break; 766 767 case XCOFF_SPECIAL_SECTION_END: 768 case XCOFF_SPECIAL_SECTION_END2: 769 /* _end and end */ 770 oname = ".bss"; 771 start = FALSE; 772 break; 773 } 774 775 os = lang_output_section_find (oname); 776 777 if (start) 778 { 779 is->header.next = os->children.head; 780 os->children.head = (lang_statement_union_type *) is; 781 } 782 else 783 { 784 is->header.next = NULL; 785 lang_statement_append (&os->children, 786 (lang_statement_union_type *) is, 787 &is->header.next); 788 } 789 } 790 791 before_allocation_default (); 792} 793 794static char * 795gld${EMULATION_NAME}_choose_target (int argc, char **argv) 796{ 797 int i, j, jmax; 798 static char *from_outside; 799 static char *from_inside; 800 static char *argv_to_target[][2] = { 801 {NULL, "${OUTPUT_FORMAT}"}, 802 {"-b32", "${OUTPUT_FORMAT_32BIT}"}, 803 {"-b64", "${OUTPUT_FORMAT_64BIT}"}, 804 }; 805 806 jmax = 3; 807 808 from_outside = getenv (TARGET_ENVIRON); 809 if (from_outside != (char *) NULL) 810 return from_outside; 811 812 /* Set to default. */ 813 from_inside = argv_to_target[0][1]; 814 for (i = 1; i < argc; i++) 815 { 816 for (j = 1; j < jmax; j++) 817 { 818 if (0 == strcmp (argv[i], argv_to_target[j][0])) 819 from_inside = argv_to_target[j][1]; 820 } 821 } 822 823 return from_inside; 824} 825 826/* Returns 827 1 : state changed 828 0 : no change */ 829static int 830change_symbol_mode (char *input) 831{ 832 char *symbol_mode_string[] = { 833 "# 32", /* 0x01 */ 834 "# 64", /* 0x02 */ 835 "# no32", /* 0x04 */ 836 "# no64", /* 0x08 */ 837 NULL, 838 }; 839 840 unsigned int bit; 841 char *string; 842 843 for (bit = 0;; bit++) 844 { 845 string = symbol_mode_string[bit]; 846 if (string == NULL) 847 return 0; 848 849 if (0 == strcmp (input, string)) 850 { 851 symbol_mode = (1 << bit); 852 return 1; 853 } 854 } 855 /* should not be here */ 856 return 0; 857} 858 859/* Returns 860 1 : yes 861 0 : ignore 862 -1 : error, try something else */ 863static int 864is_syscall (char *input, unsigned int *flag) 865{ 866 unsigned int bit; 867 char *string; 868 869 struct sc { 870 char *syscall_string; 871 unsigned int flag; 872 } s [] = { 873 { "svc" /* 0x01 */, XCOFF_SYSCALL32 }, 874 { "svc32" /* 0x02 */, XCOFF_SYSCALL32 }, 875 { "svc3264" /* 0x04 */, XCOFF_SYSCALL32 | XCOFF_SYSCALL64 }, 876 { "svc64" /* 0x08 */, XCOFF_SYSCALL64 }, 877 { "syscall" /* 0x10 */, XCOFF_SYSCALL32 }, 878 { "syscall32" /* 0x20 */, XCOFF_SYSCALL32 }, 879 { "syscall3264" /* 0x40 */, XCOFF_SYSCALL32 | XCOFF_SYSCALL64 }, 880 { "syscall64" /* 0x80 */, XCOFF_SYSCALL64 }, 881 { NULL, 0 }, 882 }; 883 884 *flag = 0; 885 886 for (bit = 0;; bit++) 887 { 888 string = s[bit].syscall_string; 889 if (string == NULL) 890 return -1; 891 892 if (0 == strcmp (input, string)) 893 { 894 if (1 << bit & syscall_mask) 895 { 896 *flag = s[bit].flag; 897 return 1; 898 } 899 else 900 { 901 return 0; 902 } 903 } 904 } 905 /* should not be here */ 906 return -1; 907} 908 909/* Read an import or export file. For an import file, this is called 910 by the before_allocation emulation routine. For an export file, 911 this is called by the handle_option emulation routine. */ 912 913static void 914gld${EMULATION_NAME}_read_file (const char *filename, bfd_boolean import) 915{ 916 struct obstack *o; 917 FILE *f; 918 int lineno; 919 int c; 920 bfd_boolean keep; 921 const char *imppath; 922 const char *impfile; 923 const char *impmember; 924 925 o = (struct obstack *) xmalloc (sizeof (struct obstack)); 926 obstack_specify_allocation (o, 0, 0, xmalloc, gld${EMULATION_NAME}_free); 927 928 f = fopen (filename, FOPEN_RT); 929 if (f == NULL) 930 { 931 bfd_set_error (bfd_error_system_call); 932 einfo ("%F%s: %E\n", filename); 933 } 934 935 keep = FALSE; 936 937 imppath = NULL; 938 impfile = NULL; 939 impmember = NULL; 940 941 lineno = 0; 942 943 /* Default to 32 and 64 bit mode 944 symbols at top of /lib/syscalls.exp do not have a mode modifier and they 945 are not repeated, assume 64 bit routines also want to use them. 946 See the routine change_symbol_mode for more information. */ 947 948 symbol_mode = 0x04; 949 950 while ((c = getc (f)) != EOF) 951 { 952 char *s; 953 char *symname; 954 unsigned int syscall_flag = 0; 955 bfd_vma address; 956 struct bfd_link_hash_entry *h; 957 958 if (c != '\n') 959 { 960 obstack_1grow (o, c); 961 continue; 962 } 963 964 obstack_1grow (o, '\0'); 965 ++lineno; 966 967 s = (char *) obstack_base (o); 968 while (ISSPACE (*s)) 969 ++s; 970 if (*s == '\0' 971 || *s == '*' 972 || change_symbol_mode (s) 973 || (*s == '#' && s[1] == ' ') 974 || (!import && *s == '#' && s[1] == '!')) 975 { 976 obstack_free (o, obstack_base (o)); 977 continue; 978 } 979 980 if (*s == '#' && s[1] == '!') 981 { 982 s += 2; 983 while (ISSPACE (*s)) 984 ++s; 985 if (*s == '\0') 986 { 987 imppath = NULL; 988 impfile = NULL; 989 impmember = NULL; 990 obstack_free (o, obstack_base (o)); 991 } 992 else if (*s == '(') 993 einfo ("%F%s%d: #! ([member]) is not supported in import files\n", 994 filename, lineno); 995 else 996 { 997 char cs; 998 char *file; 999 1000 (void) obstack_finish (o); 1001 keep = TRUE; 1002 imppath = s; 1003 file = NULL; 1004 while (!ISSPACE (*s) && *s != '(' && *s != '\0') 1005 { 1006 if (*s == '/') 1007 file = s + 1; 1008 ++s; 1009 } 1010 if (file != NULL) 1011 { 1012 file[-1] = '\0'; 1013 impfile = file; 1014 if (imppath == file - 1) 1015 imppath = "/"; 1016 } 1017 else 1018 { 1019 impfile = imppath; 1020 imppath = ""; 1021 } 1022 cs = *s; 1023 *s = '\0'; 1024 while (ISSPACE (cs)) 1025 { 1026 ++s; 1027 cs = *s; 1028 } 1029 if (cs != '(') 1030 { 1031 impmember = ""; 1032 if (cs != '\0') 1033 einfo ("%s:%d: warning: syntax error in import file\n", 1034 filename, lineno); 1035 } 1036 else 1037 { 1038 ++s; 1039 impmember = s; 1040 while (*s != ')' && *s != '\0') 1041 ++s; 1042 if (*s == ')') 1043 *s = '\0'; 1044 else 1045 einfo ("%s:%d: warning: syntax error in import file\n", 1046 filename, lineno); 1047 } 1048 } 1049 1050 continue; 1051 } 1052 1053 if (symbol_mode & symbol_mode_mask) 1054 { 1055 /* This is a symbol to be imported or exported. */ 1056 symname = s; 1057 syscall_flag = 0; 1058 address = (bfd_vma) -1; 1059 1060 while (!ISSPACE (*s) && *s != '\0') 1061 ++s; 1062 if (*s != '\0') 1063 { 1064 char *se; 1065 1066 *s++ = '\0'; 1067 1068 while (ISSPACE (*s)) 1069 ++s; 1070 1071 se = s; 1072 while (!ISSPACE (*se) && *se != '\0') 1073 ++se; 1074 if (*se != '\0') 1075 { 1076 *se++ = '\0'; 1077 while (ISSPACE (*se)) 1078 ++se; 1079 if (*se != '\0') 1080 einfo ("%s%d: warning: syntax error in import/export file\n", 1081 filename, lineno); 1082 } 1083 1084 if (s != se) 1085 { 1086 int status; 1087 const char *end; 1088 1089 status = is_syscall (s, &syscall_flag); 1090 1091 if (0 > status) 1092 { 1093 /* not a system call, check for address */ 1094 address = bfd_scan_vma (s, &end, 0); 1095 if (*end != '\0') 1096 { 1097 einfo ("%s:%d: warning: syntax error in import/export file\n", 1098 filename, lineno); 1099 1100 } 1101 } 1102 } 1103 } 1104 1105 if (!import) 1106 { 1107 struct export_symbol_list *n; 1108 1109 ldlang_add_undef (symname); 1110 n = ((struct export_symbol_list *) 1111 xmalloc (sizeof (struct export_symbol_list))); 1112 n->next = export_symbols; 1113 n->name = xstrdup (symname); 1114 export_symbols = n; 1115 } 1116 else 1117 { 1118 h = bfd_link_hash_lookup (link_info.hash, symname, FALSE, FALSE, 1119 TRUE); 1120 if (h == NULL || h->type == bfd_link_hash_new) 1121 { 1122 /* We can just ignore attempts to import an unreferenced 1123 symbol. */ 1124 } 1125 else 1126 { 1127 if (!bfd_xcoff_import_symbol (output_bfd, &link_info, h, 1128 address, imppath, impfile, 1129 impmember, syscall_flag)) 1130 einfo ("%X%s:%d: failed to import symbol %s: %E\n", 1131 filename, lineno, symname); 1132 } 1133 } 1134 } 1135 obstack_free (o, obstack_base (o)); 1136 } 1137 1138 if (obstack_object_size (o) > 0) 1139 { 1140 einfo ("%s:%d: warning: ignoring unterminated last line\n", 1141 filename, lineno); 1142 obstack_free (o, obstack_base (o)); 1143 } 1144 1145 if (!keep) 1146 { 1147 obstack_free (o, NULL); 1148 free (o); 1149 } 1150} 1151 1152/* This routine saves us from worrying about declaring free. */ 1153 1154static void 1155gld${EMULATION_NAME}_free (void *p) 1156{ 1157 free (p); 1158} 1159 1160/* This is called by the before_allocation routine via 1161 lang_for_each_statement. It looks for relocations and assignments 1162 to symbols. */ 1163 1164static void 1165gld${EMULATION_NAME}_find_relocs (lang_statement_union_type *s) 1166{ 1167 if (s->header.type == lang_reloc_statement_enum) 1168 { 1169 lang_reloc_statement_type *rs; 1170 1171 rs = &s->reloc_statement; 1172 if (rs->name == NULL) 1173 einfo ("%F%P: only relocations against symbols are permitted\n"); 1174 if (!bfd_xcoff_link_count_reloc (output_bfd, &link_info, rs->name)) 1175 einfo ("%F%P: bfd_xcoff_link_count_reloc failed: %E\n"); 1176 } 1177 1178 if (s->header.type == lang_assignment_statement_enum) 1179 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp); 1180} 1181 1182/* Look through an expression for an assignment statement. */ 1183 1184static void 1185gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp) 1186{ 1187 struct bfd_link_hash_entry *h; 1188 1189 switch (exp->type.node_class) 1190 { 1191 case etree_provide: 1192 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst, 1193 FALSE, FALSE, FALSE); 1194 if (h == NULL) 1195 break; 1196 /* Fall through. */ 1197 case etree_assign: 1198 if (strcmp (exp->assign.dst, ".") != 0) 1199 { 1200 if (!bfd_xcoff_record_link_assignment (output_bfd, &link_info, 1201 exp->assign.dst)) 1202 einfo ("%P%F: failed to record assignment to %s: %E\n", 1203 exp->assign.dst); 1204 } 1205 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src); 1206 break; 1207 1208 case etree_binary: 1209 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs); 1210 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs); 1211 break; 1212 1213 case etree_trinary: 1214 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond); 1215 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs); 1216 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs); 1217 break; 1218 1219 case etree_unary: 1220 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child); 1221 break; 1222 1223 default: 1224 break; 1225 } 1226} 1227 1228static char * 1229gld${EMULATION_NAME}_get_script (int *isfile) 1230EOF 1231 1232if test -n "$COMPILE_IN" 1233then 1234# Scripts compiled in. 1235 1236# sed commands to quote an ld script as a C string. 1237sc="-f ${srcdir}/emultempl/ostring.sed" 1238 1239cat >>e${EMULATION_NAME}.c <<EOF 1240{ 1241 *isfile = 0; 1242 1243 if (link_info.relocatable && config.build_constructors) 1244 return 1245EOF 1246sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c 1247echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c 1248sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c 1249echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c 1250sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c 1251echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c 1252sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c 1253echo ' ; else return' >> e${EMULATION_NAME}.c 1254sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c 1255echo '; }' >> e${EMULATION_NAME}.c 1256 1257else 1258# Scripts read from the filesystem. 1259 1260cat >>e${EMULATION_NAME}.c <<EOF 1261{ 1262 *isfile = 1; 1263 1264 if (link_info.relocatable && config.build_constructors) 1265 return "ldscripts/${EMULATION_NAME}.xu"; 1266 else if (link_info.relocatable) 1267 return "ldscripts/${EMULATION_NAME}.xr"; 1268 else if (!config.text_read_only) 1269 return "ldscripts/${EMULATION_NAME}.xbn"; 1270 else if (!config.magic_demand_paged) 1271 return "ldscripts/${EMULATION_NAME}.xn"; 1272 else 1273 return "ldscripts/${EMULATION_NAME}.x"; 1274} 1275EOF 1276 1277fi 1278 1279cat >>e${EMULATION_NAME}.c <<EOF 1280 1281static void 1282gld${EMULATION_NAME}_create_output_section_statements (void) 1283{ 1284 /* __rtinit */ 1285 if ((bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour) 1286 && (link_info.init_function != NULL 1287 || link_info.fini_function != NULL 1288 || rtld)) 1289 { 1290 initfini_file = lang_add_input_file ("initfini", 1291 lang_input_file_is_file_enum, 1292 NULL); 1293 1294 initfini_file->the_bfd = bfd_create ("initfini", output_bfd); 1295 if (initfini_file->the_bfd == NULL 1296 || ! bfd_set_arch_mach (initfini_file->the_bfd, 1297 bfd_get_arch (output_bfd), 1298 bfd_get_mach (output_bfd))) 1299 { 1300 einfo ("%X%P: can not create BFD %E\n"); 1301 return; 1302 } 1303 1304 /* Call backend to fill in the rest */ 1305 if (! bfd_xcoff_link_generate_rtinit (initfini_file->the_bfd, 1306 link_info.init_function, 1307 link_info.fini_function, 1308 rtld)) 1309 { 1310 einfo ("%X%P: can not create BFD %E\n"); 1311 return; 1312 } 1313 1314 /* __rtld defined in /lib/librtl.a */ 1315 if (rtld) 1316 lang_add_input_file ("rtl", lang_input_file_is_l_enum, NULL); 1317 } 1318} 1319 1320static void 1321gld${EMULATION_NAME}_set_output_arch (void) 1322{ 1323 bfd_set_arch_mach (output_bfd, 1324 bfd_xcoff_architecture (output_bfd), 1325 bfd_xcoff_machine (output_bfd)); 1326 1327 ldfile_output_architecture = bfd_get_arch (output_bfd); 1328 ldfile_output_machine = bfd_get_mach (output_bfd); 1329 ldfile_output_machine_name = bfd_printable_name (output_bfd); 1330} 1331 1332struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = { 1333 gld${EMULATION_NAME}_before_parse, 1334 syslib_default, 1335 hll_default, 1336 after_parse_default, 1337 gld${EMULATION_NAME}_after_open, 1338 after_allocation_default, 1339 gld${EMULATION_NAME}_set_output_arch, 1340 gld${EMULATION_NAME}_choose_target, 1341 gld${EMULATION_NAME}_before_allocation, 1342 gld${EMULATION_NAME}_get_script, 1343 "${EMULATION_NAME}", 1344 "${OUTPUT_FORMAT}", 1345 finish_default, 1346 gld${EMULATION_NAME}_create_output_section_statements, 1347 0, /* open_dynamic_archive */ 1348 0, /* place_orphan */ 1349 0, /* set_symbols */ 1350 gld${EMULATION_NAME}_parse_args, 1351 gld${EMULATION_NAME}_add_options, 1352 gld${EMULATION_NAME}_handle_option, 1353 gld${EMULATION_NAME}_unrecognized_file, 1354 NULL, /* list_options */ 1355 NULL, /* recognized_file */ 1356 NULL, /* find potential_libraries */ 1357 NULL /* new_vers_pattern */ 1358}; 1359EOF 1360