1/* nlmconv.c -- NLM conversion program 2 Copyright (C) 1993-2017 Free Software Foundation, Inc. 3 4 This file is part of GNU Binutils. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 22/* Written by Ian Lance Taylor <ian@cygnus.com>. 23 24 This program can be used to convert any appropriate object file 25 into a NetWare Loadable Module (an NLM). It will accept a linker 26 specification file which is identical to that accepted by the 27 NetWare linker, NLMLINK. */ 28 29/* AIX requires this to be the first thing in the file. */ 30#ifndef __GNUC__ 31# ifdef _AIX 32 #pragma alloca 33#endif 34#endif 35 36#include "sysdep.h" 37#include "bfd.h" 38#include "libiberty.h" 39#include "filenames.h" 40#include "safe-ctype.h" 41 42#include "ansidecl.h" 43#include <time.h> 44#include <assert.h> 45#include "getopt.h" 46 47/* Internal BFD NLM header. */ 48#include "libnlm.h" 49#include "nlmconv.h" 50 51#ifdef NLMCONV_ALPHA 52#include "coff/sym.h" 53#include "coff/ecoff.h" 54#endif 55 56#include "bucomm.h" 57 58/* If strerror is just a macro, we want to use the one from libiberty 59 since it will handle undefined values. */ 60#undef strerror 61extern char *strerror (int); 62 63#ifndef SEEK_SET 64#define SEEK_SET 0 65#endif 66 67#ifndef R_OK 68#define R_OK 4 69#define W_OK 2 70#define X_OK 1 71#endif 72 73/* Global variables. */ 74 75/* The name used to invoke the program. */ 76char *program_name; 77 78/* Local variables. */ 79 80/* Whether to print out debugging information (currently just controls 81 whether it prints the linker command if there is one). */ 82static int debug; 83 84/* The symbol table. */ 85static asymbol **symbols; 86 87/* A section we create in the output file to hold pointers to where 88 the sections of the input file end up. We will put a pointer to 89 this section in the NLM header. These is an entry for each input 90 section. The format is 91 null terminated section name 92 zeroes to adjust to 4 byte boundary 93 4 byte section data file pointer 94 4 byte section size 95 We don't need a version number. The way we find this information 96 is by finding a stamp in the NLM header information. If we need to 97 change the format of this information, we can simply change the 98 stamp. */ 99static asection *secsec; 100 101/* A temporary file name to be unlinked on exit. Actually, for most 102 errors, we leave it around. It's not clear whether that is helpful 103 or not. */ 104static char *unlink_on_exit; 105 106/* The list of long options. */ 107static struct option long_options[] = 108{ 109 { "debug", no_argument, 0, 'd' }, 110 { "header-file", required_argument, 0, 'T' }, 111 { "help", no_argument, 0, 'h' }, 112 { "input-target", required_argument, 0, 'I' }, 113 { "input-format", required_argument, 0, 'I' }, /* Obsolete */ 114 { "linker", required_argument, 0, 'l' }, 115 { "output-target", required_argument, 0, 'O' }, 116 { "output-format", required_argument, 0, 'O' }, /* Obsolete */ 117 { "version", no_argument, 0, 'V' }, 118 { NULL, no_argument, 0, 0 } 119}; 120 121/* Local routines. */ 122 123int main (int, char **); 124 125static void show_usage (FILE *, int); 126static const char *select_output_format 127 (enum bfd_architecture, unsigned long, bfd_boolean); 128static void setup_sections (bfd *, asection *, void *); 129static void copy_sections (bfd *, asection *, void *); 130static void mangle_relocs 131 (bfd *, asection *, arelent ***, long *, char *, bfd_size_type); 132static void default_mangle_relocs 133 (bfd *, asection *, arelent ***, long *, char *, bfd_size_type); 134static char *link_inputs (struct string_list *, char *, char *); 135 136#ifdef NLMCONV_I386 137static void i386_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type); 138#endif 139 140#ifdef NLMCONV_ALPHA 141static void alpha_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type); 142#endif 143 144#ifdef NLMCONV_POWERPC 145static void powerpc_build_stubs (bfd *, bfd *, asymbol ***, long *); 146static void powerpc_resolve_stubs (bfd *, bfd *); 147static void powerpc_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type); 148#endif 149 150/* The main routine. */ 151 152int 153main (int argc, char **argv) 154{ 155 int opt; 156 char *input_file = NULL; 157 const char *input_format = NULL; 158 const char *output_format = NULL; 159 const char *header_file = NULL; 160 char *ld_arg = NULL; 161 Nlm_Internal_Fixed_Header fixed_hdr_struct; 162 Nlm_Internal_Variable_Header var_hdr_struct; 163 Nlm_Internal_Version_Header version_hdr_struct; 164 Nlm_Internal_Copyright_Header copyright_hdr_struct; 165 Nlm_Internal_Extended_Header extended_hdr_struct; 166 bfd *inbfd; 167 bfd *outbfd; 168 asymbol **newsyms, **outsyms; 169 long symcount, newsymalloc, newsymcount; 170 long symsize; 171 asection *text_sec, *bss_sec, *data_sec; 172 bfd_vma vma; 173 bfd_size_type align; 174 asymbol *endsym; 175 long i; 176 char inlead, outlead; 177 bfd_boolean gotstart, gotexit, gotcheck; 178 struct stat st; 179 FILE *custom_data = NULL; 180 FILE *help_data = NULL; 181 FILE *message_data = NULL; 182 FILE *rpc_data = NULL; 183 FILE *shared_data = NULL; 184 size_t custom_size = 0; 185 size_t help_size = 0; 186 size_t message_size = 0; 187 size_t module_size = 0; 188 size_t rpc_size = 0; 189 asection *custom_section = NULL; 190 asection *help_section = NULL; 191 asection *message_section = NULL; 192 asection *module_section = NULL; 193 asection *rpc_section = NULL; 194 asection *shared_section = NULL; 195 bfd *sharedbfd; 196 size_t shared_offset = 0; 197 size_t shared_size = 0; 198 static Nlm_Internal_Fixed_Header sharedhdr; 199 int len; 200 char *modname; 201 char **matching; 202 203#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) 204 setlocale (LC_MESSAGES, ""); 205#endif 206#if defined (HAVE_SETLOCALE) 207 setlocale (LC_CTYPE, ""); 208#endif 209 bindtextdomain (PACKAGE, LOCALEDIR); 210 textdomain (PACKAGE); 211 212 program_name = argv[0]; 213 xmalloc_set_program_name (program_name); 214 bfd_set_error_program_name (program_name); 215 216 expandargv (&argc, &argv); 217 218 bfd_init (); 219 set_default_bfd_target (); 220 221 while ((opt = getopt_long (argc, argv, "dHhI:l:O:T:Vv", long_options, 222 (int *) NULL)) 223 != EOF) 224 { 225 switch (opt) 226 { 227 case 'd': 228 debug = 1; 229 break; 230 case 'H': 231 case 'h': 232 show_usage (stdout, 0); 233 break; 234 case 'I': 235 input_format = optarg; 236 break; 237 case 'l': 238 ld_arg = optarg; 239 break; 240 case 'O': 241 output_format = optarg; 242 break; 243 case 'T': 244 header_file = optarg; 245 break; 246 case 'v': 247 case 'V': 248 print_version ("nlmconv"); 249 break; 250 case 0: 251 break; 252 default: 253 show_usage (stderr, 1); 254 break; 255 } 256 } 257 258 /* The input and output files may be named on the command line. */ 259 output_file = NULL; 260 if (optind < argc) 261 { 262 input_file = argv[optind]; 263 ++optind; 264 if (optind < argc) 265 { 266 output_file = argv[optind]; 267 ++optind; 268 if (optind < argc) 269 show_usage (stderr, 1); 270 if (filename_cmp (input_file, output_file) == 0) 271 { 272 fatal (_("input and output files must be different")); 273 } 274 } 275 } 276 277 /* Initialize the header information to default values. */ 278 fixed_hdr = &fixed_hdr_struct; 279 memset ((void *) &fixed_hdr_struct, 0, sizeof fixed_hdr_struct); 280 var_hdr = &var_hdr_struct; 281 memset ((void *) &var_hdr_struct, 0, sizeof var_hdr_struct); 282 version_hdr = &version_hdr_struct; 283 memset ((void *) &version_hdr_struct, 0, sizeof version_hdr_struct); 284 copyright_hdr = ©right_hdr_struct; 285 memset ((void *) ©right_hdr_struct, 0, sizeof copyright_hdr_struct); 286 extended_hdr = &extended_hdr_struct; 287 memset ((void *) &extended_hdr_struct, 0, sizeof extended_hdr_struct); 288 check_procedure = NULL; 289 custom_file = NULL; 290 debug_info = FALSE; 291 exit_procedure = "_Stop"; 292 export_symbols = NULL; 293 map_file = NULL; 294 full_map = FALSE; 295 help_file = NULL; 296 import_symbols = NULL; 297 message_file = NULL; 298 modules = NULL; 299 sharelib_file = NULL; 300 start_procedure = "_Prelude"; 301 verbose = FALSE; 302 rpc_file = NULL; 303 304 parse_errors = 0; 305 306 /* Parse the header file (if there is one). */ 307 if (header_file != NULL) 308 { 309 if (! nlmlex_file (header_file) 310 || yyparse () != 0 311 || parse_errors != 0) 312 exit (1); 313 } 314 315 if (input_files != NULL) 316 { 317 if (input_file != NULL) 318 { 319 fatal (_("input file named both on command line and with INPUT")); 320 } 321 if (input_files->next == NULL) 322 input_file = input_files->string; 323 else 324 input_file = link_inputs (input_files, ld_arg, map_file); 325 } 326 else if (input_file == NULL) 327 { 328 non_fatal (_("no input file")); 329 show_usage (stderr, 1); 330 } 331 332 inbfd = bfd_openr (input_file, input_format); 333 if (inbfd == NULL) 334 bfd_fatal (input_file); 335 336 if (! bfd_check_format_matches (inbfd, bfd_object, &matching)) 337 { 338 bfd_nonfatal (input_file); 339 if (bfd_get_error () == bfd_error_file_ambiguously_recognized) 340 { 341 list_matching_formats (matching); 342 free (matching); 343 } 344 exit (1); 345 } 346 347 if (output_format == NULL) 348 output_format = select_output_format (bfd_get_arch (inbfd), 349 bfd_get_mach (inbfd), 350 bfd_big_endian (inbfd)); 351 352 assert (output_format != NULL); 353 354 /* Use the output file named on the command line if it exists. 355 Otherwise use the file named in the OUTPUT statement. */ 356 if (output_file == NULL) 357 { 358 non_fatal (_("no name for output file")); 359 show_usage (stderr, 1); 360 } 361 362 outbfd = bfd_openw (output_file, output_format); 363 if (outbfd == NULL) 364 bfd_fatal (output_file); 365 if (! bfd_set_format (outbfd, bfd_object)) 366 bfd_fatal (output_file); 367 368 assert (bfd_get_flavour (outbfd) == bfd_target_nlm_flavour); 369 370 /* XXX: Should we accept the unknown bfd format here ? */ 371 if (bfd_arch_get_compatible (inbfd, outbfd, TRUE) == NULL) 372 non_fatal (_("warning: input and output formats are not compatible")); 373 374 /* Move the values read from the command file into outbfd. */ 375 *nlm_fixed_header (outbfd) = fixed_hdr_struct; 376 *nlm_variable_header (outbfd) = var_hdr_struct; 377 *nlm_version_header (outbfd) = version_hdr_struct; 378 *nlm_copyright_header (outbfd) = copyright_hdr_struct; 379 *nlm_extended_header (outbfd) = extended_hdr_struct; 380 381 /* Start copying the input BFD to the output BFD. */ 382 if (! bfd_set_file_flags (outbfd, bfd_get_file_flags (inbfd))) 383 bfd_fatal (bfd_get_filename (outbfd)); 384 385 symsize = bfd_get_symtab_upper_bound (inbfd); 386 if (symsize < 0) 387 bfd_fatal (input_file); 388 symbols = (asymbol **) xmalloc (symsize); 389 symcount = bfd_canonicalize_symtab (inbfd, symbols); 390 if (symcount < 0) 391 bfd_fatal (input_file); 392 393 /* Make sure we have a .bss section. */ 394 bss_sec = bfd_get_section_by_name (outbfd, NLM_UNINITIALIZED_DATA_NAME); 395 if (bss_sec == NULL) 396 { 397 bss_sec = bfd_make_section_with_flags (outbfd, 398 NLM_UNINITIALIZED_DATA_NAME, 399 SEC_ALLOC); 400 if (bss_sec == NULL 401 || ! bfd_set_section_alignment (outbfd, bss_sec, 1)) 402 bfd_fatal (_("make .bss section")); 403 } 404 405 /* We store the original section names in the .nlmsections section, 406 so that programs which understand it can resurrect the original 407 sections from the NLM. We will put a pointer to .nlmsections in 408 the NLM header area. */ 409 secsec = bfd_make_section_with_flags (outbfd, ".nlmsections", 410 SEC_HAS_CONTENTS); 411 if (secsec == NULL) 412 bfd_fatal (_("make .nlmsections section")); 413 414#ifdef NLMCONV_POWERPC 415 /* For PowerPC NetWare we need to build stubs for calls to undefined 416 symbols. Because each stub requires an entry in the TOC section 417 which must be at the same location as other entries in the TOC 418 section, we must do this before determining where the TOC section 419 goes in setup_sections. */ 420 if (bfd_get_arch (inbfd) == bfd_arch_powerpc) 421 powerpc_build_stubs (inbfd, outbfd, &symbols, &symcount); 422#endif 423 424 /* Set up the sections. */ 425 bfd_map_over_sections (inbfd, setup_sections, (void *) outbfd); 426 427 text_sec = bfd_get_section_by_name (outbfd, NLM_CODE_NAME); 428 429 /* The .bss section immediately follows the .data section. */ 430 data_sec = bfd_get_section_by_name (outbfd, NLM_INITIALIZED_DATA_NAME); 431 if (data_sec != NULL) 432 { 433 bfd_size_type add; 434 435 vma = bfd_get_section_size (data_sec); 436 align = 1 << bss_sec->alignment_power; 437 add = ((vma + align - 1) &~ (align - 1)) - vma; 438 vma += add; 439 if (! bfd_set_section_vma (outbfd, bss_sec, vma)) 440 bfd_fatal (_("set .bss vma")); 441 if (add != 0) 442 { 443 bfd_size_type data_size; 444 445 data_size = bfd_get_section_size (data_sec); 446 if (! bfd_set_section_size (outbfd, data_sec, data_size + add)) 447 bfd_fatal (_("set .data size")); 448 } 449 } 450 451 /* Adjust symbol information. */ 452 inlead = bfd_get_symbol_leading_char (inbfd); 453 outlead = bfd_get_symbol_leading_char (outbfd); 454 gotstart = FALSE; 455 gotexit = FALSE; 456 gotcheck = FALSE; 457 newsymalloc = 10; 458 newsyms = (asymbol **) xmalloc (newsymalloc * sizeof (asymbol *)); 459 newsymcount = 0; 460 endsym = NULL; 461 for (i = 0; i < symcount; i++) 462 { 463 asymbol *sym; 464 465 sym = symbols[i]; 466 467 /* Add or remove a leading underscore. */ 468 if (inlead != outlead) 469 { 470 if (inlead != '\0') 471 { 472 if (bfd_asymbol_name (sym)[0] == inlead) 473 { 474 if (outlead == '\0') 475 ++sym->name; 476 else 477 { 478 char *new_name; 479 480 new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 1); 481 new_name[0] = outlead; 482 strcpy (new_name + 1, bfd_asymbol_name (sym) + 1); 483 sym->name = new_name; 484 } 485 } 486 } 487 else 488 { 489 char *new_name; 490 491 new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 2); 492 new_name[0] = outlead; 493 strcpy (new_name + 1, bfd_asymbol_name (sym)); 494 sym->name = new_name; 495 } 496 } 497 498 /* NLM's have an uninitialized data section, but they do not 499 have a common section in the Unix sense. Move all common 500 symbols into the .bss section, and mark them as exported. */ 501 if (bfd_is_com_section (bfd_get_section (sym))) 502 { 503 bfd_vma size = sym->value; 504 505 sym->section = bss_sec; 506 sym->value = bfd_get_section_size (bss_sec); 507 size += sym->value; 508 align = 1 << bss_sec->alignment_power; 509 size = (size + align - 1) & ~(align - 1); 510 bfd_set_section_size (outbfd, bss_sec, size); 511 sym->flags |= BSF_EXPORT | BSF_GLOBAL; 512 } 513 else if (bfd_get_section (sym)->output_section != NULL) 514 { 515 /* Move the symbol into the output section. */ 516 sym->value += bfd_get_section (sym)->output_offset; 517 sym->section = bfd_get_section (sym)->output_section; 518 /* This is no longer a section symbol. */ 519 sym->flags &=~ BSF_SECTION_SYM; 520 } 521 522 /* Force _edata and _end to be defined. This would normally be 523 done by the linker, but the manipulation of the common 524 symbols will confuse it. */ 525 if ((sym->flags & BSF_DEBUGGING) == 0 526 && bfd_asymbol_name (sym)[0] == '_' 527 && bfd_is_und_section (bfd_get_section (sym))) 528 { 529 if (strcmp (bfd_asymbol_name (sym), "_edata") == 0) 530 { 531 sym->section = bss_sec; 532 sym->value = 0; 533 } 534 if (strcmp (bfd_asymbol_name (sym), "_end") == 0) 535 { 536 sym->section = bss_sec; 537 endsym = sym; 538 } 539 540#ifdef NLMCONV_POWERPC 541 /* For PowerPC NetWare, we define __GOT0. This is the start 542 of the .got section. */ 543 if (bfd_get_arch (inbfd) == bfd_arch_powerpc 544 && strcmp (bfd_asymbol_name (sym), "__GOT0") == 0) 545 { 546 asection *got_sec; 547 548 got_sec = bfd_get_section_by_name (inbfd, ".got"); 549 assert (got_sec != (asection *) NULL); 550 sym->value = got_sec->output_offset; 551 sym->section = got_sec->output_section; 552 } 553#endif 554 } 555 556 /* If this is a global symbol, check the export list. */ 557 if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0) 558 { 559 struct string_list *l; 560 int found_simple; 561 562 /* Unfortunately, a symbol can appear multiple times on the 563 export list, with and without prefixes. */ 564 found_simple = 0; 565 for (l = export_symbols; l != NULL; l = l->next) 566 { 567 if (strcmp (l->string, bfd_asymbol_name (sym)) == 0) 568 found_simple = 1; 569 else 570 { 571 char *zbase; 572 573 zbase = strchr (l->string, '@'); 574 if (zbase != NULL 575 && strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0) 576 { 577 /* We must add a symbol with this prefix. */ 578 if (newsymcount >= newsymalloc) 579 { 580 newsymalloc += 10; 581 newsyms = ((asymbol **) 582 xrealloc ((void *) newsyms, 583 (newsymalloc 584 * sizeof (asymbol *)))); 585 } 586 newsyms[newsymcount] = 587 (asymbol *) xmalloc (sizeof (asymbol)); 588 *newsyms[newsymcount] = *sym; 589 newsyms[newsymcount]->name = l->string; 590 ++newsymcount; 591 } 592 } 593 } 594 if (! found_simple) 595 { 596 /* The unmodified symbol is actually not exported at 597 all. */ 598 sym->flags &=~ (BSF_GLOBAL | BSF_EXPORT); 599 sym->flags |= BSF_LOCAL; 600 } 601 } 602 603 /* If it's an undefined symbol, see if it's on the import list. 604 Change the prefix if necessary. */ 605 if (bfd_is_und_section (bfd_get_section (sym))) 606 { 607 struct string_list *l; 608 609 for (l = import_symbols; l != NULL; l = l->next) 610 { 611 if (strcmp (l->string, bfd_asymbol_name (sym)) == 0) 612 break; 613 else 614 { 615 char *zbase; 616 617 zbase = strchr (l->string, '@'); 618 if (zbase != NULL 619 && strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0) 620 { 621 sym->name = l->string; 622 break; 623 } 624 } 625 } 626 if (l == NULL) 627 non_fatal (_("warning: symbol %s imported but not in import list"), 628 bfd_asymbol_name (sym)); 629 } 630 631 /* See if it's one of the special named symbols. */ 632 if ((sym->flags & BSF_DEBUGGING) == 0) 633 { 634 bfd_vma val; 635 636 /* FIXME: If these symbols are not in the .text section, we 637 add the .text section size to the value. This may not be 638 correct for all targets. I'm not sure how this should 639 really be handled. */ 640 if (strcmp (bfd_asymbol_name (sym), start_procedure) == 0) 641 { 642 val = bfd_asymbol_value (sym); 643 if (bfd_get_section (sym) == data_sec 644 && text_sec != (asection *) NULL) 645 val += bfd_section_size (outbfd, text_sec); 646 if (! bfd_set_start_address (outbfd, val)) 647 bfd_fatal (_("set start address")); 648 gotstart = TRUE; 649 } 650 if (strcmp (bfd_asymbol_name (sym), exit_procedure) == 0) 651 { 652 val = bfd_asymbol_value (sym); 653 if (bfd_get_section (sym) == data_sec 654 && text_sec != (asection *) NULL) 655 val += bfd_section_size (outbfd, text_sec); 656 nlm_fixed_header (outbfd)->exitProcedureOffset = val; 657 gotexit = TRUE; 658 } 659 if (check_procedure != NULL 660 && strcmp (bfd_asymbol_name (sym), check_procedure) == 0) 661 { 662 val = bfd_asymbol_value (sym); 663 if (bfd_get_section (sym) == data_sec 664 && text_sec != (asection *) NULL) 665 val += bfd_section_size (outbfd, text_sec); 666 nlm_fixed_header (outbfd)->checkUnloadProcedureOffset = val; 667 gotcheck = TRUE; 668 } 669 } 670 } 671 672 if (endsym != NULL) 673 { 674 endsym->value = bfd_get_section_size (bss_sec); 675 676 /* FIXME: If any relocs referring to _end use inplace addends, 677 then I think they need to be updated. This is handled by 678 i386_mangle_relocs. Is it needed for any other object 679 formats? */ 680 } 681 682 if (newsymcount == 0) 683 outsyms = symbols; 684 else 685 { 686 outsyms = (asymbol **) xmalloc ((symcount + newsymcount + 1) 687 * sizeof (asymbol *)); 688 memcpy (outsyms, symbols, symcount * sizeof (asymbol *)); 689 memcpy (outsyms + symcount, newsyms, newsymcount * sizeof (asymbol *)); 690 outsyms[symcount + newsymcount] = NULL; 691 } 692 693 bfd_set_symtab (outbfd, outsyms, symcount + newsymcount); 694 695 if (! gotstart) 696 non_fatal (_("warning: START procedure %s not defined"), start_procedure); 697 if (! gotexit) 698 non_fatal (_("warning: EXIT procedure %s not defined"), exit_procedure); 699 if (check_procedure != NULL && ! gotcheck) 700 non_fatal (_("warning: CHECK procedure %s not defined"), check_procedure); 701 702 /* Add additional sections required for the header information. */ 703 if (custom_file != NULL) 704 { 705 custom_data = fopen (custom_file, "r"); 706 if (custom_data == NULL 707 || fstat (fileno (custom_data), &st) < 0) 708 { 709 fprintf (stderr, "%s:%s: %s\n", program_name, custom_file, 710 strerror (errno)); 711 custom_file = NULL; 712 } 713 else 714 { 715 custom_size = st.st_size; 716 custom_section = bfd_make_section_with_flags (outbfd, ".nlmcustom", 717 SEC_HAS_CONTENTS); 718 if (custom_section == NULL 719 || ! bfd_set_section_size (outbfd, custom_section, custom_size)) 720 bfd_fatal (_("custom section")); 721 } 722 } 723 if (help_file != NULL) 724 { 725 help_data = fopen (help_file, "r"); 726 if (help_data == NULL 727 || fstat (fileno (help_data), &st) < 0) 728 { 729 fprintf (stderr, "%s:%s: %s\n", program_name, help_file, 730 strerror (errno)); 731 help_file = NULL; 732 } 733 else 734 { 735 help_size = st.st_size; 736 help_section = bfd_make_section_with_flags (outbfd, ".nlmhelp", 737 SEC_HAS_CONTENTS); 738 if (help_section == NULL 739 || ! bfd_set_section_size (outbfd, help_section, help_size)) 740 bfd_fatal (_("help section")); 741 LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs"); 742 } 743 } 744 if (message_file != NULL) 745 { 746 message_data = fopen (message_file, "r"); 747 if (message_data == NULL 748 || fstat (fileno (message_data), &st) < 0) 749 { 750 fprintf (stderr, "%s:%s: %s\n", program_name, message_file, 751 strerror (errno)); 752 message_file = NULL; 753 } 754 else 755 { 756 message_size = st.st_size; 757 message_section = bfd_make_section_with_flags (outbfd, 758 ".nlmmessages", 759 SEC_HAS_CONTENTS); 760 if (message_section == NULL 761 || ! bfd_set_section_size (outbfd, message_section, message_size)) 762 bfd_fatal (_("message section")); 763 LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs"); 764 } 765 } 766 if (modules != NULL) 767 { 768 struct string_list *l; 769 770 module_size = 0; 771 for (l = modules; l != NULL; l = l->next) 772 module_size += strlen (l->string) + 1; 773 module_section = bfd_make_section_with_flags (outbfd, ".nlmmodules", 774 SEC_HAS_CONTENTS); 775 if (module_section == NULL 776 || ! bfd_set_section_size (outbfd, module_section, module_size)) 777 bfd_fatal (_("module section")); 778 } 779 if (rpc_file != NULL) 780 { 781 rpc_data = fopen (rpc_file, "r"); 782 if (rpc_data == NULL 783 || fstat (fileno (rpc_data), &st) < 0) 784 { 785 fprintf (stderr, "%s:%s: %s\n", program_name, rpc_file, 786 strerror (errno)); 787 rpc_file = NULL; 788 } 789 else 790 { 791 rpc_size = st.st_size; 792 rpc_section = bfd_make_section_with_flags (outbfd, ".nlmrpc", 793 SEC_HAS_CONTENTS); 794 if (rpc_section == NULL 795 || ! bfd_set_section_size (outbfd, rpc_section, rpc_size)) 796 bfd_fatal (_("rpc section")); 797 LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs"); 798 } 799 } 800 if (sharelib_file != NULL) 801 { 802 sharedbfd = bfd_openr (sharelib_file, output_format); 803 if (sharedbfd == NULL 804 || ! bfd_check_format (sharedbfd, bfd_object)) 805 { 806 fprintf (stderr, "%s:%s: %s\n", program_name, sharelib_file, 807 bfd_errmsg (bfd_get_error ())); 808 sharelib_file = NULL; 809 } 810 else 811 { 812 sharedhdr = *nlm_fixed_header (sharedbfd); 813 bfd_close (sharedbfd); 814 shared_data = fopen (sharelib_file, "r"); 815 if (shared_data == NULL 816 || (fstat (fileno (shared_data), &st) < 0)) 817 { 818 fprintf (stderr, "%s:%s: %s\n", program_name, sharelib_file, 819 strerror (errno)); 820 sharelib_file = NULL; 821 } 822 else 823 { 824 /* If we were clever, we could just copy out the 825 sections of the shared library which we actually 826 need. However, we would have to figure out the sizes 827 of the external and public information, and that can 828 not be done without reading through them. */ 829 if (sharedhdr.uninitializedDataSize > 0) 830 { 831 /* There is no place to record this information. */ 832 non_fatal (_("%s: warning: shared libraries can not have uninitialized data"), 833 sharelib_file); 834 } 835 shared_offset = st.st_size; 836 if (shared_offset > (size_t) sharedhdr.codeImageOffset) 837 shared_offset = sharedhdr.codeImageOffset; 838 if (shared_offset > (size_t) sharedhdr.dataImageOffset) 839 shared_offset = sharedhdr.dataImageOffset; 840 if (shared_offset > (size_t) sharedhdr.relocationFixupOffset) 841 shared_offset = sharedhdr.relocationFixupOffset; 842 if (shared_offset > (size_t) sharedhdr.externalReferencesOffset) 843 shared_offset = sharedhdr.externalReferencesOffset; 844 if (shared_offset > (size_t) sharedhdr.publicsOffset) 845 shared_offset = sharedhdr.publicsOffset; 846 shared_size = st.st_size - shared_offset; 847 shared_section = bfd_make_section_with_flags (outbfd, 848 ".nlmshared", 849 SEC_HAS_CONTENTS); 850 if (shared_section == NULL 851 || ! bfd_set_section_size (outbfd, shared_section, 852 shared_size)) 853 bfd_fatal (_("shared section")); 854 LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs"); 855 } 856 } 857 } 858 859 /* Check whether a version was given. */ 860 if (!CONST_STRNEQ (version_hdr->stamp, "VeRsIoN#")) 861 non_fatal (_("warning: No version number given")); 862 863 /* At least for now, always create an extended header, because that 864 is what NLMLINK does. */ 865 LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs"); 866 867 LITMEMCPY (nlm_cygnus_ext_header (outbfd)->stamp, "CyGnUsEx"); 868 869 /* If the date was not given, force it in. */ 870 if (nlm_version_header (outbfd)->month == 0 871 && nlm_version_header (outbfd)->day == 0 872 && nlm_version_header (outbfd)->year == 0) 873 { 874 time_t now; 875 struct tm *ptm; 876 877 time (&now); 878 ptm = localtime (&now); 879 nlm_version_header (outbfd)->month = ptm->tm_mon + 1; 880 nlm_version_header (outbfd)->day = ptm->tm_mday; 881 nlm_version_header (outbfd)->year = ptm->tm_year + 1900; 882 LITMEMCPY (version_hdr->stamp, "VeRsIoN#"); 883 } 884 885#ifdef NLMCONV_POWERPC 886 /* Resolve the stubs we build for PowerPC NetWare. */ 887 if (bfd_get_arch (inbfd) == bfd_arch_powerpc) 888 powerpc_resolve_stubs (inbfd, outbfd); 889#endif 890 891 /* Copy over the sections. */ 892 bfd_map_over_sections (inbfd, copy_sections, (void *) outbfd); 893 894 /* Finish up the header information. */ 895 if (custom_file != NULL) 896 { 897 void *data; 898 899 data = xmalloc (custom_size); 900 if (fread (data, 1, custom_size, custom_data) != custom_size) 901 non_fatal (_("%s: read: %s"), custom_file, strerror (errno)); 902 else 903 { 904 if (! bfd_set_section_contents (outbfd, custom_section, data, 905 (file_ptr) 0, custom_size)) 906 bfd_fatal (_("custom section")); 907 nlm_fixed_header (outbfd)->customDataOffset = 908 custom_section->filepos; 909 nlm_fixed_header (outbfd)->customDataSize = custom_size; 910 } 911 free (data); 912 } 913 if (! debug_info) 914 { 915 /* As a special hack, the backend recognizes a debugInfoOffset 916 of -1 to mean that it should not output any debugging 917 information. This can not be handling by fiddling with the 918 symbol table because exported symbols appear in both the 919 export information and the debugging information. */ 920 nlm_fixed_header (outbfd)->debugInfoOffset = (file_ptr) -1; 921 } 922 if (full_map) 923 non_fatal (_("warning: FULLMAP is not supported; try ld -M")); 924 if (help_file != NULL) 925 { 926 void *data; 927 928 data = xmalloc (help_size); 929 if (fread (data, 1, help_size, help_data) != help_size) 930 non_fatal (_("%s: read: %s"), help_file, strerror (errno)); 931 else 932 { 933 if (! bfd_set_section_contents (outbfd, help_section, data, 934 (file_ptr) 0, help_size)) 935 bfd_fatal (_("help section")); 936 nlm_extended_header (outbfd)->helpFileOffset = 937 help_section->filepos; 938 nlm_extended_header (outbfd)->helpFileLength = help_size; 939 } 940 free (data); 941 } 942 if (message_file != NULL) 943 { 944 void *data; 945 946 data = xmalloc (message_size); 947 if (fread (data, 1, message_size, message_data) != message_size) 948 non_fatal (_("%s: read: %s"), message_file, strerror (errno)); 949 else 950 { 951 if (! bfd_set_section_contents (outbfd, message_section, data, 952 (file_ptr) 0, message_size)) 953 bfd_fatal (_("message section")); 954 nlm_extended_header (outbfd)->messageFileOffset = 955 message_section->filepos; 956 nlm_extended_header (outbfd)->messageFileLength = message_size; 957 958 /* FIXME: Are these offsets correct on all platforms? Are 959 they 32 bits on all platforms? What endianness? */ 960 nlm_extended_header (outbfd)->languageID = 961 bfd_h_get_32 (outbfd, (bfd_byte *) data + 106); 962 nlm_extended_header (outbfd)->messageCount = 963 bfd_h_get_32 (outbfd, (bfd_byte *) data + 110); 964 } 965 free (data); 966 } 967 if (modules != NULL) 968 { 969 void *data; 970 unsigned char *set; 971 struct string_list *l; 972 bfd_size_type c; 973 974 data = xmalloc (module_size); 975 c = 0; 976 set = (unsigned char *) data; 977 for (l = modules; l != NULL; l = l->next) 978 { 979 *set = strlen (l->string); 980 strncpy ((char *) set + 1, l->string, *set); 981 set += *set + 1; 982 ++c; 983 } 984 if (! bfd_set_section_contents (outbfd, module_section, data, 985 (file_ptr) 0, module_size)) 986 bfd_fatal (_("module section")); 987 nlm_fixed_header (outbfd)->moduleDependencyOffset = 988 module_section->filepos; 989 nlm_fixed_header (outbfd)->numberOfModuleDependencies = c; 990 } 991 if (rpc_file != NULL) 992 { 993 void *data; 994 995 data = xmalloc (rpc_size); 996 if (fread (data, 1, rpc_size, rpc_data) != rpc_size) 997 non_fatal (_("%s: read: %s"), rpc_file, strerror (errno)); 998 else 999 { 1000 if (! bfd_set_section_contents (outbfd, rpc_section, data, 1001 (file_ptr) 0, rpc_size)) 1002 bfd_fatal (_("rpc section")); 1003 nlm_extended_header (outbfd)->RPCDataOffset = 1004 rpc_section->filepos; 1005 nlm_extended_header (outbfd)->RPCDataLength = rpc_size; 1006 } 1007 free (data); 1008 } 1009 if (sharelib_file != NULL) 1010 { 1011 void *data; 1012 1013 data = xmalloc (shared_size); 1014 if (fseek (shared_data, shared_offset, SEEK_SET) != 0 1015 || fread (data, 1, shared_size, shared_data) != shared_size) 1016 non_fatal (_("%s: read: %s"), sharelib_file, strerror (errno)); 1017 else 1018 { 1019 if (! bfd_set_section_contents (outbfd, shared_section, data, 1020 (file_ptr) 0, shared_size)) 1021 bfd_fatal (_("shared section")); 1022 } 1023 nlm_extended_header (outbfd)->sharedCodeOffset = 1024 sharedhdr.codeImageOffset - shared_offset + shared_section->filepos; 1025 nlm_extended_header (outbfd)->sharedCodeLength = 1026 sharedhdr.codeImageSize; 1027 nlm_extended_header (outbfd)->sharedDataOffset = 1028 sharedhdr.dataImageOffset - shared_offset + shared_section->filepos; 1029 nlm_extended_header (outbfd)->sharedDataLength = 1030 sharedhdr.dataImageSize; 1031 nlm_extended_header (outbfd)->sharedRelocationFixupOffset = 1032 (sharedhdr.relocationFixupOffset 1033 - shared_offset 1034 + shared_section->filepos); 1035 nlm_extended_header (outbfd)->sharedRelocationFixupCount = 1036 sharedhdr.numberOfRelocationFixups; 1037 nlm_extended_header (outbfd)->sharedExternalReferenceOffset = 1038 (sharedhdr.externalReferencesOffset 1039 - shared_offset 1040 + shared_section->filepos); 1041 nlm_extended_header (outbfd)->sharedExternalReferenceCount = 1042 sharedhdr.numberOfExternalReferences; 1043 nlm_extended_header (outbfd)->sharedPublicsOffset = 1044 sharedhdr.publicsOffset - shared_offset + shared_section->filepos; 1045 nlm_extended_header (outbfd)->sharedPublicsCount = 1046 sharedhdr.numberOfPublics; 1047 nlm_extended_header (outbfd)->sharedDebugRecordOffset = 1048 sharedhdr.debugInfoOffset - shared_offset + shared_section->filepos; 1049 nlm_extended_header (outbfd)->sharedDebugRecordCount = 1050 sharedhdr.numberOfDebugRecords; 1051 nlm_extended_header (outbfd)->SharedInitializationOffset = 1052 sharedhdr.codeStartOffset; 1053 nlm_extended_header (outbfd)->SharedExitProcedureOffset = 1054 sharedhdr.exitProcedureOffset; 1055 free (data); 1056 } 1057 1058 { 1059 const int max_len = NLM_MODULE_NAME_SIZE - 2; 1060 const char * filename = lbasename (output_file); 1061 1062 len = strlen (filename); 1063 if (len > max_len) 1064 len = max_len; 1065 nlm_fixed_header (outbfd)->moduleName[0] = len; 1066 1067 strncpy (nlm_fixed_header (outbfd)->moduleName + 1, filename, max_len); 1068 nlm_fixed_header (outbfd)->moduleName[max_len + 1] = '\0'; 1069 1070 for (modname = nlm_fixed_header (outbfd)->moduleName; 1071 *modname != '\0'; 1072 modname++) 1073 *modname = TOUPPER (*modname); 1074 } 1075 1076 strncpy (nlm_variable_header (outbfd)->oldThreadName, " LONG", 1077 NLM_OLD_THREAD_NAME_LENGTH); 1078 1079 nlm_cygnus_ext_header (outbfd)->offset = secsec->filepos; 1080 nlm_cygnus_ext_header (outbfd)->length = bfd_section_size (outbfd, secsec); 1081 1082 if (! bfd_close (outbfd)) 1083 bfd_fatal (output_file); 1084 if (! bfd_close (inbfd)) 1085 bfd_fatal (input_file); 1086 1087 if (unlink_on_exit != NULL) 1088 unlink (unlink_on_exit); 1089 1090 return 0; 1091} 1092 1093 1094/* Show a usage message and exit. */ 1095 1096static void 1097show_usage (FILE *file, int status) 1098{ 1099 fprintf (file, _("Usage: %s [option(s)] [in-file [out-file]]\n"), program_name); 1100 fprintf (file, _(" Convert an object file into a NetWare Loadable Module\n")); 1101 fprintf (file, _(" The options are:\n\ 1102 -I --input-target=<bfdname> Set the input binary file format\n\ 1103 -O --output-target=<bfdname> Set the output binary file format\n\ 1104 -T --header-file=<file> Read <file> for NLM header information\n\ 1105 -l --linker=<linker> Use <linker> for any linking\n\ 1106 -d --debug Display on stderr the linker command line\n\ 1107 @<file> Read options from <file>.\n\ 1108 -h --help Display this information\n\ 1109 -v --version Display the program's version\n\ 1110")); 1111 if (REPORT_BUGS_TO[0] && status == 0) 1112 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO); 1113 exit (status); 1114} 1115 1116/* Select the output format based on the input architecture, machine, 1117 and endianness. This chooses the appropriate NLM target. */ 1118 1119static const char * 1120select_output_format (enum bfd_architecture arch, unsigned long mach, 1121 bfd_boolean bigendian ATTRIBUTE_UNUSED) 1122{ 1123 switch (arch) 1124 { 1125#ifdef NLMCONV_I386 1126 case bfd_arch_i386: 1127 return "nlm32-i386"; 1128#endif 1129#ifdef NLMCONV_SPARC 1130 case bfd_arch_sparc: 1131 return "nlm32-sparc"; 1132#endif 1133#ifdef NLMCONV_ALPHA 1134 case bfd_arch_alpha: 1135 return "nlm32-alpha"; 1136#endif 1137#ifdef NLMCONV_POWERPC 1138 case bfd_arch_powerpc: 1139 return "nlm32-powerpc"; 1140#endif 1141 default: 1142 fatal (_("support not compiled in for %s"), 1143 bfd_printable_arch_mach (arch, mach)); 1144 } 1145 /*NOTREACHED*/ 1146} 1147 1148/* The BFD sections are copied in two passes. This function selects 1149 the output section for each input section, and sets up the section 1150 name, size, etc. */ 1151 1152static void 1153setup_sections (bfd *inbfd ATTRIBUTE_UNUSED, asection *insec, void *data_ptr) 1154{ 1155 bfd *outbfd = (bfd *) data_ptr; 1156 flagword f; 1157 const char *outname; 1158 asection *outsec; 1159 bfd_vma offset; 1160 bfd_size_type align; 1161 bfd_size_type add; 1162 bfd_size_type secsecsize; 1163 1164 f = bfd_get_section_flags (inbfd, insec); 1165 if (f & SEC_CODE) 1166 outname = NLM_CODE_NAME; 1167 else if ((f & SEC_LOAD) && (f & SEC_HAS_CONTENTS)) 1168 outname = NLM_INITIALIZED_DATA_NAME; 1169 else if (f & SEC_ALLOC) 1170 outname = NLM_UNINITIALIZED_DATA_NAME; 1171 else 1172 outname = bfd_section_name (inbfd, insec); 1173 1174 outsec = bfd_get_section_by_name (outbfd, outname); 1175 if (outsec == NULL) 1176 { 1177 outsec = bfd_make_section (outbfd, outname); 1178 if (outsec == NULL) 1179 bfd_fatal (_("make section")); 1180 } 1181 1182 insec->output_section = outsec; 1183 1184 offset = bfd_section_size (outbfd, outsec); 1185 align = 1 << bfd_section_alignment (inbfd, insec); 1186 add = ((offset + align - 1) &~ (align - 1)) - offset; 1187 insec->output_offset = offset + add; 1188 1189 if (! bfd_set_section_size (outbfd, outsec, 1190 (bfd_section_size (outbfd, outsec) 1191 + bfd_section_size (inbfd, insec) 1192 + add))) 1193 bfd_fatal (_("set section size")); 1194 1195 if ((bfd_section_alignment (inbfd, insec) 1196 > bfd_section_alignment (outbfd, outsec)) 1197 && ! bfd_set_section_alignment (outbfd, outsec, 1198 bfd_section_alignment (inbfd, insec))) 1199 bfd_fatal (_("set section alignment")); 1200 1201 if (! bfd_set_section_flags (outbfd, outsec, 1202 f | bfd_get_section_flags (outbfd, outsec))) 1203 bfd_fatal (_("set section flags")); 1204 1205 bfd_set_reloc (outbfd, outsec, (arelent **) NULL, 0); 1206 1207 /* For each input section we allocate space for an entry in 1208 .nlmsections. */ 1209 secsecsize = bfd_section_size (outbfd, secsec); 1210 secsecsize += strlen (bfd_section_name (inbfd, insec)) + 1; 1211 secsecsize = (secsecsize + 3) &~ 3; 1212 secsecsize += 8; 1213 if (! bfd_set_section_size (outbfd, secsec, secsecsize)) 1214 bfd_fatal (_("set .nlmsections size")); 1215} 1216 1217/* Copy the section contents. */ 1218 1219static void 1220copy_sections (bfd *inbfd, asection *insec, void *data_ptr) 1221{ 1222 static bfd_size_type secsecoff = 0; 1223 bfd *outbfd = (bfd *) data_ptr; 1224 const char *inname; 1225 asection *outsec; 1226 bfd_size_type size; 1227 void *contents; 1228 long reloc_size; 1229 bfd_byte buf[4]; 1230 bfd_size_type add; 1231 1232 inname = bfd_section_name (inbfd, insec); 1233 1234 outsec = insec->output_section; 1235 assert (outsec != NULL); 1236 1237 size = bfd_get_section_size (insec); 1238 1239 if ((bfd_get_section_flags (inbfd, insec) & SEC_HAS_CONTENTS) == 0) 1240 contents = NULL; 1241 else 1242 { 1243 contents = xmalloc (size); 1244 if (! bfd_get_section_contents (inbfd, insec, contents, 1245 (file_ptr) 0, size)) 1246 bfd_fatal (bfd_get_filename (inbfd)); 1247 } 1248 1249 reloc_size = bfd_get_reloc_upper_bound (inbfd, insec); 1250 if (reloc_size < 0) 1251 bfd_fatal (bfd_get_filename (inbfd)); 1252 if (reloc_size != 0) 1253 { 1254 arelent **relocs; 1255 long reloc_count; 1256 1257 relocs = (arelent **) xmalloc (reloc_size); 1258 reloc_count = bfd_canonicalize_reloc (inbfd, insec, relocs, symbols); 1259 if (reloc_count < 0) 1260 bfd_fatal (bfd_get_filename (inbfd)); 1261 mangle_relocs (outbfd, insec, &relocs, &reloc_count, (char *) contents, 1262 size); 1263 1264 /* FIXME: refers to internal BFD fields. */ 1265 if (outsec->orelocation != (arelent **) NULL) 1266 { 1267 bfd_size_type total_count; 1268 arelent **combined; 1269 1270 total_count = reloc_count + outsec->reloc_count; 1271 combined = (arelent **) xmalloc (total_count * sizeof (arelent *)); 1272 memcpy (combined, outsec->orelocation, 1273 outsec->reloc_count * sizeof (arelent *)); 1274 memcpy (combined + outsec->reloc_count, relocs, 1275 (size_t) (reloc_count * sizeof (arelent *))); 1276 free (outsec->orelocation); 1277 reloc_count = total_count; 1278 relocs = combined; 1279 } 1280 1281 bfd_set_reloc (outbfd, outsec, relocs, reloc_count); 1282 } 1283 1284 if (contents != NULL) 1285 { 1286 if (! bfd_set_section_contents (outbfd, outsec, contents, 1287 insec->output_offset, size)) 1288 bfd_fatal (bfd_get_filename (outbfd)); 1289 free (contents); 1290 } 1291 1292 /* Add this section to .nlmsections. */ 1293 if (! bfd_set_section_contents (outbfd, secsec, (void *) inname, secsecoff, 1294 strlen (inname) + 1)) 1295 bfd_fatal (_("set .nlmsection contents")); 1296 secsecoff += strlen (inname) + 1; 1297 1298 add = ((secsecoff + 3) &~ 3) - secsecoff; 1299 if (add != 0) 1300 { 1301 bfd_h_put_32 (outbfd, (bfd_vma) 0, buf); 1302 if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, add)) 1303 bfd_fatal (_("set .nlmsection contents")); 1304 secsecoff += add; 1305 } 1306 1307 if (contents != NULL) 1308 bfd_h_put_32 (outbfd, (bfd_vma) outsec->filepos, buf); 1309 else 1310 bfd_h_put_32 (outbfd, (bfd_vma) 0, buf); 1311 if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, 4)) 1312 bfd_fatal (_("set .nlmsection contents")); 1313 secsecoff += 4; 1314 1315 bfd_h_put_32 (outbfd, (bfd_vma) size, buf); 1316 if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, 4)) 1317 bfd_fatal (_("set .nlmsection contents")); 1318 secsecoff += 4; 1319} 1320 1321/* Some, perhaps all, NetWare targets require changing the relocs used 1322 by the input formats. */ 1323 1324static void 1325mangle_relocs (bfd *outbfd, asection *insec, arelent ***relocs_ptr, 1326 long *reloc_count_ptr, char *contents, 1327 bfd_size_type contents_size) 1328{ 1329 switch (bfd_get_arch (outbfd)) 1330 { 1331#ifdef NLMCONV_I386 1332 case bfd_arch_i386: 1333 i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, 1334 contents, contents_size); 1335 break; 1336#endif 1337#ifdef NLMCONV_ALPHA 1338 case bfd_arch_alpha: 1339 alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, 1340 contents, contents_size); 1341 break; 1342#endif 1343#ifdef NLMCONV_POWERPC 1344 case bfd_arch_powerpc: 1345 powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, 1346 contents, contents_size); 1347 break; 1348#endif 1349 default: 1350 default_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, 1351 contents, contents_size); 1352 break; 1353 } 1354} 1355 1356/* By default all we need to do for relocs is change the address by 1357 the output_offset. */ 1358 1359static void 1360default_mangle_relocs (bfd *outbfd ATTRIBUTE_UNUSED, asection *insec, 1361 arelent ***relocs_ptr, long *reloc_count_ptr, 1362 char *contents ATTRIBUTE_UNUSED, 1363 bfd_size_type contents_size ATTRIBUTE_UNUSED) 1364{ 1365 if (insec->output_offset != 0) 1366 { 1367 long reloc_count; 1368 arelent **relocs; 1369 long i; 1370 1371 reloc_count = *reloc_count_ptr; 1372 relocs = *relocs_ptr; 1373 for (i = 0; i < reloc_count; i++, relocs++) 1374 (*relocs)->address += insec->output_offset; 1375 } 1376} 1377 1378#ifdef NLMCONV_I386 1379 1380/* NetWare on the i386 supports a restricted set of relocs, which are 1381 different from those used on other i386 targets. This routine 1382 converts the relocs. It is, obviously, very target dependent. At 1383 the moment, the nlm32-i386 backend performs similar translations; 1384 however, it is more reliable and efficient to do them here. */ 1385 1386static reloc_howto_type nlm_i386_pcrel_howto = 1387 HOWTO (1, /* type */ 1388 0, /* rightshift */ 1389 2, /* size (0 = byte, 1 = short, 2 = long) */ 1390 32, /* bitsize */ 1391 TRUE, /* pc_relative */ 1392 0, /* bitpos */ 1393 complain_overflow_signed, /* complain_on_overflow */ 1394 0, /* special_function */ 1395 "DISP32", /* name */ 1396 TRUE, /* partial_inplace */ 1397 0xffffffff, /* src_mask */ 1398 0xffffffff, /* dst_mask */ 1399 TRUE); /* pcrel_offset */ 1400 1401static void 1402i386_mangle_relocs (bfd *outbfd, asection *insec, arelent ***relocs_ptr, 1403 long *reloc_count_ptr, char *contents, 1404 bfd_size_type contents_size) 1405{ 1406 long reloc_count, i; 1407 arelent **relocs; 1408 1409 reloc_count = *reloc_count_ptr; 1410 relocs = *relocs_ptr; 1411 for (i = 0; i < reloc_count; i++) 1412 { 1413 arelent *rel; 1414 asymbol *sym; 1415 bfd_size_type address; 1416 bfd_vma addend; 1417 1418 rel = *relocs++; 1419 /* PR 17512: file: 057f89c1. */ 1420 if (rel->sym_ptr_ptr == NULL) 1421 continue; 1422 sym = *rel->sym_ptr_ptr; 1423 1424 /* We're moving the relocs from the input section to the output 1425 section, so we must adjust the address accordingly. */ 1426 address = rel->address; 1427 rel->address += insec->output_offset; 1428 1429 /* Note that no serious harm will ensue if we fail to change a 1430 reloc. The backend will fail when writing out the reloc. */ 1431 1432 /* Make sure this reloc is within the data we have. We use only 1433 4 byte relocs here, so we insist on having 4 bytes. */ 1434 if (address + 4 > contents_size) 1435 continue; 1436 1437 /* A PC relative reloc entirely within a single section is 1438 completely unnecessary. This can be generated by ld -r. */ 1439 if (sym == insec->symbol 1440 && rel->howto != NULL 1441 && rel->howto->pc_relative 1442 && ! rel->howto->pcrel_offset) 1443 { 1444 --*reloc_count_ptr; 1445 --relocs; 1446 memmove (relocs, relocs + 1, 1447 (size_t) ((reloc_count - i) * sizeof (arelent *))); 1448 continue; 1449 } 1450 1451 /* Get the amount the relocation will add in. */ 1452 addend = rel->addend + sym->value; 1453 1454 /* NetWare doesn't support PC relative relocs against defined 1455 symbols, so we have to eliminate them by doing the relocation 1456 now. We can only do this if the reloc is within a single 1457 section. */ 1458 if (rel->howto != NULL 1459 && rel->howto->pc_relative 1460 && bfd_get_section (sym) == insec->output_section) 1461 { 1462 bfd_vma val; 1463 1464 if (rel->howto->pcrel_offset) 1465 addend -= address; 1466 1467 val = bfd_get_32 (outbfd, (bfd_byte *) contents + address); 1468 val += addend; 1469 bfd_put_32 (outbfd, val, (bfd_byte *) contents + address); 1470 1471 --*reloc_count_ptr; 1472 --relocs; 1473 memmove (relocs, relocs + 1, 1474 (size_t) ((reloc_count - i) * sizeof (arelent *))); 1475 continue; 1476 } 1477 1478 /* NetWare doesn't support reloc addends, so we get rid of them 1479 here by simply adding them into the object data. We handle 1480 the symbol value, if any, the same way. */ 1481 if (addend != 0 1482 && rel->howto != NULL 1483 && rel->howto->rightshift == 0 1484 && rel->howto->size == 2 1485 && rel->howto->bitsize == 32 1486 && rel->howto->bitpos == 0 1487 && rel->howto->src_mask == 0xffffffff 1488 && rel->howto->dst_mask == 0xffffffff) 1489 { 1490 bfd_vma val; 1491 1492 val = bfd_get_32 (outbfd, (bfd_byte *) contents + address); 1493 val += addend; 1494 bfd_put_32 (outbfd, val, (bfd_byte *) contents + address); 1495 1496 /* Adjust the reloc for the changes we just made. */ 1497 rel->addend = 0; 1498 if (! bfd_is_und_section (bfd_get_section (sym))) 1499 rel->sym_ptr_ptr = bfd_get_section (sym)->symbol_ptr_ptr; 1500 } 1501 1502 /* NetWare uses a reloc with pcrel_offset set. We adjust 1503 pc_relative relocs accordingly. We are going to change the 1504 howto field, so we can only do this if the current one is 1505 compatible. We should check that special_function is NULL 1506 here, but at the moment coff-i386 uses a special_function 1507 which does not affect what we are doing here. */ 1508 if (rel->howto != NULL 1509 && rel->howto->pc_relative 1510 && ! rel->howto->pcrel_offset 1511 && rel->howto->rightshift == 0 1512 && rel->howto->size == 2 1513 && rel->howto->bitsize == 32 1514 && rel->howto->bitpos == 0 1515 && rel->howto->src_mask == 0xffffffff 1516 && rel->howto->dst_mask == 0xffffffff) 1517 { 1518 bfd_vma val; 1519 1520 /* When pcrel_offset is not set, it means that the negative 1521 of the address of the memory location is stored in the 1522 memory location. We must add it back in. */ 1523 val = bfd_get_32 (outbfd, (bfd_byte *) contents + address); 1524 val += address; 1525 bfd_put_32 (outbfd, val, (bfd_byte *) contents + address); 1526 1527 /* We must change to a new howto. */ 1528 rel->howto = &nlm_i386_pcrel_howto; 1529 } 1530 } 1531} 1532 1533#endif /* NLMCONV_I386 */ 1534 1535#ifdef NLMCONV_ALPHA 1536 1537/* On the Alpha the first reloc for every section must be a special 1538 relocs which hold the GP address. Also, the first reloc in the 1539 file must be a special reloc which holds the address of the .lita 1540 section. */ 1541 1542static reloc_howto_type nlm32_alpha_nw_howto = 1543 HOWTO (ALPHA_R_NW_RELOC, /* type */ 1544 0, /* rightshift */ 1545 0, /* size (0 = byte, 1 = short, 2 = long) */ 1546 0, /* bitsize */ 1547 FALSE, /* pc_relative */ 1548 0, /* bitpos */ 1549 complain_overflow_dont, /* complain_on_overflow */ 1550 0, /* special_function */ 1551 "NW_RELOC", /* name */ 1552 FALSE, /* partial_inplace */ 1553 0, /* src_mask */ 1554 0, /* dst_mask */ 1555 FALSE); /* pcrel_offset */ 1556 1557static void 1558alpha_mangle_relocs (bfd *outbfd, asection *insec, 1559 arelent ***relocs_ptr, long *reloc_count_ptr, 1560 char *contents ATTRIBUTE_UNUSED, 1561 bfd_size_type contents_size ATTRIBUTE_UNUSED) 1562{ 1563 long old_reloc_count; 1564 arelent **old_relocs; 1565 arelent **relocs; 1566 1567 old_reloc_count = *reloc_count_ptr; 1568 old_relocs = *relocs_ptr; 1569 relocs = (arelent **) xmalloc ((old_reloc_count + 3) * sizeof (arelent *)); 1570 *relocs_ptr = relocs; 1571 1572 if (nlm_alpha_backend_data (outbfd)->lita_address == 0) 1573 { 1574 bfd *inbfd; 1575 asection *lita_section; 1576 1577 inbfd = insec->owner; 1578 lita_section = bfd_get_section_by_name (inbfd, _LITA); 1579 if (lita_section != (asection *) NULL) 1580 { 1581 nlm_alpha_backend_data (outbfd)->lita_address = 1582 bfd_get_section_vma (inbfd, lita_section); 1583 nlm_alpha_backend_data (outbfd)->lita_size = 1584 bfd_section_size (inbfd, lita_section); 1585 } 1586 else 1587 { 1588 /* Avoid outputting this reloc again. */ 1589 nlm_alpha_backend_data (outbfd)->lita_address = 4; 1590 } 1591 1592 *relocs = (arelent *) xmalloc (sizeof (arelent)); 1593 (*relocs)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 1594 (*relocs)->address = nlm_alpha_backend_data (outbfd)->lita_address; 1595 (*relocs)->addend = nlm_alpha_backend_data (outbfd)->lita_size + 1; 1596 (*relocs)->howto = &nlm32_alpha_nw_howto; 1597 ++relocs; 1598 ++(*reloc_count_ptr); 1599 } 1600 1601 /* Get the GP value from bfd. */ 1602 if (nlm_alpha_backend_data (outbfd)->gp == 0) 1603 nlm_alpha_backend_data (outbfd)->gp = 1604 bfd_ecoff_get_gp_value (insec->owner); 1605 1606 *relocs = (arelent *) xmalloc (sizeof (arelent)); 1607 (*relocs)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 1608 (*relocs)->address = nlm_alpha_backend_data (outbfd)->gp; 1609 (*relocs)->addend = 0; 1610 (*relocs)->howto = &nlm32_alpha_nw_howto; 1611 ++relocs; 1612 ++(*reloc_count_ptr); 1613 1614 memcpy (relocs, old_relocs, (size_t) old_reloc_count * sizeof (arelent *)); 1615 relocs[old_reloc_count] = (arelent *) NULL; 1616 1617 free (old_relocs); 1618 1619 if (insec->output_offset != 0) 1620 { 1621 bfd_size_type i; 1622 1623 for (i = 0; i < (bfd_size_type) old_reloc_count; i++, relocs++) 1624 (*relocs)->address += insec->output_offset; 1625 } 1626} 1627 1628#endif /* NLMCONV_ALPHA */ 1629 1630#ifdef NLMCONV_POWERPC 1631 1632/* We keep a linked list of stubs which we must build. Because BFD 1633 requires us to know the sizes of all sections before we can set the 1634 contents of any, we must figure out which stubs we want to build 1635 before we can actually build any of them. */ 1636 1637struct powerpc_stub 1638{ 1639 /* Next stub in linked list. */ 1640 struct powerpc_stub *next; 1641 1642 /* Symbol whose value is the start of the stub. This is a symbol 1643 whose name begins with `.'. */ 1644 asymbol *start; 1645 1646 /* Symbol we are going to create a reloc against. This is a symbol 1647 with the same name as START but without the leading `.'. */ 1648 asymbol *reloc; 1649 1650 /* The TOC index for this stub. This is the index into the TOC 1651 section at which the reloc is created. */ 1652 unsigned int toc_index; 1653}; 1654 1655/* The linked list of stubs. */ 1656 1657static struct powerpc_stub *powerpc_stubs; 1658 1659/* This is what a stub looks like. The first instruction will get 1660 adjusted with the correct TOC index. */ 1661 1662static unsigned long powerpc_stub_insns[] = 1663{ 1664 0x81820000, /* lwz r12,0(r2) */ 1665 0x90410014, /* stw r2,20(r1) */ 1666 0x800c0000, /* lwz r0,0(r12) */ 1667 0x804c0004, /* lwz r2,r(r12) */ 1668 0x7c0903a6, /* mtctr r0 */ 1669 0x4e800420, /* bctr */ 1670 0, /* Traceback table. */ 1671 0xc8000, 1672 0 1673}; 1674 1675#define POWERPC_STUB_INSN_COUNT \ 1676 (sizeof powerpc_stub_insns / sizeof powerpc_stub_insns[0]) 1677 1678#define POWERPC_STUB_SIZE (4 * POWERPC_STUB_INSN_COUNT) 1679 1680/* Each stub uses a four byte TOC entry. */ 1681#define POWERPC_STUB_TOC_ENTRY_SIZE (4) 1682 1683/* The original size of the .got section. */ 1684static bfd_size_type powerpc_initial_got_size; 1685 1686/* Look for all undefined symbols beginning with `.', and prepare to 1687 build a stub for each one. */ 1688 1689static void 1690powerpc_build_stubs (bfd *inbfd, bfd *outbfd ATTRIBUTE_UNUSED, 1691 asymbol ***symbols_ptr, long *symcount_ptr) 1692{ 1693 asection *stub_sec; 1694 asection *got_sec; 1695 unsigned int got_base; 1696 long i; 1697 long symcount; 1698 long stubcount; 1699 1700 /* Make a section to hold stubs. We don't set SEC_HAS_CONTENTS for 1701 the section to prevent copy_sections from reading from it. */ 1702 stub_sec = bfd_make_section_with_flags (inbfd, ".stubs", 1703 (SEC_CODE 1704 | SEC_RELOC 1705 | SEC_ALLOC 1706 | SEC_LOAD)); 1707 if (stub_sec == (asection *) NULL 1708 || ! bfd_set_section_alignment (inbfd, stub_sec, 2)) 1709 bfd_fatal (".stubs"); 1710 1711 /* Get the TOC section, which is named .got. */ 1712 got_sec = bfd_get_section_by_name (inbfd, ".got"); 1713 if (got_sec == (asection *) NULL) 1714 { 1715 got_sec = bfd_make_section_with_flags (inbfd, ".got", 1716 (SEC_DATA 1717 | SEC_RELOC 1718 | SEC_ALLOC 1719 | SEC_LOAD 1720 | SEC_HAS_CONTENTS)); 1721 if (got_sec == (asection *) NULL 1722 || ! bfd_set_section_alignment (inbfd, got_sec, 2)) 1723 bfd_fatal (".got"); 1724 } 1725 1726 powerpc_initial_got_size = bfd_section_size (inbfd, got_sec); 1727 got_base = powerpc_initial_got_size; 1728 got_base = (got_base + 3) &~ 3; 1729 1730 stubcount = 0; 1731 1732 symcount = *symcount_ptr; 1733 for (i = 0; i < symcount; i++) 1734 { 1735 asymbol *sym; 1736 asymbol *newsym; 1737 char *newname; 1738 struct powerpc_stub *item; 1739 1740 sym = (*symbols_ptr)[i]; 1741 1742 /* We must make a stub for every undefined symbol whose name 1743 starts with '.'. */ 1744 if (bfd_asymbol_name (sym)[0] != '.' 1745 || ! bfd_is_und_section (bfd_get_section (sym))) 1746 continue; 1747 1748 /* Make a new undefined symbol with the same name but without 1749 the leading `.'. */ 1750 newsym = xmalloc (sizeof (asymbol)); 1751 *newsym = *sym; 1752 newname = xmalloc (strlen (bfd_asymbol_name (sym))); 1753 strcpy (newname, bfd_asymbol_name (sym) + 1); 1754 newsym->name = newname; 1755 1756 /* Define the `.' symbol to be in the stub section. */ 1757 sym->section = stub_sec; 1758 sym->value = stubcount * POWERPC_STUB_SIZE; 1759 /* We set the BSF_DYNAMIC flag here so that we can check it when 1760 we are mangling relocs. FIXME: This is a hack. */ 1761 sym->flags = BSF_LOCAL | BSF_DYNAMIC; 1762 1763 /* Add this stub to the linked list. */ 1764 item = (struct powerpc_stub *) xmalloc (sizeof (struct powerpc_stub)); 1765 item->start = sym; 1766 item->reloc = newsym; 1767 item->toc_index = got_base + stubcount * POWERPC_STUB_TOC_ENTRY_SIZE; 1768 1769 item->next = powerpc_stubs; 1770 powerpc_stubs = item; 1771 1772 ++stubcount; 1773 } 1774 1775 if (stubcount > 0) 1776 { 1777 asymbol **s; 1778 struct powerpc_stub *l; 1779 1780 /* Add the new symbols we just created to the symbol table. */ 1781 *symbols_ptr = (asymbol **) xrealloc ((char *) *symbols_ptr, 1782 ((symcount + stubcount) 1783 * sizeof (asymbol))); 1784 *symcount_ptr += stubcount; 1785 s = &(*symbols_ptr)[symcount]; 1786 for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next) 1787 *s++ = l->reloc; 1788 1789 /* Set the size of the .stubs section and increase the size of 1790 the .got section. */ 1791 if (! bfd_set_section_size (inbfd, stub_sec, 1792 stubcount * POWERPC_STUB_SIZE) 1793 || ! bfd_set_section_size (inbfd, got_sec, 1794 (got_base 1795 + (stubcount 1796 * POWERPC_STUB_TOC_ENTRY_SIZE)))) 1797 bfd_fatal (_("stub section sizes")); 1798 } 1799} 1800 1801/* Resolve all the stubs for PowerPC NetWare. We fill in the contents 1802 of the output section, and create new relocs in the TOC. */ 1803 1804static void 1805powerpc_resolve_stubs (bfd *inbfd, bfd *outbfd) 1806{ 1807 bfd_byte buf[POWERPC_STUB_SIZE]; 1808 unsigned int i; 1809 unsigned int stubcount; 1810 arelent **relocs; 1811 asection *got_sec; 1812 arelent **r; 1813 struct powerpc_stub *l; 1814 1815 if (powerpc_stubs == (struct powerpc_stub *) NULL) 1816 return; 1817 1818 for (i = 0; i < POWERPC_STUB_INSN_COUNT; i++) 1819 bfd_put_32 (outbfd, (bfd_vma) powerpc_stub_insns[i], buf + i * 4); 1820 1821 got_sec = bfd_get_section_by_name (inbfd, ".got"); 1822 assert (got_sec != (asection *) NULL); 1823 assert (got_sec->output_section->orelocation == (arelent **) NULL); 1824 1825 stubcount = 0; 1826 for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next) 1827 ++stubcount; 1828 relocs = (arelent **) xmalloc (stubcount * sizeof (arelent *)); 1829 1830 r = relocs; 1831 for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next) 1832 { 1833 arelent *reloc; 1834 1835 /* Adjust the first instruction to use the right TOC index. */ 1836 bfd_put_32 (outbfd, (bfd_vma) powerpc_stub_insns[0] + l->toc_index, buf); 1837 1838 /* Write this stub out. */ 1839 if (! bfd_set_section_contents (outbfd, 1840 bfd_get_section (l->start), 1841 buf, 1842 l->start->value, 1843 POWERPC_STUB_SIZE)) 1844 bfd_fatal (_("writing stub")); 1845 1846 /* Create a new reloc for the TOC entry. */ 1847 reloc = (arelent *) xmalloc (sizeof (arelent)); 1848 reloc->sym_ptr_ptr = &l->reloc; 1849 reloc->address = l->toc_index + got_sec->output_offset; 1850 reloc->addend = 0; 1851 reloc->howto = bfd_reloc_type_lookup (inbfd, BFD_RELOC_32); 1852 1853 *r++ = reloc; 1854 } 1855 1856 bfd_set_reloc (outbfd, got_sec->output_section, relocs, stubcount); 1857} 1858 1859/* Adjust relocation entries for PowerPC NetWare. We do not output 1860 TOC relocations. The object code already contains the offset from 1861 the TOC pointer. When the function is called, the TOC register, 1862 r2, will be set to the correct TOC value, so there is no need for 1863 any further reloc. */ 1864 1865static void 1866powerpc_mangle_relocs (bfd *outbfd, asection *insec, 1867 arelent ***relocs_ptr, 1868 long *reloc_count_ptr, char *contents, 1869 bfd_size_type contents_size ATTRIBUTE_UNUSED) 1870{ 1871 reloc_howto_type *toc_howto; 1872 long reloc_count; 1873 arelent **relocs; 1874 long i; 1875 1876 toc_howto = bfd_reloc_type_lookup (insec->owner, BFD_RELOC_PPC_TOC16); 1877 if (toc_howto == (reloc_howto_type *) NULL) 1878 fatal (_("Unable to locate PPC_TOC16 reloc information")); 1879 1880 /* If this is the .got section, clear out all the contents beyond 1881 the initial size. We must do this here because copy_sections is 1882 going to write out whatever we return in the contents field. */ 1883 if (strcmp (bfd_get_section_name (insec->owner, insec), ".got") == 0) 1884 memset (contents + powerpc_initial_got_size, 0, 1885 (size_t) (bfd_get_section_size (insec) - powerpc_initial_got_size)); 1886 1887 reloc_count = *reloc_count_ptr; 1888 relocs = *relocs_ptr; 1889 for (i = 0; i < reloc_count; i++) 1890 { 1891 arelent *rel; 1892 asymbol *sym; 1893 bfd_vma sym_value; 1894 1895 rel = *relocs++; 1896 sym = *rel->sym_ptr_ptr; 1897 1898 /* Convert any relocs against the .bss section into relocs 1899 against the .data section. */ 1900 if (strcmp (bfd_get_section_name (outbfd, bfd_get_section (sym)), 1901 NLM_UNINITIALIZED_DATA_NAME) == 0) 1902 { 1903 asection *datasec; 1904 1905 datasec = bfd_get_section_by_name (outbfd, 1906 NLM_INITIALIZED_DATA_NAME); 1907 if (datasec != NULL) 1908 { 1909 rel->addend += (bfd_get_section_vma (outbfd, 1910 bfd_get_section (sym)) 1911 + sym->value); 1912 rel->sym_ptr_ptr = datasec->symbol_ptr_ptr; 1913 sym = *rel->sym_ptr_ptr; 1914 } 1915 } 1916 1917 /* PR 17512: file: 70cfde95. */ 1918 if (rel->howto == NULL) 1919 continue; 1920 1921 /* We must be able to resolve all PC relative relocs at this 1922 point. If we get a branch to an undefined symbol we build a 1923 stub, since NetWare will resolve undefined symbols into a 1924 pointer to a function descriptor. */ 1925 if (rel->howto->pc_relative) 1926 { 1927 /* This check for whether a symbol is in the same section as 1928 the reloc will be wrong if there is a PC relative reloc 1929 between two sections both of which were placed in the 1930 same output section. This should not happen. */ 1931 if (bfd_get_section (sym) != insec->output_section) 1932 non_fatal (_("unresolved PC relative reloc against %s"), 1933 bfd_asymbol_name (sym)); 1934 else 1935 { 1936 bfd_vma val; 1937 1938 if (rel->address > contents_size - 4) 1939 { 1940 non_fatal (_("Out of range relocation: %lx"), 1941 (long) rel->address); 1942 break; 1943 } 1944 1945 assert (rel->howto->size == 2 && rel->howto->pcrel_offset); 1946 val = bfd_get_32 (outbfd, (bfd_byte *) contents + rel->address); 1947 val = ((val &~ rel->howto->dst_mask) 1948 | (((val & rel->howto->src_mask) 1949 + (sym->value - rel->address) 1950 + rel->addend) 1951 & rel->howto->dst_mask)); 1952 bfd_put_32 (outbfd, val, (bfd_byte *) contents + rel->address); 1953 1954 /* If this reloc is against an stubbed symbol and the 1955 next instruction is 1956 cror 31,31,31 1957 then we replace the next instruction with 1958 lwz r2,20(r1) 1959 This reloads the TOC pointer after a stub call. */ 1960 if (bfd_asymbol_name (sym)[0] == '.' 1961 && (sym->flags & BSF_DYNAMIC) != 0 1962 && (bfd_get_32 (outbfd, 1963 (bfd_byte *) contents + rel->address + 4) 1964 == 0x4ffffb82)) /* cror 31,31,31 */ 1965 bfd_put_32 (outbfd, (bfd_vma) 0x80410014, /* lwz r2,20(r1) */ 1966 (bfd_byte *) contents + rel->address + 4); 1967 1968 --*reloc_count_ptr; 1969 --relocs; 1970 memmove (relocs, relocs + 1, 1971 (size_t) ((reloc_count - 1) * sizeof (arelent *))); 1972 continue; 1973 } 1974 } 1975 1976 /* When considering a TOC reloc, we do not want to include the 1977 symbol value. The symbol will be start of the TOC section 1978 (which is named .got). We do want to include the addend. */ 1979 if (rel->howto == toc_howto) 1980 sym_value = 0; 1981 else 1982 sym_value = sym->value; 1983 1984 /* If this is a relocation against a symbol with a value, or 1985 there is a reloc addend, we need to update the addend in the 1986 object file. */ 1987 if (sym_value + rel->addend != 0) 1988 { 1989 bfd_vma val; 1990 1991 switch (rel->howto->size) 1992 { 1993 case 1: 1994 if (rel->address > contents_size - 2) 1995 { 1996 non_fatal (_("Out of range relocation: %lx"), 1997 (long) rel->address); 1998 break; 1999 } 2000 2001 val = bfd_get_16 (outbfd, 2002 (bfd_byte *) contents + rel->address); 2003 val = ((val &~ rel->howto->dst_mask) 2004 | (((val & rel->howto->src_mask) 2005 + sym_value 2006 + rel->addend) 2007 & rel->howto->dst_mask)); 2008 if ((bfd_signed_vma) val < - 0x8000 2009 || (bfd_signed_vma) val >= 0x8000) 2010 non_fatal (_("overflow when adjusting relocation against %s"), 2011 bfd_asymbol_name (sym)); 2012 bfd_put_16 (outbfd, val, (bfd_byte *) contents + rel->address); 2013 break; 2014 2015 case 2: 2016 /* PR 17512: file: 0455a112. */ 2017 if (rel->address > contents_size - 4) 2018 { 2019 non_fatal (_("Out of range relocation: %lx"), 2020 (long) rel->address); 2021 break; 2022 } 2023 2024 val = bfd_get_32 (outbfd, 2025 (bfd_byte *) contents + rel->address); 2026 val = ((val &~ rel->howto->dst_mask) 2027 | (((val & rel->howto->src_mask) 2028 + sym_value 2029 + rel->addend) 2030 & rel->howto->dst_mask)); 2031 bfd_put_32 (outbfd, val, (bfd_byte *) contents + rel->address); 2032 break; 2033 2034 default: 2035 fatal (_("Unsupported relocation size: %d"), rel->howto->size); 2036 } 2037 2038 if (! bfd_is_und_section (bfd_get_section (sym))) 2039 rel->sym_ptr_ptr = bfd_get_section (sym)->symbol_ptr_ptr; 2040 rel->addend = 0; 2041 } 2042 2043 /* Now that we have incorporated the addend, remove any TOC 2044 relocs. */ 2045 if (rel->howto == toc_howto) 2046 { 2047 --*reloc_count_ptr; 2048 --relocs; 2049 memmove (relocs, relocs + 1, 2050 (size_t) ((reloc_count - i) * sizeof (arelent *))); 2051 continue; 2052 } 2053 2054 rel->address += insec->output_offset; 2055 } 2056} 2057 2058#endif /* NLMCONV_POWERPC */ 2059 2060/* Name of linker. */ 2061#ifndef LD_NAME 2062#define LD_NAME "ld" 2063#endif 2064 2065/* The user has specified several input files. Invoke the linker to 2066 link them all together, and convert and delete the resulting output 2067 file. */ 2068 2069static char * 2070link_inputs (struct string_list *inputs, char *ld, char * mfile) 2071{ 2072 size_t c; 2073 struct string_list *q; 2074 char **argv; 2075 size_t i; 2076 int pid; 2077 int status; 2078 char *errfmt; 2079 char *errarg; 2080 2081 c = 0; 2082 for (q = inputs; q != NULL; q = q->next) 2083 ++c; 2084 2085 argv = (char **) xmalloc ((c + 7) * sizeof (char *)); 2086 2087#ifndef __MSDOS__ 2088 if (ld == NULL) 2089 { 2090 char *p; 2091 2092 /* Find the linker to invoke based on how nlmconv was run. */ 2093 p = program_name + strlen (program_name); 2094 while (p != program_name) 2095 { 2096 if (p[-1] == '/') 2097 { 2098 ld = (char *) xmalloc (p - program_name + strlen (LD_NAME) + 1); 2099 memcpy (ld, program_name, p - program_name); 2100 strcpy (ld + (p - program_name), LD_NAME); 2101 break; 2102 } 2103 --p; 2104 } 2105 } 2106#endif 2107 2108 if (ld == NULL) 2109 ld = (char *) LD_NAME; 2110 2111 unlink_on_exit = make_temp_file (".O"); 2112 2113 argv[0] = ld; 2114 argv[1] = (char *) "-Ur"; 2115 argv[2] = (char *) "-o"; 2116 argv[3] = unlink_on_exit; 2117 /* If we have been given the name of a mapfile and that 2118 name is not 'stderr' then pass it on to the linker. */ 2119 if (mfile 2120 && * mfile 2121 && strcmp (mfile, "stderr") == 0) 2122 { 2123 argv[4] = (char *) "-Map"; 2124 argv[5] = mfile; 2125 i = 6; 2126 } 2127 else 2128 i = 4; 2129 2130 for (q = inputs; q != NULL; q = q->next, i++) 2131 argv[i] = q->string; 2132 argv[i] = NULL; 2133 2134 if (debug) 2135 { 2136 for (i = 0; argv[i] != NULL; i++) 2137 fprintf (stderr, " %s", argv[i]); 2138 fprintf (stderr, "\n"); 2139 } 2140 2141 pid = pexecute (ld, argv, program_name, (char *) NULL, &errfmt, &errarg, 2142 PEXECUTE_SEARCH | PEXECUTE_ONE); 2143 free (argv); 2144 2145 if (pid == -1) 2146 { 2147 fprintf (stderr, _("%s: execution of %s failed: "), program_name, ld); 2148 fprintf (stderr, errfmt, errarg); 2149 unlink (unlink_on_exit); 2150 exit (1); 2151 } 2152 2153 if (pwait (pid, &status, 0) < 0) 2154 { 2155 perror ("pwait"); 2156 unlink (unlink_on_exit); 2157 exit (1); 2158 } 2159 2160 if (status != 0) 2161 { 2162 non_fatal (_("Execution of %s failed"), ld); 2163 unlink (unlink_on_exit); 2164 exit (1); 2165 } 2166 2167 return unlink_on_exit; 2168} 2169