Subversion Repositories open8_urisc

/* nlmconv.c -- NLM conversion program

   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,

   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012

   Free Software Foundation, Inc.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

/* Written by Ian Lance Taylor <ian@cygnus.com>.

   This program can be used to convert any appropriate object file

   into a NetWare Loadable Module (an NLM).  It will accept a linker

   specification file which is identical to that accepted by the

   NetWare linker, NLMLINK.  */

/* AIX requires this to be the first thing in the file.  */

#ifndef __GNUC__

# ifdef _AIX

 #pragma alloca

#endif

#endif

#include "sysdep.h"

#include "bfd.h"

#include "libiberty.h"

#include "filenames.h"

#include "safe-ctype.h"

#include "ansidecl.h"

#include <time.h>

#include <assert.h>

#include "getopt.h"

/* Internal BFD NLM header.  */

#include "libnlm.h"

#include "nlmconv.h"

#ifdef NLMCONV_ALPHA

#include "coff/sym.h"

#include "coff/ecoff.h"

#endif

#include "bucomm.h"

/* If strerror is just a macro, we want to use the one from libiberty

   since it will handle undefined values.  */

#undef strerror

extern char *strerror (int);

#ifndef SEEK_SET

#define SEEK_SET 0

#endif

#ifndef R_OK

#define R_OK 4

#define W_OK 2

#define X_OK 1

#endif

/* Global variables.  */

/* The name used to invoke the program.  */

char *program_name;

/* Local variables.  */

/* Whether to print out debugging information (currently just controls

   whether it prints the linker command if there is one).  */

static int debug;

/* The symbol table.  */

static asymbol **symbols;

/* A section we create in the output file to hold pointers to where

   the sections of the input file end up.  We will put a pointer to

   this section in the NLM header.  These is an entry for each input

   section.  The format is

       null terminated section name

       zeroes to adjust to 4 byte boundary

       4 byte section data file pointer

       4 byte section size

   We don't need a version number.  The way we find this information

   is by finding a stamp in the NLM header information.  If we need to

   change the format of this information, we can simply change the

   stamp.  */

static asection *secsec;

/* A temporary file name to be unlinked on exit.  Actually, for most

   errors, we leave it around.  It's not clear whether that is helpful

   or not.  */

static char *unlink_on_exit;

/* The list of long options.  */

static struct option long_options[] =

{

  { "debug", no_argument, 0, 'd' },

  { "header-file", required_argument, 0, 'T' },

  { "help", no_argument, 0, 'h' },

  { "input-target", required_argument, 0, 'I' },

  { "input-format", required_argument, 0, 'I' }, /* Obsolete */

  { "linker", required_argument, 0, 'l' },

  { "output-target", required_argument, 0, 'O' },

  { "output-format", required_argument, 0, 'O' }, /* Obsolete */

  { "version", no_argument, 0, 'V' },

  { NULL, no_argument, 0, 0 }

};

/* Local routines.  */

int main (int, char **);

static void show_usage (FILE *, int);

static const char *select_output_format

  (enum bfd_architecture, unsigned long, bfd_boolean);

static void setup_sections (bfd *, asection *, void *);

static void copy_sections (bfd *, asection *, void *);

static void mangle_relocs

  (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

static void default_mangle_relocs

  (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

static char *link_inputs (struct string_list *, char *, char *);

#ifdef NLMCONV_I386

static void i386_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

#endif

#ifdef NLMCONV_ALPHA

static void alpha_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

#endif

#ifdef NLMCONV_POWERPC

static void powerpc_build_stubs (bfd *, bfd *, asymbol ***, long *);

static void powerpc_resolve_stubs (bfd *, bfd *);

static void powerpc_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

#endif

/* The main routine.  */

int

main (int argc, char **argv)

{

  int opt;

  char *input_file = NULL;

  const char *input_format = NULL;

  const char *output_format = NULL;

  const char *header_file = NULL;

  char *ld_arg = NULL;

  Nlm_Internal_Fixed_Header fixed_hdr_struct;

  Nlm_Internal_Variable_Header var_hdr_struct;

  Nlm_Internal_Version_Header version_hdr_struct;

  Nlm_Internal_Copyright_Header copyright_hdr_struct;

  Nlm_Internal_Extended_Header extended_hdr_struct;

  bfd *inbfd;

  bfd *outbfd;

  asymbol **newsyms, **outsyms;

  long symcount, newsymalloc, newsymcount;

  long symsize;

  asection *text_sec, *bss_sec, *data_sec;

  bfd_vma vma;

  bfd_size_type align;

  asymbol *endsym;

  long i;

  char inlead, outlead;

  bfd_boolean gotstart, gotexit, gotcheck;

  struct stat st;

  FILE *custom_data = NULL;

  FILE *help_data = NULL;

  FILE *message_data = NULL;

  FILE *rpc_data = NULL;

  FILE *shared_data = NULL;

  size_t custom_size = 0;

  size_t help_size = 0;

  size_t message_size = 0;

  size_t module_size = 0;

  size_t rpc_size = 0;

  asection *custom_section = NULL;

  asection *help_section = NULL;

  asection *message_section = NULL;

  asection *module_section = NULL;

  asection *rpc_section = NULL;

  asection *shared_section = NULL;

  bfd *sharedbfd;

  size_t shared_offset = 0;

  size_t shared_size = 0;

  static Nlm_Internal_Fixed_Header sharedhdr;

  int len;

  char *modname;

  char **matching;

#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)

  setlocale (LC_MESSAGES, "");

#endif

#if defined (HAVE_SETLOCALE)

  setlocale (LC_CTYPE, "");

#endif

  bindtextdomain (PACKAGE, LOCALEDIR);

  textdomain (PACKAGE);

  program_name = argv[0];

  xmalloc_set_program_name (program_name);

  expandargv (&argc, &argv);

  bfd_init ();

  set_default_bfd_target ();

  while ((opt = getopt_long (argc, argv, "dHhI:l:O:T:Vv", long_options,

                             (int *) NULL))

         != EOF)

    {

      switch (opt)

        {

        case 'd':

          debug = 1;

          break;

        case 'H':

        case 'h':

          show_usage (stdout, 0);

          break;

        case 'I':

          input_format = optarg;

          break;

        case 'l':

          ld_arg = optarg;

          break;

        case 'O':

          output_format = optarg;

          break;

        case 'T':

          header_file = optarg;

          break;

        case 'v':

        case 'V':

          print_version ("nlmconv");

          break;

        case 0:

          break;

        default:

          show_usage (stderr, 1);

          break;

        }

    }

  /* The input and output files may be named on the command line.  */

  output_file = NULL;

  if (optind < argc)

    {

      input_file = argv[optind];

      ++optind;

      if (optind < argc)

        {

          output_file = argv[optind];

          ++optind;

          if (optind < argc)

            show_usage (stderr, 1);

          if (filename_cmp (input_file, output_file) == 0)

            {

              fatal (_("input and output files must be different"));

            }

        }

    }

  /* Initialize the header information to default values.  */

  fixed_hdr = &fixed_hdr_struct;

  memset ((void *) &fixed_hdr_struct, 0, sizeof fixed_hdr_struct);

  var_hdr = &var_hdr_struct;

  memset ((void *) &var_hdr_struct, 0, sizeof var_hdr_struct);

  version_hdr = &version_hdr_struct;

  memset ((void *) &version_hdr_struct, 0, sizeof version_hdr_struct);

  copyright_hdr = &copyright_hdr_struct;

  memset ((void *) &copyright_hdr_struct, 0, sizeof copyright_hdr_struct);

  extended_hdr = &extended_hdr_struct;

  memset ((void *) &extended_hdr_struct, 0, sizeof extended_hdr_struct);

  check_procedure = NULL;

  custom_file = NULL;

  debug_info = FALSE;

  exit_procedure = "_Stop";

  export_symbols = NULL;

  map_file = NULL;

  full_map = FALSE;

  help_file = NULL;

  import_symbols = NULL;

  message_file = NULL;

  modules = NULL;

  sharelib_file = NULL;

  start_procedure = "_Prelude";

  verbose = FALSE;

  rpc_file = NULL;

  parse_errors = 0;

  /* Parse the header file (if there is one).  */

  if (header_file != NULL)

    {

      if (! nlmlex_file (header_file)

          || yyparse () != 0

          || parse_errors != 0)

        exit (1);

    }

  if (input_files != NULL)

    {

      if (input_file != NULL)

        {

          fatal (_("input file named both on command line and with INPUT"));

        }

      if (input_files->next == NULL)

        input_file = input_files->string;

      else

        input_file = link_inputs (input_files, ld_arg, map_file);

    }

  else if (input_file == NULL)

    {

      non_fatal (_("no input file"));

      show_usage (stderr, 1);

    }

  inbfd = bfd_openr (input_file, input_format);

  if (inbfd == NULL)

    bfd_fatal (input_file);

  if (! bfd_check_format_matches (inbfd, bfd_object, &matching))

    {

      bfd_nonfatal (input_file);

      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)

        {

          list_matching_formats (matching);

          free (matching);

        }

      exit (1);

    }

  if (output_format == NULL)

    output_format = select_output_format (bfd_get_arch (inbfd),

                                          bfd_get_mach (inbfd),

                                          bfd_big_endian (inbfd));

  assert (output_format != NULL);

  /* Use the output file named on the command line if it exists.

     Otherwise use the file named in the OUTPUT statement.  */

  if (output_file == NULL)

    {

      non_fatal (_("no name for output file"));

      show_usage (stderr, 1);

    }

  outbfd = bfd_openw (output_file, output_format);

  if (outbfd == NULL)

    bfd_fatal (output_file);

  if (! bfd_set_format (outbfd, bfd_object))

    bfd_fatal (output_file);

  assert (bfd_get_flavour (outbfd) == bfd_target_nlm_flavour);

  /* XXX: Should we accept the unknown bfd format here ?  */

  if (bfd_arch_get_compatible (inbfd, outbfd, TRUE) == NULL)

    non_fatal (_("warning: input and output formats are not compatible"));

  /* Move the values read from the command file into outbfd.  */

  *nlm_fixed_header (outbfd) = fixed_hdr_struct;

  *nlm_variable_header (outbfd) = var_hdr_struct;

  *nlm_version_header (outbfd) = version_hdr_struct;

  *nlm_copyright_header (outbfd) = copyright_hdr_struct;

  *nlm_extended_header (outbfd) = extended_hdr_struct;

  /* Start copying the input BFD to the output BFD.  */

  if (! bfd_set_file_flags (outbfd, bfd_get_file_flags (inbfd)))

    bfd_fatal (bfd_get_filename (outbfd));

  symsize = bfd_get_symtab_upper_bound (inbfd);

  if (symsize < 0)

    bfd_fatal (input_file);

  symbols = (asymbol **) xmalloc (symsize);

  symcount = bfd_canonicalize_symtab (inbfd, symbols);

  if (symcount < 0)

    bfd_fatal (input_file);

  /* Make sure we have a .bss section.  */

  bss_sec = bfd_get_section_by_name (outbfd, NLM_UNINITIALIZED_DATA_NAME);

  if (bss_sec == NULL)

    {

      bss_sec = bfd_make_section_with_flags (outbfd,

                                             NLM_UNINITIALIZED_DATA_NAME,

                                             SEC_ALLOC);

      if (bss_sec == NULL

          || ! bfd_set_section_alignment (outbfd, bss_sec, 1))

        bfd_fatal (_("make .bss section"));

    }

  /* We store the original section names in the .nlmsections section,

     so that programs which understand it can resurrect the original

     sections from the NLM.  We will put a pointer to .nlmsections in

     the NLM header area.  */

  secsec = bfd_make_section_with_flags (outbfd, ".nlmsections",

                                        SEC_HAS_CONTENTS);

  if (secsec == NULL)

    bfd_fatal (_("make .nlmsections section"));

#ifdef NLMCONV_POWERPC

  /* For PowerPC NetWare we need to build stubs for calls to undefined

     symbols.  Because each stub requires an entry in the TOC section

     which must be at the same location as other entries in the TOC

     section, we must do this before determining where the TOC section

     goes in setup_sections.  */

  if (bfd_get_arch (inbfd) == bfd_arch_powerpc)

    powerpc_build_stubs (inbfd, outbfd, &symbols, &symcount);

#endif

  /* Set up the sections.  */

  bfd_map_over_sections (inbfd, setup_sections, (void *) outbfd);

  text_sec = bfd_get_section_by_name (outbfd, NLM_CODE_NAME);

  /* The .bss section immediately follows the .data section.  */

  data_sec = bfd_get_section_by_name (outbfd, NLM_INITIALIZED_DATA_NAME);

  if (data_sec != NULL)

    {

      bfd_size_type add;

      vma = bfd_get_section_size (data_sec);

      align = 1 << bss_sec->alignment_power;

      add = ((vma + align - 1) &~ (align - 1)) - vma;

      vma += add;

      if (! bfd_set_section_vma (outbfd, bss_sec, vma))

        bfd_fatal (_("set .bss vma"));

      if (add != 0)

        {

          bfd_size_type data_size;

          data_size = bfd_get_section_size (data_sec);

          if (! bfd_set_section_size (outbfd, data_sec, data_size + add))

            bfd_fatal (_("set .data size"));

        }

    }

  /* Adjust symbol information.  */

  inlead = bfd_get_symbol_leading_char (inbfd);

  outlead = bfd_get_symbol_leading_char (outbfd);

  gotstart = FALSE;

  gotexit = FALSE;

  gotcheck = FALSE;

  newsymalloc = 10;

  newsyms = (asymbol **) xmalloc (newsymalloc * sizeof (asymbol *));

  newsymcount = 0;

  endsym = NULL;

  for (i = 0; i < symcount; i++)

    {

      asymbol *sym;

      sym = symbols[i];

      /* Add or remove a leading underscore.  */

      if (inlead != outlead)

        {

          if (inlead != '\0')

            {

              if (bfd_asymbol_name (sym)[0] == inlead)

                {

                  if (outlead == '\0')

                    ++sym->name;

                  else

                    {

                      char *new_name;

                      new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 1);

                      new_name[0] = outlead;

                      strcpy (new_name + 1, bfd_asymbol_name (sym) + 1);

                      sym->name = new_name;

                    }

                }

            }

          else

            {

              char *new_name;

              new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 2);

              new_name[0] = outlead;

              strcpy (new_name + 1, bfd_asymbol_name (sym));

              sym->name = new_name;

            }

        }

      /* NLM's have an uninitialized data section, but they do not

         have a common section in the Unix sense.  Move all common

         symbols into the .bss section, and mark them as exported.  */

      if (bfd_is_com_section (bfd_get_section (sym)))

        {

          bfd_vma size = sym->value;

          sym->section = bss_sec;

          sym->value = bfd_get_section_size (bss_sec);

          size += sym->value;

          align = 1 << bss_sec->alignment_power;

          size = (size + align - 1) & ~(align - 1);

          bfd_set_section_size (outbfd, bss_sec, size);

          sym->flags |= BSF_EXPORT | BSF_GLOBAL;

        }

      else if (bfd_get_section (sym)->output_section != NULL)

        {

          /* Move the symbol into the output section.  */

          sym->value += bfd_get_section (sym)->output_offset;

          sym->section = bfd_get_section (sym)->output_section;

          /* This is no longer a section symbol.  */

          sym->flags &=~ BSF_SECTION_SYM;

        }

      /* Force _edata and _end to be defined.  This would normally be

         done by the linker, but the manipulation of the common

         symbols will confuse it.  */

      if ((sym->flags & BSF_DEBUGGING) == 0

          && bfd_asymbol_name (sym)[0] == '_'

          && bfd_is_und_section (bfd_get_section (sym)))

        {

          if (strcmp (bfd_asymbol_name (sym), "_edata") == 0)

            {

              sym->section = bss_sec;

              sym->value = 0;

            }

          if (strcmp (bfd_asymbol_name (sym), "_end") == 0)

            {

              sym->section = bss_sec;

              endsym = sym;

            }

#ifdef NLMCONV_POWERPC

          /* For PowerPC NetWare, we define __GOT0.  This is the start

             of the .got section.  */

          if (bfd_get_arch (inbfd) == bfd_arch_powerpc

              && strcmp (bfd_asymbol_name (sym), "__GOT0") == 0)

            {

              asection *got_sec;

              got_sec = bfd_get_section_by_name (inbfd, ".got");

              assert (got_sec != (asection *) NULL);

              sym->value = got_sec->output_offset;

              sym->section = got_sec->output_section;

            }

#endif

        }

      /* If this is a global symbol, check the export list.  */

      if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0)

        {

          struct string_list *l;

          int found_simple;

          /* Unfortunately, a symbol can appear multiple times on the

             export list, with and without prefixes.  */

          found_simple = 0;

          for (l = export_symbols; l != NULL; l = l->next)

            {

              if (strcmp (l->string, bfd_asymbol_name (sym)) == 0)

                found_simple = 1;

              else

                {

                  char *zbase;

                  zbase = strchr (l->string, '@');

                  if (zbase != NULL

                      && strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0)

                    {

                      /* We must add a symbol with this prefix.  */

                      if (newsymcount >= newsymalloc)

                        {

                          newsymalloc += 10;

                          newsyms = ((asymbol **)

                                     xrealloc ((void *) newsyms,

                                               (newsymalloc

                                                * sizeof (asymbol *))));

                        }

                      newsyms[newsymcount] =

                        (asymbol *) xmalloc (sizeof (asymbol));

                      *newsyms[newsymcount] = *sym;

                      newsyms[newsymcount]->name = l->string;

                      ++newsymcount;

                    }

                }

            }

          if (! found_simple)

            {

              /* The unmodified symbol is actually not exported at

                 all.  */

              sym->flags &=~ (BSF_GLOBAL | BSF_EXPORT);

              sym->flags |= BSF_LOCAL;

            }

        }

      /* If it's an undefined symbol, see if it's on the import list.

         Change the prefix if necessary.  */

      if (bfd_is_und_section (bfd_get_section (sym)))

        {

          struct string_list *l;

          for (l = import_symbols; l != NULL; l = l->next)

            {

              if (strcmp (l->string, bfd_asymbol_name (sym)) == 0)

                break;

              else

                {

                  char *zbase;

                  zbase = strchr (l->string, '@');

                  if (zbase != NULL

                      && strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0)

                    {

                      sym->name = l->string;

                      break;

                    }

                }

            }

          if (l == NULL)

            non_fatal (_("warning: symbol %s imported but not in import list"),

                       bfd_asymbol_name (sym));

        }

      /* See if it's one of the special named symbols.  */

      if ((sym->flags & BSF_DEBUGGING) == 0)

        {

          bfd_vma val;

          /* FIXME: If these symbols are not in the .text section, we

             add the .text section size to the value.  This may not be

             correct for all targets.  I'm not sure how this should

             really be handled.  */

          if (strcmp (bfd_asymbol_name (sym), start_procedure) == 0)

            {

              val = bfd_asymbol_value (sym);

              if (bfd_get_section (sym) == data_sec

                  && text_sec != (asection *) NULL)

                val += bfd_section_size (outbfd, text_sec);

              if (! bfd_set_start_address (outbfd, val))

                bfd_fatal (_("set start address"));

              gotstart = TRUE;

            }

          if (strcmp (bfd_asymbol_name (sym), exit_procedure) == 0)

            {

              val = bfd_asymbol_value (sym);

              if (bfd_get_section (sym) == data_sec

                  && text_sec != (asection *) NULL)

                val += bfd_section_size (outbfd, text_sec);

              nlm_fixed_header (outbfd)->exitProcedureOffset = val;

              gotexit = TRUE;

            }

          if (check_procedure != NULL

              && strcmp (bfd_asymbol_name (sym), check_procedure) == 0)