binutils/nlmconv.c

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