path: root/misc/buildroot/toolchain/nxflat/ldnxflat.c

/***********************************************************************
 * toolchain/nxflat/ldnxflat.c
 * Convert ELF (or any BFD format) to NXFLAT binary format
 *
 * ldnxflat takes a fully resolvable elf binary which was linked with -r 
 * and resolves all references, then generates relocation table entries for
 * any relocation entries in data sections. This is designed to work with
 * the options -fpic -msingle-pic-base (and -mno-got or -membedded-pic, but
 * will and GOT relocations as well).
 *
 *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
 *   Author: Gregory Nutt <gnutt@nuttx.org>
 *
 *
 * Modified from ldelf2xflat (see http://xflat.org):
 *
 *   Copyright (c) 2002, 2006, Cadenux, LLC.  All rights reserved.
 *   Copyright (c) 2002, 2006, Gregory Nutt.  All rights reserved.
 *   Author: Gregory Nutt <gnutt@nuttx.org>
 *
 * Extended from the FLAT ldnxflat.c (original copyright below )
 *
 *   Copyright (C) 2000 NETsilicon, Inc.
 *   Copyright (C) 2000 WireSpeed Communications Corp
 *
 *   author : Joe deBlaquiere ( joe@wirespeed.com )
 *
 *   converted from elf2flt.c ( original copyright below )
 *
 *   elf2flt copyright :
 *
 *   (c) 1999, Greg Ungerer <gerg@moreton.com.au>
 *   (c) 1999, Phil Blundell, Nexus Electronics Ltd <pb@nexus.co.uk>
 *
 *   Hacked this about badly to fully support relocating binaries.
 *
 *   Originally obj-res.c
 *
 *   (c) 1998, Kenneth Albanowski <kjahds@kjahds.com>
 *   (c) 1998, D. Jeff Dionne
 *   (c) 1998, The Silver Hammer Group Ltd.
 *   (c) 1996, 1997 Dionne & Associates
 *   jeff@ryeham.ee.ryerson.ca
 *
 *   Relocation added March 1997, Kresten Krab Thorup 
 *   krab@california.daimi.aau.dk
 *
 * 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 2 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 ***********************************************************************/

/***********************************************************************
 * Included Files
 ***********************************************************************/

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdarg.h>
#include <errno.h>

#include <sys/types.h>
#include <netinet/in.h>

#include "bfd.h"
#include "arch/arch.h"
#include "nxflat.h"

/***********************************************************************
 * Compilation Switches
 ***********************************************************************/

/* #define RELOCS_IN_NETWORK_ORDER 1 */

#define LIBS_CAN_INCLUDE_LIBS 1

/* Debug output */

#if 0
#  define message(fmt, arg...) printf("%s: " fmt, __func__, ##arg)
#  define dbg(fmt, arg...)     if (verbose) printf("%s: " fmt, __func__, ##arg)
#  define vdbg(fmt, arg...)    if (verbose > 1) printf("%s: " fmt, __func__, ##arg)
#else
#  define message(fmt, arg...) printf(fmt, ##arg)
#  define dbg(fmt, arg...)     if (verbose) printf(fmt, ##arg)
#  define vdbg(fmt, arg...)     if (verbose > 1) printf(fmt, ##arg)
#endif
#define err(fmt, arg...)       fprintf(stderr, "ERROR -- " fmt, ##arg)
#define warn(fmt, arg...)      fprintf(stderr, "WARNING -- " fmt, ##arg)

/***********************************************************************
 * Definitions
 ***********************************************************************/

#ifndef PARAMS
#  define PARAMS(x)          x
#endif

#ifdef __CYGWIN32__
#  define O_PLATFORM         O_BINARY
#else
#  define O_PLATFORM         0
#endif

#define MAX_SECTIONS       16
#define DEFAULT_STACK_SIZE 4096

#define IS_GLOBAL(x)       ((((x)->flags)&(BSF_GLOBAL))!=0)

#define NXFLAT_HDR_SIZE     sizeof(struct nxflat_hdr_s)

/* The names of these fields have changed in later versions of binutils
 * (after 2.13 and before 2.15) and the meaning of _rawsize is has also
 * changed somewhat.  In the same timeframe, the name of the section
 * structure changed.
 */

#if 0
#  define COOKED_SIZE _cooked_size
#  define RAW_SIZE    _raw_size
#  define bfd_section sec
#else
#  define COOKED_SIZE size
#  define RAW_SIZE    rawsize
#endif

#define NXFLAT_RELOC_TARGET_TEXT    0
#define NXFLAT_RELOC_TARGET_DATA    1
#define NXFLAT_RELOC_TARGET_RODATA  2
#define NXFLAT_RELOC_TARGET_BSS     3
#define NXFLAT_RELOC_TARGET_UNKNOWN 4

/***********************************************************************
 * Private Types
 ***********************************************************************/

/* Needs to match definition in include/elf/internal.h.  This is from binutils-2.19.1 */

struct elf_internal_sym
{
  bfd_vma       st_value;            /* Value of the symbol */
  bfd_vma       st_size;             /* Associated symbol size */
  unsigned long st_name;             /* Symbol name, index in string tbl */
  unsigned char st_info;             /* Type and binding attributes */
  unsigned char st_other;            /* Visibilty, and target specific */
  unsigned int  st_shndx;            /* Associated section index */
};

typedef struct
{
  /* The BFD symbol. */

  asymbol symbol;

  /* ELF symbol information.  */

  struct elf_internal_sym internal_elf_sym;

  /* Backend specific information.  */

  union
    {
      unsigned int hppa_arg_reloc;
      void *mips_extr;
      void *any;
    }
  tc_data;

  /* Version information.  This is from an Elf_Internal_Versym structure in a 
   * SHT_GNU_versym section.  It is zero if there is no version information. */

  u_int16_t version;

} elf_symbol_type;

typedef struct _segment_info
{
  const char *name;
  bfd_vma low_mark;
  bfd_vma high_mark;
  size_t size;
  void *contents;
  asection *subsect[MAX_SECTIONS];
  int nsubsects;
} segment_info;

typedef void (*func_type) (asymbol * sym, void *arg1, void *arg2, void *arg3);

/* This structure defines the got entry for one symbol */

struct nxflat_got_s
{
  asymbol   *sym;                /* Symbol */
  u_int32_t  offset;             /* GOT offset for this symbol */
};

/***********************************************************************
 * Private Variable Data
 ***********************************************************************/

static int verbose = 0;
static int dsyms = 0;
static int stack_size = 0;
static int nerrors = 0;

static int32_t counter = 0;

static const char *program_name = NULL;
static const char *bfd_filename = NULL;
static const char *entry_name = NULL;
static char *out_filename = NULL;

static segment_info text_info;
static segment_info data_info;
static segment_info bss_info;

static asymbol **symbol_table = NULL;
static int32_t number_of_symbols = 0;

static asymbol *entry_symbol = NULL;
static asymbol *dynimport_begin_symbol = NULL;
static asymbol *dynimport_end_symbol = NULL;

struct nxflat_reloc_s *nxflat_relocs;
static int nxflat_nrelocs;

static struct nxflat_got_s *got_offsets; /* realloc'ed array of GOT entry descriptions */
static u_int32_t got_size;                /* The size of the GOT to be allocated */
int    ngot_offsets;                      /* Number of GOT offsets in got_offsets[] */

/***********************************************************************
 * Private Constant Data
 ***********************************************************************/

static const char default_exe_entry_name[] = "_start";
static const char dynimport_begin_name[] = "__dynimport_begin";
static const char dynimport_end_name[] = "__dynimport_end";

/***********************************************************************
 * Private Functions
 ***********************************************************************/

/***********************************************************************
 * nxflat_swap32
 ***********************************************************************/

#ifdef ARCH_BIG_ENDIAN
static inline u_int32_t nxflat_swap32(u_int32_t little)
{
  u_int32_t big =
    ((little >> 24) & 0xff) |
    (((little >> 16) & 0xff) << 8) |
    (((little >> 8) & 0xff) << 16) | ((little & 0xff) << 24);
  return big;
}
#endif

/***********************************************************************
 * get_xflat32
 ***********************************************************************/

static inline u_int32_t get_xflat32(u_int32_t * addr32)
{
  return ntohl(*addr32);
}

/***********************************************************************
 * put_xflat32
 ***********************************************************************/

static void inline put_xflat32(u_int32_t * addr32, u_int32_t val32)
{
  *addr32 = htonl(val32);
}

/***********************************************************************
 * put_xflat16
 ***********************************************************************/

static void inline put_xflat16(u_int16_t * addr16, u_int16_t val16)
{
#if 1
  *addr16 = htons(val16);
#else
  u_int32_t *addr32 = (u_int32_t *) (((u_int32_t) addr16) & ~3);
  u_int32_t ndx = ((((u_int32_t) addr16) >> 1) & 1);

  union
    {
      u_int16_t hw[2];
      u_int32_t w;
    } uword;

  /* Fetch the 32 bit value */

  uword.w = get_xflat32(addr32);

  /* Add in the 16 bit value */

  uword.hw[ndx] = val16;

  /* Then save the 32-bit value */

  put_xflat32(addr32, uword.w);
#endif
}

/***********************************************************************
 * nxflat_write
 ***********************************************************************/

static void nxflat_write(int fd, const char *buffer, int buflen)
{
  vdbg("Writing fd: %d buffer: %p buflen: %d\n", fd, buffer, buflen);

  /* Dump the entire buffer if very strong debug is selected */

  if (verbose > 2)
    {
      static int offset = 0;
      const unsigned char *ptr = (const unsigned char *)buffer;
      int i;
      int j;

      for (i = 0; i < buflen; i += 32)
        {
          printf("%08x:", offset + i);
          for (j = 0; j < 32 && (i + j) < buflen; j++)
            {
              printf(" %02x", *ptr++);
            }
          printf("\n");
        }
      offset += buflen;
    }

  /* Write the data to file, handling errors and interruptions */

  do
    {
      ssize_t nwritten = write(fd, buffer, buflen);
      if (nwritten < 0)
        {
           if (errno != EINTR)
             {
               err("Write to output file failed: %s\n", strerror(errno));
               exit(1);
             }
        }
      else
        {
           buffer += nwritten;
           buflen -= nwritten;
        }
    }
  while (buflen > 0);
}

/***********************************************************************
 * get_symbols
 ***********************************************************************/

static asymbol **get_symbols(bfd *abfd, int32_t *num)
{
  int32_t storage_needed;

  if (dsyms)
    {
      storage_needed = bfd_get_dynamic_symtab_upper_bound(abfd);
    }
  else
    {
      storage_needed = bfd_get_symtab_upper_bound(abfd);
    }

  if (storage_needed < 0)
    {
      abort();
    }

  if (storage_needed == 0)
    {
      return NULL;
    }

  symbol_table = (asymbol**)malloc(storage_needed);

  if (dsyms)
    {
      number_of_symbols = bfd_canonicalize_dynamic_symtab(abfd, symbol_table);
    }
  else
    {
      number_of_symbols = bfd_canonicalize_symtab(abfd, symbol_table);
    }

  if (number_of_symbols < 0)
    {
      abort();
    }

  *num = number_of_symbols;

  vdbg("Read %ld symbols\n", (long)number_of_symbols);
  return symbol_table;
}

/***********************************************************************
 * traverse_global_symbols
 ***********************************************************************/

static void
traverse_global_symbols(void *arg1, void *arg2, void *arg3, func_type fn)
{
  int i;
  for (i = 0; i < number_of_symbols; i++)
    {
      /* Check if it is a global function symbol defined in this */

      if (IS_GLOBAL(symbol_table[i]))
        {
          /* Yes, process the symbol */

          fn(symbol_table[i], arg1, arg2, arg3);
        }
    }
}

/***********************************************************************
 * check_special_symbol
 ***********************************************************************/

static void check_special_symbol(asymbol * sym,
                                 void *arg1, void *arg2, void *arg3)
{
  if ((entry_name) && (strcmp(entry_name, sym->name) == 0))
    {
      entry_symbol = sym;
    }
  else if (strcmp(dynimport_begin_name, sym->name) == 0)
    {
      dynimport_begin_symbol = sym;
    }
  else if (strcmp(dynimport_end_name, sym->name) == 0)
    {
      dynimport_end_symbol = sym;
    }
  counter++;
}

/***********************************************************************
 * find_special_symbols
 ***********************************************************************/

static void inline find_special_symbols(void)
{
  counter = 0;
  traverse_global_symbols(NULL, NULL, NULL, check_special_symbol);

  if (entry_symbol == NULL)
    {
      err("Executable entry point \"%s\" not found\n", entry_name);
      exit(1);
    }

  if (dynimport_begin_symbol == NULL)
    {
      warn("Special symbol \"%s\" not found\n", dynimport_begin_name);
      dynimport_end_symbol = NULL;
    }
  else if (dynimport_end_symbol == NULL)
    {
      err("Symbol \"%s\" found, but missing \"%s\"\n",
          dynimport_begin_name, dynimport_end_name);
      exit(1);
    }
}

/***********************************************************************
 * put_special_symbol
 ***********************************************************************/

static void
put_special_symbol(asymbol *begin_sym, asymbol *end_sym,
                   u_int32_t *addr, u_int16_t *count,
                   u_int32_t elem_size, u_int32_t offset)
{
  u_int32_t file_offset = 0;
  u_int32_t elems = 0;

  u_int32_t begin_sym_value;
  u_int32_t begin_sect_vma;

  /* We'll assume its okay if this symbol was not found. */

  if (begin_sym != NULL)
    {
      vdbg("begin: '%s' end: '%s' offset: %08lx\n",
            begin_sym->name, end_sym->name, (long)(NXFLAT_HDR_SIZE+offset));

      /* Get the value of the beginning symbol and the section that it is
       * defined in. */

      begin_sym_value = begin_sym->value;
      if (begin_sym->section == NULL)
        {
          err("No section for symbol \"%s\"\n", begin_sym->name);
          exit(1);
        }
      else
        {
          /* Get the file offset to the beginning symbol */

          begin_sect_vma = begin_sym->section->vma;

          file_offset = NXFLAT_HDR_SIZE +       /* Size of the NXFLAT header */
            begin_sect_vma +    /* Virtual address of section */
            begin_sym_value +   /* Value of the symbol */
            offset;             /* Additional file offset */

          /* If there is a begin symbol, then there MUST be a corresponding
           * ending symbol.  We must have this to get the size of the data
           * structure.  This size will be used to determined the number of
           * elements in the array. */

          if (end_sym == NULL)
            {
              /* No matching end symbol */

              err("ERROR: Begin sym \"%s\" found, no corresponding end\n",
                  begin_sym->name);
              exit(1);
            }
          else if (end_sym->section == NULL)
            {
              /* No section associated with the end symbol */

              err("No section for symbol \"%s\"\n", end_sym->name);
              exit(1);
            }
          else if (end_sym->section != begin_sym->section)
            {
              /* Section associated with the end symbol is not the same as the
               * section associated with the begin symbol. */

              err("Begin sym \"%s\" is defined in section \"%s\"\n",
                  begin_sym->name, begin_sym->section->name);
              err("  but sym \"%s\" is defined in section \"%s\"\n",
                  end_sym->name, end_sym->section->name);
              exit(1);
            }
          else if (end_sym->value < begin_sym_value)
            {
              /* End symbol is before the begin symbol? */

              err("Begin sym \"%s\" lies at offset %d in section \"%s\"\n",
                  begin_sym->name, begin_sym_value, begin_sym->section->name);
              err("  but sym \"%s\" is before that at offset: %ld\n",
                  end_sym->name, (long)end_sym->value);
              exit(1);
            }
          else
            {
              /* Get the size of the structure in bytes */

              u_int32_t array_size = end_sym->value - begin_sym_value;

              /* Get the number of elements in the structure. */

              elems = array_size / elem_size;

              /* Verify that there are an even number of elements in the array. */

              if (elems * elem_size != array_size)
                {
                  err("Array size (%d) is not a multiple of the element size (%d)\n",
                      array_size, elem_size);
                  exit(1);
                }
            }
        }

      dbg("Symbol %s: value: %08x section offset: %08x file offset: %08x count: %d\n",
          begin_sym->name, begin_sym_value, begin_sect_vma, file_offset, elems);
    }

  put_xflat32(addr, file_offset);
  put_xflat16(count, elems);
}

/***********************************************************************
 * put_entry_point
 ***********************************************************************/

static void put_entry_point(struct nxflat_hdr_s *hdr)
{
  u_int32_t entry_point = 0;

  if (entry_symbol)
    {
      struct bfd_section *sect;

      /* Does this symbol lie in the text section? */

      sect = entry_symbol->section;
      if (sect == NULL)
        {
          err("No section for entry symbol \"%s\"\n", entry_symbol->name);
          exit(1);
        }

      /* Get the file offset to the entry point symbol */

      entry_point = NXFLAT_HDR_SIZE + sect->vma + entry_symbol->value;

      printf("Entry symbol \"%s\": %08x in section \"%s\"\n",
             entry_symbol->name, entry_point, sect->name);

      dbg("  HDR: %08lx + Section VMA: %08lx + Symbol Value: %08lx\n",
          (long)NXFLAT_HDR_SIZE, (long)sect->vma, (long)entry_symbol->value);
    }

  /* Does the entry point lie within the text region? */

  if ((entry_point < NXFLAT_HDR_SIZE) ||
      (entry_point >= NXFLAT_HDR_SIZE + text_info.size))
    {

      /* No... One special case: A shared library may not need an
       * initialization entry point. */

      if (entry_point == 0)
        {
          /* Complain a little in this case... The used might have intended to
           * specify one. */

          warn("Library has no initialization entry point\n");
        }
      else
        {
          /* Otherwise, complain a lot.  We either have a program with no
           * entry_point or a bogus entry_point. */

          err("Invalid entry point: %08x\n", entry_point);
          err("  Valid TEXT range: %08lx - %08lx\n",
              (long)NXFLAT_HDR_SIZE, (long)(NXFLAT_HDR_SIZE + text_info.size));
          exit(1);
        }
    }

  /* Put the entry point into the NXFLAT header. */

  put_xflat32(&hdr->h_entry, entry_point);
}

/***********************************************************************
 * get_reloc_type
 ***********************************************************************/

static int get_reloc_type(asection *sym_section, segment_info **sym_segment)
{
  int i;

  /* Locate the address referred to by section type.  In the context in which
   * this runs, we can no longer use the flags field (it is zero for some
   * reason).  But we can search for matches with the buffered section
   * pointers. */

  /* Check if the symbol is defined in a BSS section */

  for (i = 0; i < bss_info.nsubsects; i++)
    {
      if (bss_info.subsect[i] == sym_section)
        {
          /* Yes... */

          vdbg("Sym section %s is BSS\n", sym_section->name);
 
          if (sym_segment)
            {
              *sym_segment = &bss_info;
            }
          return NXFLAT_RELOC_TARGET_BSS;
        }
    }

  /* Check if the symbol is defined in a TEXT section */

  for (i = 0; i < text_info.nsubsects; i++)
    {
      if (text_info.subsect[i] == sym_section)
        {
          /* Yes... */

          vdbg("Sym section %s is CODE\n", sym_section->name);

          if (sym_segment)
            {
              *sym_segment = &text_info;
            }
          return NXFLAT_RELOC_TARGET_TEXT;
        }
    }

  /* Check if the symbol is defined in a DATA section */

  for (i = 0; i < data_info.nsubsects; i++)
    {
      if (data_info.subsect[i] == sym_section)
        {
          /* Yes... */

          vdbg("Sym section %s is DATA\n", sym_section->name);

          if (sym_segment)
            {
              *sym_segment = &data_info;
            }
          return NXFLAT_RELOC_TARGET_DATA;
        }
    }

  err("Could not find region for sym_section \"%s\" (%p)\n",
      sym_section->name, sym_section);

  return NXFLAT_RELOC_TARGET_UNKNOWN;
}

/***********************************************************************
 * find_got_entry
 ***********************************************************************/

/* Find the GOT entry for a particular symbol index */

static struct nxflat_got_s *find_got_entry(asymbol *sym)
{
  int i;
  for (i = 0; i < ngot_offsets; i++)
    {
      if (got_offsets[i].sym == sym)
        {
           return &got_offsets[i];
        }
    }
  return NULL;
}

/***********************************************************************
 * alloc_got_entry
 ***********************************************************************/

/* Allocate a new got entry */

static void alloc_got_entry(asymbol *sym)
{
  struct nxflat_got_s *newgot;
  int noffsets;

  /* First, make sure that we don't already have an entry for this symbol */

  if (find_got_entry(sym) == 0)
    {
      /* Realloc the array of GOT offsets to hold one more */

      noffsets = ngot_offsets + 1;
      newgot = (struct nxflat_got_s *)realloc(got_offsets, sizeof(struct nxflat_got_s) * noffsets);
      if (!newgot)
        {
           err("Failed to extend the GOT offset table. noffsets: %d\n", noffsets);
        }
      else
        {
          /* Add the new symbol offset to the end of the reallocated table */

          newgot[ngot_offsets].sym    = sym;
          newgot[ngot_offsets].offset = got_size;

          /* Update counts and sizes */

          got_offsets   = newgot;
          ngot_offsets  = noffsets;
          got_size      = sizeof(u_int32_t) * noffsets;
        }
    }
}

/***********************************************************************
 * relocate_rel32
 ***********************************************************************/

static void
relocate_rel32(arelent *relp, int32_t *target, symvalue sym_value)
{
  reloc_howto_type      *how_to      = relp->howto;
  asymbol               *rel_sym     = *relp->sym_ptr_ptr;
  asection              *rel_section = rel_sym->section;
  int32_t                value;
  int32_t                temp;
  int32_t                saved;

  if (verbose > 1)
    {
      vdbg("  Original location %p is %08lx ",
#ifdef ARCH_BIG_ENDIAN
           target, (long)nxflat_swap32(*target));
#else
          target, (long)*target);
#endif
      if (verbose > 2)
        {
          printf("rsh %d ", how_to->rightshift);
          printf(" sz %d ", how_to->size);
          printf("bit %d ", how_to->bitsize);
          printf("rel %d ", how_to->pc_relative);
          printf("smask %08lx ", (long)how_to->src_mask);
          printf("dmask %08lx ", (long)how_to->dst_mask);
          printf("off %d ", how_to->pcrel_offset);
        }

      printf("\n");
    }

#ifdef ARCH_BIG_ENDIAN
  saved = temp = (int32_t) nxflat_swap32(*target);
#else
  saved = temp = *target;
#endif
  /* Mask  and sign extend */

  temp &= how_to->src_mask;
  temp <<= (32 - how_to->bitsize);
  temp >>= (32 - how_to->bitsize);

  /* Calculate the new value:  Current value + VMA - current PC */

  value = temp + sym_value + rel_section->vma - relp->address;

  /* Offset */

  temp += (value >> how_to->rightshift);

  /* Mask upper bits from rollover */

  temp &= how_to->dst_mask;

  /* Replace data that was masked */

  temp |= saved & (~how_to->dst_mask);

  vdbg("  Modified location: %08lx\n", (long)temp);
#ifdef ARCH_BIG_ENDIAN
  *target = (long)nxflat_swap32(temp);
#else
  *target = (long)temp;
#endif
 }

/***********************************************************************
 * relocate_abs32
 ***********************************************************************/

static void
relocate_abs32(arelent *relp, int32_t *target, symvalue sym_value)
{
  reloc_howto_type      *how_to      = relp->howto;
  asymbol               *rel_sym     = *relp->sym_ptr_ptr;
  asection              *rel_section = rel_sym->section;
  struct nxflat_reloc_s *relocs;
  int32_t                temp;
  int32_t                saved;
  int                    reloc_type;

  /* ABS32 links from .text are easy - since the fetches will
   * always be base relative. the ABS32 refs from data will be
   * handled the same
   */

  if (verbose > 1)
    {
      vdbg("  Original location %p is %08lx ",
#ifdef ARCH_BIG_ENDIAN
           target, (long)nxflat_swap32(*target));
#else
          target, (long)*target);
#endif
      if (verbose > 2)
        {
          printf("rsh %d ", how_to->rightshift);
          printf(" sz %d ", how_to->size);
          printf("bit %d ", how_to->bitsize);
          printf("rel %d ", how_to->pc_relative);
          printf("smask %08lx ", (long)how_to->src_mask);
          printf("dmask %08lx ", (long)how_to->dst_mask);
          printf("off %d ", how_to->pcrel_offset);
        }

      printf("\n");
    }

#ifdef ARCH_BIG_ENDIAN
  saved = temp = (int32_t) nxflat_swap32(*target);
#else
  saved = temp = *target;
#endif
  /* Mask  and sign extend */

  temp &= how_to->src_mask;
  temp <<= (32 - how_to->bitsize);
  temp >>= (32 - how_to->bitsize);

  /* Offset */

  temp += (sym_value + rel_section->vma) >> how_to->rightshift;

  /* Mask upper bits from rollover */

  temp &= how_to->dst_mask;

  /* Replace data that was masked */

  temp |= saved & (~how_to->dst_mask);

  vdbg("  Modified location: %08lx\n", (long)temp);
#ifdef ARCH_BIG_ENDIAN
  *target = (long)nxflat_swap32(temp);
#else
  *target = (long)temp;
#endif
  /* Determine where the symbol lies */

  switch (get_reloc_type(rel_section, NULL))
    {
      case NXFLAT_RELOC_TARGET_UNKNOWN:
      default:
        {
          err("Symbol relocation section type is unknown\n");
          nerrors++;
        }
        /* Fall through and do something wrong */

      case NXFLAT_RELOC_TARGET_BSS:
      case NXFLAT_RELOC_TARGET_DATA:
        {
          vdbg("Symbol '%s' lies in D-Space\n", rel_sym->name);
          reloc_type = NXFLAT_RELOC_TYPE_REL32D;
        }
        break;

      case NXFLAT_RELOC_TARGET_TEXT:
        {
          vdbg("Symbol '%s' lies in I-Space\n", rel_sym->name);
          reloc_type = NXFLAT_RELOC_TYPE_REL32I;
        }
        break;
    }

  /* Re-allocate memory to include this relocation */

  relocs = (struct nxflat_reloc_s*)
  realloc(nxflat_relocs, sizeof(struct nxflat_reloc_s) * (nxflat_nrelocs + 1));
  if (!relocs)
    {
      err("Failed to re-allocate memory ABS32 relocations (%d relocations)\n",
          nxflat_nrelocs);
      nerrors++;
    }
  else
    {
      /* Reallocation was successful.  Update globals */
               
      nxflat_nrelocs++;
      nxflat_relocs = relocs;

      /* Then add the relocation at the end of the table */

      nxflat_relocs[nxflat_nrelocs-1].r_info =
      NXFLAT_RELOC(reloc_type, relp->address + got_size);
 
      vdbg("relocs[%d]: type: %d offset: %08x\n",
      nxflat_nrelocs-1,
      NXFLAT_RELOC_TYPE(nxflat_relocs[nxflat_nrelocs-1].r_info),
      NXFLAT_RELOC_OFFSET(nxflat_relocs[nxflat_nrelocs-1].r_info));
    }
 }

/***********************************************************************
 * resolve_segment_relocs
 ***********************************************************************/

static void
resolve_segment_relocs(bfd *input_bfd, segment_info *inf, asymbol **syms)
{
  arelent **relpp;
  int relsize;
  int relcount;
  int i;
  int j;

  for (i = 0; i < inf->nsubsects; i++)
    {
      relcount = inf->subsect[i]->reloc_count;
      vdbg("Section %s has %08x relocs\n", inf->subsect[i]->name, relcount);

      if (0 >= relcount)
        {
          continue;
        }

      relsize = bfd_get_reloc_upper_bound(input_bfd, inf->subsect[i]);
      vdbg("Section %s reloc size: %08x\n", inf->subsect[i]->name, relsize);

      if (0 >= relsize)
        {
          continue;
        }

      relpp = (arelent**)malloc((size_t) relsize);
      relcount = bfd_canonicalize_reloc(input_bfd, inf->subsect[i], relpp, syms);

      if (relcount < 0)
        {
          err("bfd_canonicalize_reloc failed!\n");
          exit(1);
        }

      vdbg("Section %s can'd %08x relocs\n", inf->subsect[i]->name, relcount);

      for (j = 0; j < relcount; j++)
        {
          /* Get information about this symbol */

          reloc_howto_type *how_to      = relpp[j]->howto;
          asymbol          *rel_sym     = *relpp[j]->sym_ptr_ptr;
          asection         *rel_section = rel_sym->section;
          int32_t          *target      = (int32_t*)(inf->contents + relpp[j]->address);
          symvalue          sym_value;

          /* If the symbol is a thumb function, then set bit 1 of the value */

          sym_value = rel_sym->value;
#ifdef NXFLAT_THUMB2
          if ((((elf_symbol_type *)rel_sym)->internal_elf_sym.st_info & 0x0f) == STT_ARM_TFUNC)
            {
               sym_value |= 1;
            }
          else
#endif

          /* If the symbol lies in D-Space, then we need to add the size of the GOT
           * table to the symbol value
           */

          if ((rel_section->flags & SEC_CODE) == 0 && (rel_section->flags & SEC_ALLOC) != 0)
            {
              sym_value += got_size;
            }

          dbg("rel %-3d: sym [%20s] s_addr @ %08lx val %08lx-%08lx rel %08lx how %s\n",
               j, rel_sym->name, (long)relpp[j]->address, (long)rel_sym->value,
               (long)sym_value, (long)relpp[j]->addend, how_to->name);

          switch (how_to->type)
            {
            case R_ARM_PLT32:
            case R_ARM_PC24:
              {
                int32_t temp;
                int32_t saved;

                dbg("performing PC24 link at addr %08lx [%08lx] to sym '%s' [%08lx]\n",
                    (long)relpp[j]->address, (long)*target, rel_sym->name, (long)sym_value);

                /* Can't fix what we ain't got */

                if ((SEC_IN_MEMORY & rel_section->flags) == 0)
                  {
                    err("Section %s not loaded into mem!\n", rel_section->name);
                    exit(1);
                  }

                /* PC24 -> can only fix text to text refs */

                if ((SEC_CODE & rel_section->flags) == 0)
                  {
                    err("Section %s not code!\n", rel_section->name);
                    exit(1);
                  }

                if ((SEC_CODE & inf->subsect[i]->flags) == 0)
                  {
                    err("Section %s not code!\n", rel_section->name);
                    exit(1);
                  }

                if (verbose > 1)
                  {
                    vdbg(" Original opcode @ %p is %08lx ",
#ifdef ARCH_BIG_ENDIAN
                         target, (long)nxflat_swap32(*target));
#else
                         target, (long)*target);
#endif
                    if (verbose > 2)
                      {
                        printf("rsh %d ", how_to->rightshift);
                        printf(" sz %d ", how_to->size);
                        printf("bit %d ", how_to->bitsize);
                        printf("rel %d ", how_to->pc_relative);
                        printf("smask %08lx ", (long)how_to->src_mask);
                        printf("dmask %08lx ", (long)how_to->dst_mask);
                        printf("off %d ", how_to->pcrel_offset);
                      }
                    printf("\n");
                  }

                if (how_to->pcrel_offset)
                  {
#ifdef ARCH_BIG_ENDIAN
                    saved = temp = (int32_t)nxflat_swap32(*target);
#else
                    saved = temp = *target;
#endif
                    /* mask */
                    temp &= how_to->src_mask;

                    /* sign extend */
                    temp <<= (32 - how_to->bitsize);
                    temp >>= (32 - how_to->bitsize);

                    /* offset */
                    temp +=
                      ((sym_value + rel_section->vma)
                       - relpp[j]->address) >> how_to->rightshift;

                    /* demote */
                    /* temp >>= how_to->rightshift; */

                    /* mask upper bits from rollover */
                    temp &= how_to->dst_mask;

                    /* replace data that was masked */
                    temp |= saved & (~how_to->dst_mask);
                  }
                else
                  {
                    err("Do not know how pcrel_offset\n");
                    exit(1);
                  }

                vdbg("  Modified opcode: %08lx\n", (long)temp);
#ifdef ARCH_BIG_ENDIAN
                *target = (long)nxflat_swap32(temp);
#else
                *target = (long)temp;
#endif
              }
              break;

            case R_ARM_ABS32:
              {
                dbg("Performing ABS32 link at addr %08lx [%08lx] to sym '%s' [%08lx]\n",
                     (long)relpp[j]->address, (long)*target, rel_sym->name, (long)sym_value);

                relocate_abs32(relpp[j], target, sym_value);
              }
              break;

            case R_ARM_REL32:
              {
                dbg("Performing REL32 link at addr %08lx [%08lx] to sym '%s' [%08lx]\n",
                     (long)relpp[j]->address, (long)*target, rel_sym->name, (long)sym_value);

                /* The only valid REL32 relocation would be to relocate a reference from
                 * I-Space to another symbol in I-Space.  That should be handled by the
                 * partially linking logic so we don't expect to see any R_ARM_REL32
                 * relocations here.
                 */

                switch (get_reloc_type(rel_section, NULL))
                  {
                    case NXFLAT_RELOC_TARGET_UNKNOWN:
                    default:
                      {
                        err("Symbol relocation section type is unknown\n");
                        nerrors++;
                      }
                      break;

                    case NXFLAT_RELOC_TARGET_BSS:
                    case NXFLAT_RELOC_TARGET_DATA:
                      {
                        err("Cannot perform REL32 relocation: Symbol '%s' lies in D-Space\n",
                            rel_sym->name);
                        nerrors++;
                      }
                      break;

                    case NXFLAT_RELOC_TARGET_TEXT:
                      {
                        vdbg("Symbol '%s' lies in I-Space\n", rel_sym->name);
                        relocate_rel32(relpp[j], target, sym_value - relpp[j]->address);
                      }
                      break;
                  }
              }
              break;

#ifdef NXFLAT_THUMB2
            case R_ARM_THM_XPC22:
            case R_ARM_THM_CALL:
            case R_ARM_THM_JUMP24:
              /* Thumb BL (branch long instruction).  */
              {
                u_int16_t *pinsn     = (u_int16_t*)target;
                u_int16_t upper_insn = pinsn[0];
                u_int16_t lower_insn = pinsn[1];

                /* Fetch the addend.  We use the Thumb-2 encoding (backwards
                 * compatible with Thumb-1) involving the J1 and J2 bits
                 */

                int32_t s     = (upper_insn & (1 << 10)) >> 10;
                int32_t upper = upper_insn & 0x3ff;
                int32_t lower = lower_insn & 0x7ff;
                int32_t j1    = (lower_insn & (1 << 13)) >> 13;
                int32_t j2    = (lower_insn & (1 << 11)) >> 11;
                int32_t i1    = j1 ^ s ? 0 : 1;
                int32_t i2    = j2 ^ s ? 0 : 1;
                int32_t temp;
                int32_t signbit;

                temp = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1);

                /* Sign extend */

                temp = (temp | ((s ? 0 : 1) << 24)) - (1 << 24);

                dbg("Performing THM link at addr %08lx [%04x %04x] to sym '%s' [%08lx]\n",
                    (long)relpp[j]->address, upper_insn, lower_insn,
                    rel_sym->name, (long)sym_value);
                vdbg("  Original INSN: %04x %04x temp: %08lx\n",
                    upper_insn, lower_insn, (long)temp);

                /* Add the branch offset (really needs a range check) */

                temp += (sym_value + rel_section->vma - relpp[j]->address);

                if ((lower_insn & 0x5000) == 0x4000)
                  {
                    /* For a BLX instruction, make sure that the relocation is rounded up
                     * to a word boundary.  This follows the semantics of the instruction
                     * which specifies that bit 1 of the target address will come from bit
                     * 1 of the base address.
                     */

                    temp = (temp + 2) & ~ 3;
                  }

                /* Put RELOCATION back into the insn.  Assumes two's complement.
                 * We use the Thumb-2 encoding, which is safe even if dealing with
                 * a Thumb-1 instruction by virtue of our overflow check above.
                 */

                signbit = (temp < 0) ? 1 : 0;
                upper_insn = (upper_insn & ~0x7ff) | ((temp >> 12) & 0x3ff) | (signbit << 10);
                lower_insn = (lower_insn & ~0x2fff)
                           | (((!((temp >> 23) & 1)) ^ signbit) << 13)
                           | (((!((temp >> 22) & 1)) ^ signbit) << 11)
                           | ((temp >> 1) & 0x7ff);

                vdbg("  Modified INSN: %04x %04x temp: %08lx Sec VMA: %08lx\n",
                    upper_insn, lower_insn, (long)temp, (long)rel_section->vma);

                /* Put the relocated value back in the object file:  */

                pinsn[0] = upper_insn;
                pinsn[1] = lower_insn;
              }
              break;
#endif

            case R_ARM_GOTOFF:
              {
                int reltype;

                /* Relocation is relative to the start of the global offset
                 * table.  This is used for things link known offsets to
                 * constant strings in D-Space.  I think we can just ignore
                 * this relocation. The usual assembly language sequence
                 * is like:
                 * 
                 *      ldr  r0, .L9       <- r0 holds GOT-relative offset to 'n'
                 *      add  r0, sl, r0    <- Adding SL produces address of 'n'
                 *      ...
                 * .L9:
                 *     .word  n(GOTOFF)
                 */

                dbg("Perfoming GOTOFF reloc at addr %08lx [%08lx] to sym '%s' [%08lx]\n",
                    (long)relpp[j]->address, (long)*target, rel_sym->name, (long)sym_value);

                /* For this location, we need to set the value to the value
                 * of the symbol in D-Space.  (There is obviously a problem if
                 * the symbol lies in I-Space because the offset is not relative
                 * to the PIC address which points to the GOT).
                 */

                /* Check if symbols lies in I- or D-Space */
 
                reltype = get_reloc_type(rel_section, NULL);
                if (reltype == NXFLAT_RELOC_TARGET_TEXT)
                  {
                    err("Symbol in GOT32 relocation is in TEXT\n");
                    err("  At addr %08lx to sym '%s' [%08lx]\n",
                        (long)relpp[j]->address, rel_sym->name, (long)sym_value);
                  }
                else
                  {
                    vdbg("  Original value: %08lx\n", (long)*target);
                    *target = sym_value;
                    vdbg("  Modified value: %08lx\n", (long)*target);
                 }
              }
              break;

            case R_ARM_GOT32:
            case R_ARM_GOT_PREL:
              {
                struct nxflat_got_s *got_entry;

                /* Relocation is to the entry for this symbol in the global
                 * offset table. This relocation type is used to set the 32-bit
                 * address of global variables.  The usual assembly language sequence
                 * is like:
                 * 
                 *      ldr  r3, .L4       <- r3 holds GOT-relative offset to address of 'n'
                 *      ldr  r1, [sl,r3]   <- r1 holds (relocated) address of 'n'
                 *      ...
                 * .L4:
                 *     .word  n(GOT)
                 */

                dbg("Performing GOT32 reloc at addr %08lx [%08lx] to sym '%s' [%08lx]\n",
                    (long)relpp[j]->address, (long)*target, rel_sym->name, (long)sym_value);

                /* There should be an entry for the relocation allocated in the GOT */

                got_entry = find_got_entry(rel_sym);
                if (!got_entry)
                  {
                     err("No GOT entry from for symobl '%s'\n", rel_sym->name);
                     nerrors++;
                  }
                else
                  {
                    /* The fixup is simply to provide the GOT offset as the relocation value */

                    vdbg("  Original value: %08lx\n", (long)*target);
                    *target = got_entry->offset;
                    vdbg("  Modified value: %08lx\n", (long)*target);
                  }
              }
              break;

            case R_ARM_GOTPC:
              {
                /* Use the global offset table as a symbol value */

                dbg("Performing GOTPC reloc at addr %08lx [%08lx] to sym '%s' [%08lx]\n",
                    (long)relpp[j]->address, (long)*target, rel_sym->name, (long)sym_value);
 
                /* Check if this is TEXT section relocation */
 
                if ((inf->subsect[i]->flags & SEC_CODE) != 0 &&
                         (inf->subsect[i]->flags & SEC_ALLOC) != 0)
                  {
                    /* The GOT always begins at offset 0 */

                    vdbg("  Original value: %08lx\n", (long)*target);
                    *target = 0;
                    vdbg("  Modified value: %08lx\n", (long)*target);
                  }
                else
                  {
                    err("Attempted GOTPC relocation in outside of I-Space section\n");
                    err("  At addr %08lx [%08lx] to sym '%s' [%08lx]\n",
                        (long)relpp[j]->address, (long)*target,
                        rel_sym->name, (long)sym_value);
                    nerrors++;
                  }
              }
              break;

            default:
              err("Do not know how to handle reloc %d type %s @ %p!\n",
                  how_to->type, how_to->name, how_to);
              nerrors++;
              break;
            }
        }

      /* Mark the section as having no relocs */

      inf->subsect[i]->flags &= !(SEC_RELOC);
      inf->subsect[i]->reloc_count = 0;
      free(relpp);
    }
}

/***********************************************************************
 * allocate_segment_got
 ***********************************************************************/

/* The GOT lies at the beginning of D-Space.  Before we can process
 * any relocation data, we need to determine the size of the GOT.
 */

static void allocate_segment_got(bfd *input_bfd, segment_info *inf, asymbol **syms)
{
   arelent **relpp;
  int relsize;
  int relcount;
  int i;
  int j;

  for (i = 0; i < inf->nsubsects; i++)
    {
      relcount = inf->subsect[i]->reloc_count;
      vdbg("Section %s has %08x relocs\n", inf->subsect[i]->name, relcount);

      if (0 >= relcount)
        {
          continue;
        }

      relsize = bfd_get_reloc_upper_bound(input_bfd, inf->subsect[i]);
      vdbg("Section %s reloc size: %08x\n", inf->subsect[i]->name, relsize);

      if (0 >= relsize)
        {
          continue;
        }

      relpp    = (arelent**)malloc((size_t) relsize);
      relcount = bfd_canonicalize_reloc(input_bfd, inf->subsect[i], relpp, syms);

      if (relcount < 0)
        {
          err("bfd_canonicalize_reloc failed!\n");
          exit(1);
        }

      vdbg("Section %s can'd %08x relocs\n", inf->subsect[i]->name, relcount);

      for (j = 0; j < relcount; j++)
        {
          /* Get information about this symbol */

          reloc_howto_type *how_to  = relpp[j]->howto;
          asymbol          *rel_sym = *relpp[j]->sym_ptr_ptr;

          dbg("rel %-3d: sym [%20s] s_addr @ %08lx rel %08lx how %s\n",
               j, rel_sym->name, (long)relpp[j]->address,
               (long)relpp[j]->addend, how_to->name);

          switch (how_to->type)
            {
              case R_ARM_GOT32:
              case R_ARM_GOT_PREL:
                /* This symbol requires a global offset table entry.  */
                {
                  alloc_got_entry(rel_sym);

                  dbg("  Created GOT entry %d for sym %p (offset %d)\n",
                      ngot_offsets-1, got_offsets[ngot_offsets-1].sym, got_offsets[ngot_offsets-1].offset);
                }
                break;

              case R_ARM_GOTOFF32:
              case R_ARM_GOTPC:
                /* These are relative to the GOT, but do not require GOT entries */
                break;

              default:
                break;
            }
        }
      free(relpp);
    }
}

/***********************************************************************
 * dump_symbol
 ***********************************************************************/

static void dump_symbol(asymbol * psym)
{
  struct elf_internal_sym *isym =
    (struct elf_internal_sym *)&((elf_symbol_type *)psym)->internal_elf_sym;

  if (bfd_is_com_section(psym->section))
    {
      /* Common Global - unplaced */

      printf("Sym[%24s] @            sz %04lx ",
             psym->name, (long)psym->value);
      printf("align %04x ", (u_int32_t)isym->st_value);
    }
  else
    {
      printf("Sym[%24s] @ %04lx align            ",
             psym->name, (long)psym->value);
      printf("sz %04x ", (u_int32_t)isym->st_size);
    }

  /* Symbol type */

  printf("tp %02x ", isym->st_info);

  /* Tag thumb specific attributes */

#ifdef NXFLAT_THUMB2
  if ((isym->st_info & 0x0f) == STT_ARM_TFUNC || (isym->st_info & 0x0f) == STT_ARM_16BIT)
    {
      putchar('T');
    }
  else
    {
      putchar(' ');
    }
#endif

  /* Common attributes */

  printf("|%c", psym->flags & BSF_OBJECT ? 'O' : '.');
  printf("%c",  psym->flags & BSF_DYNAMIC ? 'D' : '.');
  printf("%c",  psym->flags & BSF_FILE ? 'F' : '.');
  printf("%c",  psym->flags & BSF_INDIRECT ? 'I' : '.');
  printf("%c",  psym->flags & BSF_WARNING ? 'W' : '.');
  printf("%c",  psym->flags & BSF_CONSTRUCTOR ? 'C' : '.');
  printf("%c",  psym->flags & BSF_NOT_AT_END ? 'N' : '.');
  printf("%c",  psym->flags & BSF_OLD_COMMON ? 'c' : '.');
  printf("%c",  psym->flags & BSF_SECTION_SYM ? 'S' : '.');
  printf("%c",  psym->flags & BSF_WEAK ? 'w' : '.');
  printf("%c",  psym->flags & BSF_KEEP_G ? 'G' : '.');
  printf("%c",  psym->flags & BSF_KEEP ? 'K' : '.');
  printf("%c",  psym->flags & BSF_FUNCTION ? 'f' : '.');
  printf("%c",  psym->flags & BSF_DEBUGGING ? 'd' : '.');
  printf("%c",  psym->flags & BSF_GLOBAL ? 'g' : '.');
  printf("%c|", psym->flags & BSF_LOCAL ? 'l' : '.');
  printf("\n");
}

/***********************************************************************
 * check_symbol_overlap
 ***********************************************************************/

static void check_symbol_overlap(asymbol ** symbols, int number_of_symbols)
{
  int i;
  int j;

  for (i = 0; i < number_of_symbols; i++)
    {
      elf_symbol_type *sym_i;
      bfd_vma base_i;
      bfd_vma top_i;
      bfd_vma size_i;

      sym_i = (elf_symbol_type *) symbols[i];
      base_i = sym_i->symbol.section->vma + sym_i->internal_elf_sym.st_value;
      size_i = sym_i->internal_elf_sym.st_size;

      if (0 == size_i)
        {
          if (sym_i->symbol.section->flags & SEC_CODE)
            {
              /* must be an internal branch - ignore */

              vdbg("Sym [%20s] is zero len, skipping!\n", sym_i->symbol.name);
              continue;
            }
          else
            {
              /* pointer - fake size up */
              size_i = 4;
            }
        }

      top_i = base_i + size_i;

      dbg("Sym [%20s] base %08lx, top %08lx\n",
          sym_i->symbol.name, (long)base_i, (long)top_i);

      for (j = (i + 1); j < number_of_symbols; j++)
        {
          elf_symbol_type *sym_j;
          bfd_vma base_j;
          bfd_vma top_j;
          bfd_vma size_j = 0;

          sym_j = (elf_symbol_type *) symbols[j];
          base_j =
            sym_j->symbol.section->vma + sym_j->internal_elf_sym.st_value;

          if (0 == size_j)
            {
              if (sym_j->symbol.section->flags & SEC_CODE)
                {
                  /* must be an internal branch - ignore */
                  continue;
                }
              else
                {
                  /* pointer - fake size up */
                  size_j = 4;
                }
            }

          top_j = base_j + sym_j->internal_elf_sym.st_size;

          if (0 == sym_j->internal_elf_sym.st_size)
            {
              continue;
            }

          if ((base_j < top_i) && (top_j > base_i))
            {
              /* symbols overlap - bad bad bad bad */

              if (verbose)
                {
                  warn("Symbols '%s'[%6s] and '%s'[%6s] OVERLAP!\n",
                      sym_i->symbol.name, sym_i->symbol.section->name,
                      sym_j->symbol.name, sym_j->symbol.section->name);
                  warn("  Sym '%s' base %08lx, top %08lx\n",
                      sym_i->symbol.name, (long)base_i, (long)top_i);
                  warn("  Sym '%s' base %08lx, top %08lx\n",
                      sym_j->symbol.name, (long)base_j, (long)top_j);
                }
            }

        }
    }
}

/***********************************************************************
 * map_common_symbols
 ***********************************************************************/

static void
map_common_symbols(bfd * input_bfd, asymbol ** symbols, int number_of_symbols)
{
  asection *bss_s;
  int i;
  int j;

  bfd_vma baseaddr;
  bfd_vma align;
  bfd_vma size;
  bfd_vma symbase;
  bfd_vma offset;

  bss_s = bss_info.subsect[0];
  baseaddr = 0;

  vdbg("Before map high mark %08lx cooked %08lx raw %08lx \n",
      (long)bss_info.high_mark, (long)bss_info.subsect[0]->COOKED_SIZE,
      (long)bss_info.subsect[0]->RAW_SIZE);
  vdbg("Checking overlap before mapping\n");

  check_symbol_overlap(symbols, number_of_symbols);

  vdbg("Mapping COMMONS\n");

  if (NULL == bss_s)
    {
      warn("NULL section passed to map_common_symbols\n");
      return;
    }

  vdbg("Assigning COMMON symbols to section %s\n", bss_s->name);

  for (i = 0; i < number_of_symbols; i++)
    {
      if (bfd_is_com_section(symbols[i]->section))
        {
          if (verbose)
            {
              message("COMMON sym[%04d] ", i);
              dump_symbol(symbols[i]);
            }

          /* get parameters of unmapped symbol */
#if 0
          align = ((elf_symbol_type *) symbols[i])->internal_elf_sym.st_value;
#else
          /* Ignore alignment - just make sure we're word aligned we're not
           * worrying about page boundaries since we're flat mem and we're not
           * really concerned with cache alignment - maybe someday */

          align = 0x04;
#endif
          size = ((elf_symbol_type *) symbols[i])->internal_elf_sym.st_size;

          if (0 == size)
            {
              dbg("Aero size symbol assumed to be a ptr size 4\n");
              size = 0x04;
            }

          if (size % 0x04)
            {
              dbg("non-mod4 symbol rounded up 4\n");
              size = ((size >> 2) + 1) << 2;
            }

          /* INSERT SYMBOL AT END OF BSS - MUCH MO BETTA */

          /* calulate transaction effects - insert blank b4 sym to get align */

          baseaddr = bss_s->COOKED_SIZE;
          symbase = ((baseaddr + align - 1) / align) * align;
          offset = (symbase + size) - baseaddr;

          vdbg("  ba: %08lx sb: %08lx al: %04lx sz: %04lx of: %04lx\n",
              (long)baseaddr, (long)symbase, (long)align, (long)size, (long)offset);

          /* Add space to bss segment and section */

          bss_info.high_mark += offset;
          bss_info.size += offset;
          bss_s->COOKED_SIZE += offset;
          bss_s->RAW_SIZE += offset;

          /* find all end markers and offset */

          for (j = 0; j < number_of_symbols; j++)
            {
              if (bss_s == symbols[j]->section)
                {
                  if (verbose)
                    {
                      message("Checking endsym? %08lx sym[%04d] ", (long)baseaddr, j);
                      dump_symbol(symbols[j]);
                    }

                  if (symbols[j]->value >= baseaddr)
                    {
                      symbols[j]->value += offset;
                      ((elf_symbol_type *) symbols[j])->internal_elf_sym.
                        st_value += offset;
                      if (verbose > 1)
                        {
                          message("Sym MOVED to sym[%04d] ", j);
                          dump_symbol(symbols[j]);
                        }
                    }
                }
            }

          /* stuff sym at base */

          symbols[i]->section = bss_s;
          symbols[i]->value = symbase;
          symbols[i]->flags = BSF_OBJECT | BSF_GLOBAL;
          ((elf_symbol_type *) symbols[i])->internal_elf_sym.st_value = symbase;

          if (verbose)
            {
              message("NEW sym[%04d] ", i);
              dump_symbol(symbols[i]);
            }
        }
    }

  check_symbol_overlap(symbols, number_of_symbols);

  vdbg("After map high mark %08lx cooked %08lx raw %08lx \n",
      (long)bss_info.high_mark, (long)bss_info.subsect[0]->COOKED_SIZE,
      (long)bss_info.subsect[0]->RAW_SIZE);
}

/***********************************************************************
 * resolve_relocs
 ***********************************************************************/

static void resolve_relocs(bfd *input_bfd, asymbol **symbols)
{
  resolve_segment_relocs(input_bfd, &text_info, symbols);
  resolve_segment_relocs(input_bfd, &data_info, symbols);
  resolve_segment_relocs(input_bfd, &bss_info, symbols);
}

/***********************************************************************
 * allocate_got
 ***********************************************************************/

/* The GOT lies at the beginning of D-Space.  Before we can process
 * any relocation data, we need to determine the size of the GOT.
 */

static void allocate_got(bfd *input_bfd, asymbol **symbols)
{
  allocate_segment_got(input_bfd, &text_info, symbols);
  allocate_segment_got(input_bfd, &data_info, symbols);
  allocate_segment_got(input_bfd, &bss_info, symbols);
}

/***********************************************************************
 * output_got
 ***********************************************************************/

/* Pull the sections that make up this segment in off disk */

static void output_got(int fd)
{
  struct nxflat_reloc_s *relocs;
  u_int32_t *got;
  int reloc_size;
  int reloc_type;
  int nrelocs;
  int i;
  int j;

  if (ngot_offsets > 0)
    {
      /* Allocate memory for the GOT */

      got = (u_int32_t*)malloc(got_size);
      if (!got)
        {
           err("Failed to allocate memory for the GOT (%d bytes, %d offsets)\n",
               got_size, ngot_offsets);
           exit(1);
        }

      /* Re-allocate memory for the relocations to include the GOT relocations */

      nrelocs    = ngot_offsets + nxflat_nrelocs;
      reloc_size = sizeof(struct nxflat_reloc_s) * nrelocs;
      relocs     = (struct nxflat_reloc_s*)realloc(nxflat_relocs, reloc_size);
      if (!relocs)
        {
           err("Failed to re-allocate memory for the GOT relocations (%d bytes, %d relocations)\n",
               reloc_size, nrelocs);
           exit(1);
        }

      /* Then initialize the GOT contents with the value associated with each symbol */

      for (i = 0; i < ngot_offsets; i++)
        {
          asymbol  *rel_sym     = got_offsets[i].sym;
          asection *rel_section = rel_sym->section;
          symvalue  sym_value   = rel_sym->value;

          /* j is the offset index into the relocatino table */

          j = i + nxflat_nrelocs;

          /* If the symbol is a thumb function, then set bit 1 of the value */

#ifdef NXFLAT_THUMB2
          if ((((elf_symbol_type *)rel_sym)->internal_elf_sym.st_info & 0x0f) == STT_ARM_TFUNC)
            {
               sym_value |= 1;
            }
#endif
          /* Determine where the symbol lies */

          switch (get_reloc_type(rel_section, NULL))
            {
              /* If the symbol lies in D-Space, then we need to add the size of the GOT
               * table to the symbol value
               */

            case NXFLAT_RELOC_TARGET_BSS:
            case NXFLAT_RELOC_TARGET_DATA:
              {
                vdbg("Symbol '%s' lies in D-Space\n", rel_sym->name);
                reloc_type = NXFLAT_RELOC_TYPE_REL32D;
                sym_value += got_size;
              }
              break;

              /* If the symbol lies in I-Space */

            case NXFLAT_RELOC_TARGET_TEXT:
              {
                vdbg("Symbol '%s' lies in I-Space\n", rel_sym->name);
                reloc_type = NXFLAT_RELOC_TYPE_REL32I;
              }
              break;

            case NXFLAT_RELOC_TARGET_UNKNOWN:
            default:
              {
                err("Relocation type is unknown\n");
                nerrors++;
                continue;
              }
            }

          /* Then save the symbol offset in the got */

          got[i] = sym_value;
          vdbg("GOT[%d]: sym name: '%s' value: %08lx->%08lx\n",
                i, rel_sym->name, (long)rel_sym->value, (long)sym_value);

          /* And output the relocation information associate with the GOT entry */

          relocs[j].r_info = NXFLAT_RELOC(reloc_type, sizeof(u_int32_t) * i);
 
          vdbg("relocs[%d]: type: %d offset: %08x\n",
                j, NXFLAT_RELOC_TYPE(relocs[j].r_info), NXFLAT_RELOC_OFFSET(relocs[j].r_info));
        }

      /* Write the GOT on the provided file descriptor */

      if (verbose > 1)
        {
           printf("GOT:\n");
           for (i = 0; i < ngot_offsets; i++)
             {
               printf("  Offset %-3ld: %08x\n",
                     (long)(sizeof(u_int32_t) * i), got[i]);
             }

           printf("Relocations:\n");
           for (i = 0; i < nrelocs; i++)
             {
               printf("  Offset %-3ld: %08x\n",
                     (long)(sizeof(struct nxflat_reloc_s) * i), relocs[i].r_info);
             }
        }

      nxflat_write(fd, (const char *)got, got_size);
      free(got);

      /* Return the relocation table (via global variables) */

      nxflat_relocs  = relocs;
      nxflat_nrelocs = nrelocs;
    }
}

/***********************************************************************
 * is_unwanted_section
 ***********************************************************************/

/* Return 1 if this is a section that we want to throw away but can only
 * identify by name.   Normally, any section with appropriate-looking flags
 * will get copied into the output file.
 */

static int is_unwanted_section(asection * s)
{
  if (!strcmp(s->name, ".hash"))
    return 1;
  if (!strcmp(s->name, ".dynstr") || !strcmp(s->name, ".dynsym"))
    return 1;
  if (s->flags & SEC_DEBUGGING)
    return 1;
  return 0;
}

/***********************************************************************
 * register_section
 ***********************************************************************/

/* Mark this section for inclusion in some segment.  */
static void register_section(asection * s, segment_info * inf)
{
  vdbg("registering section %s to %s segment\n", s->name, inf->name);
  inf->subsect[inf->nsubsects++] = s;
}

/***********************************************************************
 * dump_sections
 ***********************************************************************/

/* Print out the sections that make up this segment for debugging.  */
static void dump_sections(segment_info * inf)
{
  int i;
  printf("      [ ");
  for (i = 0; i < inf->nsubsects; i++)
    {
      printf("%s ", inf->subsect[i]->name);
    }
  printf("]\n");
}

/***********************************************************************
 * load_sections
 ***********************************************************************/

/* Pull the sections that make up this segment in off disk */

static void load_sections(bfd *bfd, segment_info *inf)
{
  void *ptr;
  int i;

  if (inf->size > 0)
    {
      inf->contents = malloc(inf->size);
      if (!inf->contents)
        {
          err("Failed to allocate memory for section contents.\n");
          exit(1);
        }

      ptr = inf->contents;
      for (i = 0; i < inf->nsubsects; i++)
        {
          if (!bfd_get_section_contents(bfd, inf->subsect[i], ptr,
                                        0, inf->subsect[i]->COOKED_SIZE))
            {
              err("Failed to read section contents.\n");
              exit(1);
            }
          ptr += inf->subsect[i]->COOKED_SIZE;
          inf->subsect[i]->flags |= SEC_IN_MEMORY;
        }
    }
}

/***********************************************************************
 * stack_nxflat_segment
 ***********************************************************************/

static void stack_nxflat_segment(segment_info * inf)
{
  bfd_vma min_addr = 0x7fffffff;
  bfd_vma max_addr = 0x00000000;
  int i;

  for (i = 0; i < inf->nsubsects; i++)
    {
      bfd_vma vma = inf->subsect[i]->vma;
      if (vma < min_addr)
        min_addr = vma;

      vma += inf->subsect[i]->COOKED_SIZE;
      if (vma > max_addr)
        max_addr = vma;
    }

  inf->low_mark = min_addr;
  inf->high_mark = max_addr;
  inf->size = max_addr - min_addr;
}

/***********************************************************************
 * show_usage
 ***********************************************************************/

static void show_usage(void)
{
  fprintf(stderr, "Usage: %s [options] <bfd-filename>\n\n", program_name);
  fprintf(stderr, "Where options are one or more of the following.  Note\n");
  fprintf(stderr, "that a space is always required between the option and\n");
  fprintf(stderr, "any following arguments.\n\n");
  fprintf(stderr, "  -d Use dynamic symbol table [Default: symtab]\n");
  fprintf(stderr, "  -e <entry-point>\n");
  fprintf(stderr, "     Entry point to module [Default: %s]\n",
          default_exe_entry_name);
  fprintf(stderr, "  -o <out-filename>\n");
  fprintf(stderr, "     Output to <out-filename> [Default: <bfd-filename>.nxf]\n");
  fprintf(stderr, "  -s <stack-size>\n");
  fprintf(stderr, "     Set stack size to <stack-size> [Default: %d]\n", DEFAULT_STACK_SIZE);
  fprintf(stderr, "  -v Verbose outpu.t If -v is applied twice, additional\n");
  fprintf(stderr, "     debug output is enabled [Default: no verbose output].\n");
  fprintf(stderr, "\n");
  exit(2);
}

/***********************************************************************
 * parse_args
 ***********************************************************************/

static void parse_args(int argc, char **argv)
{
  int opt;

  /* Save our name (for show_usage) */

  program_name = argv[0];

  /* Set some default values */

  stack_size = 0;
  entry_name = NULL;

  if (argc < 2)
    {
      err("Missing required arguments\n\n");
      show_usage();
    }

  /* Get miscellaneous options from the command line. */

  while ((opt = getopt(argc, argv, "de:lo:s:v")) != -1)
    {
      switch (opt)
        {
        case 'd':
          dsyms++;
          break;

        case 'e':
          entry_name = strdup(optarg);
          break;

        case 'o':
          out_filename = optarg;
          break;

        case 's':
          stack_size = atoi(optarg);
          break;

        case 'v':
          verbose++;
          break;

        case 'l':
        default:
          err("%s Unknown option\n\n", argv[0]);
          show_usage();
          break;
        }
    }

  /* The very last thing is also the name of the BFD input file */

  bfd_filename = argv[argc - 1];

  /* Verify that an appropriate stack size is selected. */

  if (stack_size == 0)
    {
      /* Executables must have a stack_size selected. */

      printf("Using default stack size: %d\n", DEFAULT_STACK_SIZE);
      stack_size = DEFAULT_STACK_SIZE;
    }

  if (entry_name == NULL)
    {
      printf("Using entry_point: %s\n", default_exe_entry_name);
      entry_name = default_exe_entry_name;
    }
}

/***********************************************************************
 * Public Functions
 ***********************************************************************/

/***********************************************************************
 * main
 ***********************************************************************/

int main(int argc, char **argv, char **envp)
{
  struct nxflat_hdr_s hdr;
  bfd *bf;
  asection *s;
  asymbol **symbol_table;
  int32_t number_of_symbols;
  u_int32_t offset;
  int fd;
  int i;

  /* Parse the incoming command line */

  parse_args(argc, argv);

  /* Open the BFD input file */

  if (!(bf = bfd_openr(argv[argc - 1], 0)))
    {
      err("Failed to open %s\n", argv[argc - 1]);
      exit(1);
    }

  /* Verify the format of the BFD file */

  if (bfd_check_format(bf, bfd_object) == 0)
    {
      err("File is not an object file\n");
      exit(2);
    }

  /* Read the symbol table from the file */

  symbol_table = get_symbols(bf, &number_of_symbols);

  /* Find all of the special symbols that we will need in the symbol table that 
   * we just read. */

  find_special_symbols();

  /* Walk the list of sections, figuring out where each one goes and how much
   * storage it requires. */

  text_info.low_mark = data_info.low_mark = bss_info.low_mark = -1;
  text_info.high_mark = data_info.high_mark = bss_info.high_mark = 0;
  text_info.contents = data_info.contents = bss_info.contents = NULL;
  text_info.size = data_info.size = bss_info.size = 0;
  text_info.nsubsects = data_info.nsubsects = bss_info.nsubsects = 0;
  text_info.name = "text";
  data_info.name = "data";
  bss_info.name = "bss";

  for (s = bf->sections; s != NULL; s = s->next)
    {
      dbg("Reading section %s\n", s->name);

      /* ignore blatantly useless sections */

      if (!is_unwanted_section(s))
        {
          if (s->flags == SEC_ALLOC)
            {
              vdbg("  Section %s is ALLOC only\n", s->name);
              register_section(s, &bss_info);
            }
          else if ((s->flags & SEC_CODE) != 0 && (s->flags & SEC_ALLOC) != 0)
            {
              vdbg("  Section %s is CODE\n", s->name);
              register_section(s, &text_info);
            }
          else if ((s->flags & SEC_DATA) != 0 && (s->flags & SEC_ALLOC) != 0)
            {
              vdbg("  Section %s is DATA\n", s->name);
              register_section(s, &data_info);
            }
          else
            {
              vdbg("WARNING: ignoring section %s\n", s->name);
            }
        }
    }

  /* Fixup high and low water VMA address */

  stack_nxflat_segment(&text_info);
  stack_nxflat_segment(&data_info);
  stack_nxflat_segment(&bss_info);

  /* Check for a data offset due to the presence of a GOT */

  printf("INPUT SECTIONS:\n");
  printf("SECT LOW      HIGH     SIZE\n");
  if (text_info.nsubsects == 0)
    {
      warn("TEXT Not found  Not found ( Not found )\n");
    }
  else
    {
      printf("TEXT %08lx %08lx %08lx\n",
             (long)text_info.low_mark, (long)text_info.high_mark,
             (long)text_info.size);

      if (text_info.low_mark != 0)
        {
          err("Text section must be origined at zero");
          exit(1);
        }
    }

  if (data_info.nsubsects == 0)
    {
      warn("DATA Not found  Not found ( Not found )\n");
    }
  else
    {
      printf("DATA %08lx %08lx %08lx\n",
             (long)data_info.low_mark, (long)data_info.high_mark,
             (long)data_info.size);

      if (data_info.low_mark != 0)
        {
          err("data section must be origined at zero");
          exit(1);
        }
    }

  if (bss_info.nsubsects == 0)
    {
      warn("BSS  Not found  Not found ( Not found )\n");
    }
  else
    {
      printf("BSS  %08lx %08lx %08lx\n",
             (long)bss_info.low_mark, (long)bss_info.high_mark,
             (long)bss_info.size);

      /* If data is present, then BSS was be origined immediately after the
       * data. */

      if (data_info.nsubsects > 0)
        {
          /* There is data... Account for possible ALIGN 0x10 at end of data */

          u_int32_t bss_start1 = data_info.high_mark;
          u_int32_t bss_start2 = ((bss_start1 + 0x0f) & ~0x0f);

          if ((bss_info.low_mark < bss_start1) &&
              (bss_info.low_mark > bss_start2))
            {
              err("BSS must be origined immediately after the data section\n");
              exit(1);
            }
        }

      /* If there is no data, then the BSS must be origined at zero */

      else if (bss_info.low_mark != 0)
        {
          err("BSS section (with no data section) must be origined at zero\n");
          exit(1);
        }
    }

  if (verbose)
    {
      message("TEXT: ");
      dump_sections(&text_info);
      message("DATA: ");
      dump_sections(&data_info);
      message("BSS: ");
      dump_sections(&bss_info);
    }

  /* Slurp the section contents in.  No need to load BSS since we know it
   * isn't initialised. */

  load_sections(bf, &text_info);
  load_sections(bf, &data_info);

  /* Unmapped 'common' symbols need to be stuffed into bss */

  map_common_symbols(bf, symbol_table, number_of_symbols);

  /* Dump symbol information */

  if (verbose)
    {
      for (i = 0; i < number_of_symbols; i++)
        {
          message("sym[%04d] ", i);
          dump_symbol(symbol_table[i]);
        }
    }

  /* The GOT lies at the beginning of D-Space.  Before we can process
   * any relocation data, we need to determine the size of the GOT.
   */

  allocate_got(bf, symbol_table);

  /* Then process all of the relocations */

  resolve_relocs(bf, symbol_table);

  /* Fill in the NXFLAT file header */

  memcpy(hdr.h_magic, NXFLAT_MAGIC, 4);

  offset = NXFLAT_HDR_SIZE + text_info.size;
  put_xflat32(&hdr.h_datastart, offset);

  offset += got_size + data_info.size;
  put_xflat32(&hdr.h_dataend, offset);
  put_xflat32(&hdr.h_relocstart, offset);

  offset += bss_info.size;
  put_xflat32(&hdr.h_bssend, offset);

  put_xflat32(&hdr.h_stacksize, stack_size);
  put_xflat16(&hdr.h_reloccount, nxflat_nrelocs + ngot_offsets);

  put_entry_point(&hdr);

  put_special_symbol(dynimport_begin_symbol, dynimport_end_symbol,
                     &hdr.h_importsymbols, &hdr.h_importcount,
                     sizeof(struct nxflat_import_s), text_info.size + got_size);

  /* Open the output file */

  if (!out_filename)
    {
      out_filename = malloc(strlen(bfd_filename) + 5);  /* 5 to add suffix */
      strcpy(out_filename, bfd_filename);
      strcat(out_filename, ".nxf");
    }

  fd = open(out_filename, O_WRONLY | O_PLATFORM | O_CREAT | O_TRUNC, 0744);
  if (fd < 0)
    {
      err("Failed open output file %s: %s\n", out_filename, strerror(errno));
      exit(4);
    }

  /* Write the data in the following order in order to match the NXFLAT header
   * offsets:  HDR, ISPACE, GOT, DSPACE, RELOCS.
   */

  nxflat_write(fd, (const char *)&hdr, NXFLAT_HDR_SIZE);
  nxflat_write(fd, (const char *)text_info.contents, text_info.size);

  if (ngot_offsets > 0)
    {
      output_got(fd);
    }

  nxflat_write(fd, (const char *)data_info.contents, data_info.size);

  if (nxflat_relocs)
    {
      vdbg("Number of GOT relocations: %d\n", ngot_offsets);

#ifdef RELOCS_IN_NETWORK_ORDER
      for (i = 0; i < nxflat_nrelocs; i++)
        {
          nxflat_relocs[i] = htonl(nxflat_relocs[i]);
        }
#endif
      nxflat_write(fd, (const char *)nxflat_relocs, sizeof(struct nxflat_reloc_s) * nxflat_nrelocs);
    }

  /* Finished! */

  close(fd);

  if (nerrors > 0)
    {
       fprintf(stderr, "%d Errors detected\n", nerrors);
       return 1;
    }
  return 0;
}