/*
 * elf2flt.c: Convert ELF (or any BFD format) to FLAT binary format
 *
 * (c) 1999-2002, Greg Ungerer <gerg@snapgear.com>
 * Created elf2flt from coff2flt (see copyrights below). Added all the
 * ELF format file handling. Extended relocation support for all of
 * text and data.
 *
 * (c) 2006  Support the -a (use_resolved) option for TARGET_arm.
 *           Shaun Jackman <sjackman@gmail.com>
 * (c) 2004, Nios II support, Wentao Xu <wentao@microtronix.com>
 * (c) 2003, H8 support, ktrace <davidm@snapgear.com>
 * (c) 2003-2004, MicroBlaze support, John Williams <jwilliams@itee.uq.edu.au>
 * (c) 2001-2003, arm/arm-pic/arm-big-endian support <davidm@snapgear.com>
 * (c) 2001, v850 changes, Mile Bader <miles@lsi.nec.co.jp>
 * (c) 2003, SuperH support, Paul Mundt <lethal@linux-sh.org>
 * (c) 2001, zflat support <davidm@snapgear.com>
 * (c) 2001, Changes for GOT entries Paul Dale <pauli@snapgear.com> and
 *           David McCullough <davidm@snapgear.com>
 *
 * Now supports PIC with GOT tables.  This works by taking a '.elf' file
 * and a fully linked elf executable (at address 0) and produces a flat
 * file that can be loaded with some fixups.  It still supports the old
 * style fully relocatable elf format files.
 *
 * 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>
 *
 * This is Free Software, under the GNU Public Licence v2 or greater.
 *
 * Relocation added March 1997, Kresten Krab Thorup 
 * krab@california.daimi.aau.dk
 */
 
#include <stdio.h>    /* Userland pieces of the ANSI C standard I/O package  */
#include <stdlib.h>   /* Userland prototypes of the ANSI C std lib functions */
#include <stdarg.h>   /* Allows va_list to exist in the these namespaces     */
#include <string.h>   /* Userland prototypes of the string handling funcs    */
#include <strings.h>
#include <unistd.h>   /* Userland prototypes of the Unix std system calls    */
#include <fcntl.h>    /* Flag value for file handling functions              */
#include <time.h>
#ifndef WIN32
#include <netinet/in.h> /* Consts and structs defined by the internet system */
#define	BINARY_FILE_OPTS
#else
#include <winsock2.h>
#define	BINARY_FILE_OPTS "b"
#endif

/* from $(INSTALLDIR)/include       */
#include <bfd.h>      /* Main header file for the BFD library                */

#if defined(TARGET_h8300)
#include <elf/h8.h>      /* TARGET_* ELF support for the BFD library            */
#elif defined(__CYGWIN__) || defined(__MINGW32__) || defined(TARGET_nios) || defined(TARGET_nios2)
#include "cygwin-elf.h"	/* Cygwin uses a local copy */
#elif defined(TARGET_microblaze)
#include <elf/microblaze.h>	/* TARGET_* ELF support for the BFD library */
#elif defined(TARGET_bfin)
#include "elf/bfin.h"
#else
#include <elf.h>      /* TARGET_* ELF support for the BFD library            */
#endif

#if defined(__MINGW32__)
#include <getopt.h>
#endif

/* from uClinux-x.x.x/include/linux */
#include "flat.h"     /* Binary flat header description                      */

#ifdef TARGET_e1
#include <e1.h>
#endif

#ifdef TARGET_v850e
#define TARGET_v850
#endif

#if defined(TARGET_m68k)
#define	ARCH	"m68k/coldfire"
#elif defined(TARGET_arm)
#define	ARCH	"arm"
#elif defined(TARGET_sparc)
#define	ARCH	"sparc"
#elif defined(TARGET_v850)
#define	ARCH	"v850"
#elif defined(TARGET_sh)
#define	ARCH	"sh"
#elif defined(TARGET_h8300)
#define	ARCH	"h8300"
#elif defined(TARGET_microblaze)
#define ARCH	"microblaze"
#elif defined(TARGET_e1)
#define ARCH    "e1-coff"
#elif defined(TARGET_bfin)
#define ARCH	"bfin"
#define FLAT_RELOC_TYPE_TEXT 0
#define FLAT_RELOC_TYPE_DATA 1
#define FLAT_RELOC_TYPE_BSS 2
#define FLAT_RELOC_TYPE_STACK 3
#define FLAT_RELOC_PART_LO 0
#define FLAT_RELOC_PART_HI 1
#define PCREL24_MAGIC_OFFSET -1
#elif defined(TARGET_nios)
#define ARCH	"nios"
#elif defined(TARGET_nios2)
#define ARCH	"nios2"
#else
#error "Don't know how to support your CPU architecture??"
#endif

#if defined(TARGET_m68k) || defined(TARGET_h8300) || defined(TARGET_bfin)
/*
 * Define a maximum number of bytes allowed in the offset table.
 * We'll fail if the table is larger than this.
 *
 * This limit may be different for platforms other than m68k, but
 * 8000 entries is a lot,  trust me :-) (davidm)
 */
#define GOT_LIMIT 32767
/*
 * we have to mask out the shared library id here and there,  this gives
 * us the real address bits when needed
 */
#define	real_address_bits(x)	(pic_with_got ? ((x) & 0xffffff) : (x))
#else
#define	real_address_bits(x)	(x)
#endif

#ifndef O_BINARY
#define O_BINARY 0
#endif


int verbose = 0;      /* extra output when running */
int pic_with_got = 0; /* do elf/got processing with PIC code */
int load_to_ram = 0;  /* instruct loader to allocate everything into RAM */
int ktrace = 0;       /* instruct loader output kernel trace on load */
int compress = 0;     /* 1 = compress everything, 2 = compress data only */
int use_resolved = 0; /* If true, get the value of symbol references from */
		      /* the program contents, not from the relocation table. */
		      /* In this case, the input ELF file must be already */
		      /* fully resolved (using the `-q' flag with recent */
		      /* versions of GNU ld will give you a fully resolved */
		      /* output file with relocation entries).  */

const char *progname, *filename;
int lineno;

int nerrors = 0;
int nwarnings = 0;

static char where[200];

enum {
  /* Use exactly one of these: */
  E_NOFILE = 0,         /* "progname: " */
  E_FILE = 1,           /* "filename: " */
  E_FILELINE = 2,       /* "filename:lineno: " */
  E_FILEWHERE = 3,      /* "filename:%s: " -- set %s with ewhere() */
          
  /* Add in any of these with |': */
  E_WARNING = 0x10,
  E_PERROR = 0x20
};
                  
void ewhere (const char *format, ...);
void einfo (int type, const char *format, ...);
                  

void
ewhere (const char *format, ...) {
  va_list args;
  va_start (args, format);
  vsprintf (where, format, args);
  va_end (args);
}


void
einfo (int type, const char *format, ...) {
  va_list args;

  switch (type & 0x0f) {
  case E_NOFILE:
    fprintf (stderr, "%s: ", progname);
    break;
  case E_FILE:
    fprintf (stderr, "%s: ", filename);
    break;
  case E_FILELINE:
    ewhere ("%d", lineno);
    /* fall-through */
  case E_FILEWHERE:
    fprintf (stderr, "%s:%s: ", filename, where);
    break;
  }

  if (type & E_WARNING) {
    fprintf (stderr, "warning: ");
    nwarnings++;
  } else {
    nerrors++;
  }

  va_start (args, format);
  vfprintf (stderr, format, args);
  va_end (args);

  if (type & E_PERROR)
    perror ("");
  else
    fprintf (stderr, "\n");
}


asymbol**
get_symbols (bfd *abfd, long *num)
{
  long storage_needed;
  asymbol **symbol_table;
  long number_of_symbols;
  
  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);

  number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
  
  if (number_of_symbols < 0) 
    abort ();

  *num = number_of_symbols;
  return symbol_table;
}


int
dump_symbols(asymbol **symbol_table, long number_of_symbols)
{
  long i;
  printf("SYMBOL TABLE:\n");
  for (i=0; i<number_of_symbols; i++) {
	printf("  NAME=%s  VALUE=0x%x\n", symbol_table[i]->name,
		symbol_table[i]->value);
  }
  printf("\n");
  return(0);
}  


long
get_symbol_offset(char *name, asection *sec, asymbol **symbol_table, long number_of_symbols)
{
  long i;
  for (i=0; i<number_of_symbols; i++) {
    if (symbol_table[i]->section == sec) {
      if (!strcmp(symbol_table[i]->name, name)) {
        return symbol_table[i]->value;
      }
    }
  }
  return -1;
}  


long
get_gp_value(asymbol **symbol_table, long number_of_symbols)
{
  long i;
  for (i=0; i<number_of_symbols; i++) {
      if (!strcmp(symbol_table[i]->name, "_gp"))
		return symbol_table[i]->value;
  }
  return -1;
}
 

long
add_com_to_bss(asymbol **symbol_table, long number_of_symbols, long bss_len)
{
  long i, comsize;
  long offset;

  comsize = 0;
  for (i=0; i<number_of_symbols; i++) {
    if (strcmp("*COM*", symbol_table[i]->section->name) == 0) {
      offset = bss_len + comsize;
      comsize += symbol_table[i]->value;
      symbol_table[i]->value = offset;
    }
  }
  return comsize;
}  

#ifdef TARGET_bfin
/* FUNCTION : weak_und_symbol
   ABSTRACT : return true if symbol is weak and undefined.
*/
static int
weak_und_symbol(const char *reloc_section_name,
                struct bfd_symbol *symbol)
{
    if (!(strstr (reloc_section_name, "text")
	  || strstr (reloc_section_name, "data")
	  || strstr (reloc_section_name, "bss"))) {
	if (symbol->flags & BSF_WEAK) {
#ifdef DEBUG_BFIN
	    fprintf(stderr, "found weak undefined symbol %s\n", symbol->name);
#endif
	    return TRUE;
	}
    }
    return FALSE;
}

static int
bfin_set_reloc (uint32_t *reloc, 
		const char *reloc_section_name, 
		const char *sym_name,
		struct bfd_symbol *symbol,
		int sp, int hilo, int32_t offset)
{
    unsigned int type;
    uint32_t val;

    if (strstr (reloc_section_name, "text"))
	type = FLAT_RELOC_TYPE_TEXT;
    else if (strstr (reloc_section_name, "data"))
	type = FLAT_RELOC_TYPE_DATA;
    else if (strstr (reloc_section_name, "bss"))
	type = FLAT_RELOC_TYPE_BSS;
    else if (strstr (reloc_section_name, "stack"))
	type = FLAT_RELOC_TYPE_STACK;
    else if (symbol->flags & BSF_WEAK){
	/* weak symbol support ... if a weak symbol is undefined at the
	   end of a final link, it should return 0 rather than error
	   We will assume text section for the moment.
	*/
	type = FLAT_RELOC_TYPE_TEXT;
    } else if (strstr (reloc_section_name, "*ABS*")){
	/* (A data section initialization of something in the shared libc's text section
	   does not resolve - i.e. a global pointer to function initialized with
	   a libc function).
	   The text section here is appropriate as the section information
	   of the shared library is lost. The loader will do some calcs.
	*/
	type = FLAT_RELOC_TYPE_TEXT;
    } else {
	printf ("Unknown Type - relocation for %s in bad section - %s\n", sym_name, reloc_section_name);
	return 1;
    }

    val = (offset & ((1 << 26) - 1)) << 6;
    val |= (sp & (1 << 3) - 1) << 3;
    val |= (hilo & 1) << 2;
    val |= (type & (1 << 2) - 1);
    *reloc = val;
    return 0;
}
#endif


uint32_t *
output_relocs (
  bfd *abs_bfd,
  asymbol **symbols,
  int number_of_symbols,
  unsigned long *n_relocs,
  unsigned char *text, int text_len, unsigned long text_vma,
  unsigned char *data, int data_len, unsigned long data_vma,
  bfd *rel_bfd)
{
  uint32_t		*flat_relocs;
  asection		*a, *sym_section, *r;
  arelent		**relpp, **p, *q;
  const char		*sym_name, *section_name;
  unsigned char		*sectionp;
  unsigned long		pflags;
  char			addstr[16];
  long			sym_addr, sym_vma, section_vma;
  int			relsize, relcount;
  int			flat_reloc_count;
  int			sym_reloc_size, rc;
  int			got_size = 0;
  int			bad_relocs = 0;
  asymbol		**symb;
  long			nsymb;
  
#if 0
  printf("%s(%d): output_relocs(abs_bfd=%d,synbols=0x%x,number_of_symbols=%d"
	"n_relocs=0x%x,text=0x%x,text_len=%d,data=0x%x,data_len=%d)\n",
	__FILE__, __LINE__, abs_bfd, symbols, number_of_symbols, n_relocs,
	text, text_len, data, data_len);
#endif

#if 0
dump_symbols(symbols, number_of_symbols);
#endif

  *n_relocs = 0;
  flat_relocs = NULL;
  flat_reloc_count = 0;
  rc = 0;
  pflags = 0;

  /* Determine how big our offset table is in bytes.
   * This isn't too difficult as we've terminated the table with -1.
   * Also note that both the relocatable and absolute versions have this
   * terminator even though the relocatable one doesn't have the GOT!
   */
  if (pic_with_got && !use_resolved) {
    unsigned long *lp = (unsigned long *)data;
    /* Should call ntohl(*lp) here but is isn't going to matter */
    while (*lp != 0xffffffff) lp++;
    got_size = ((unsigned char *)lp) - data;
    if (verbose)
	    printf("GOT table contains %d entries (%d bytes)\n",
			    got_size/sizeof(unsigned long), got_size);
#ifdef TARGET_m68k
    if (got_size > GOT_LIMIT) {
	    fprintf(stderr, "GOT too large: %d bytes (limit = %d bytes)\n",
			    got_size, GOT_LIMIT);
	    exit(1);
    }
#endif
  }

  for (a = abs_bfd->sections; (a != (asection *) NULL); a = a->next) {
  	section_vma = bfd_section_vma(abs_bfd, a);

	if (verbose)
		printf("SECTION: %s [0x%x]: flags=0x%x vma=0x%x\n", a->name, a,
			a->flags, section_vma);

//	if (bfd_is_abs_section(a))
//		continue;
	if (bfd_is_und_section(a))
		continue;
	if (bfd_is_com_section(a))
		continue;
//	if ((a->flags & SEC_RELOC) == 0)
//		continue;

	/*
	 *	Only relocate things in the data sections if we are PIC/GOT.
	 *	otherwise do text as well
	 */
	if (!pic_with_got && (a->flags & SEC_CODE))
		sectionp = text + (a->vma - text_vma);
	else if (a->flags & SEC_DATA)
		sectionp = data + (a->vma - data_vma);
	else
		continue;

	/* Now search for the equivalent section in the relocation binary
	 * and use that relocation information to build reloc entries
	 * for this one.
	 */
	for (r=rel_bfd->sections; r != NULL; r=r->next)
		if (strcmp(a->name, r->name) == 0)
			break;
	if (r == NULL)
	  continue;
	if (verbose)
	  printf(" RELOCS: %s [0x%x]: flags=0x%x vma=0x%x\n", r->name, r,
			r->flags, bfd_section_vma(abs_bfd, r));
  	if ((r->flags & SEC_RELOC) == 0)
  	  continue;
	relsize = bfd_get_reloc_upper_bound(rel_bfd, r);
	if (relsize <= 0) {
		if (verbose)
			printf("%s(%d): no relocation entries section=0x%x\n",
				__FILE__, __LINE__, r->name);
		continue;
	}

	symb = get_symbols(rel_bfd, &nsymb);
	relpp = (arelent **) xmalloc(relsize);
	relcount = bfd_canonicalize_reloc(rel_bfd, r, relpp, symb);
	if (relcount <= 0) {
		if (verbose)
			printf("%s(%d): no relocation entries section=%s\n",
			__FILE__, __LINE__, r->name);
		continue;
	} else {
		for (p = relpp; (relcount && (*p != NULL)); p++, relcount--) {
			unsigned char *r_mem;
			int relocation_needed = 0;

#ifdef TARGET_microblaze
			/* The MICROBLAZE_XX_NONE relocs can be skipped.
			   They represent PC relative branches that the
			   linker has already resolved */
				
			switch ((*p)->howto->type) 
			{
			case R_MICROBLAZE_NONE:
			case R_MICROBLAZE_64_NONE:
				continue;
			}
#endif /* TARGET_microblaze */

#ifdef TARGET_v850
			/* Skip this relocation entirely if possible (we
			   do this early, before doing any other
			   processing on it).  */
			switch ((*p)->howto->type) {
#ifdef R_V850_9_PCREL
			case R_V850_9_PCREL:
#endif
#ifdef R_V850_22_PCREL
			case R_V850_22_PCREL:
#endif
#ifdef R_V850_SDA_16_16_OFFSET
			case R_V850_SDA_16_16_OFFSET:
#endif
#ifdef R_V850_SDA_15_16_OFFSET
			case R_V850_SDA_15_16_OFFSET:
#endif
#ifdef R_V850_ZDA_15_16_OFFSET
			case R_V850_ZDA_15_16_OFFSET:
#endif
#ifdef R_V850_TDA_6_8_OFFSET
			case R_V850_TDA_6_8_OFFSET:
#endif
#ifdef R_V850_TDA_7_8_OFFSET
			case R_V850_TDA_7_8_OFFSET:
#endif
#ifdef R_V850_TDA_7_7_OFFSET
			case R_V850_TDA_7_7_OFFSET:
#endif
#ifdef R_V850_TDA_16_16_OFFSET
			case R_V850_TDA_16_16_OFFSET:
#endif
#ifdef R_V850_TDA_4_5_OFFSET
			case R_V850_TDA_4_5_OFFSET:
#endif
#ifdef R_V850_TDA_4_4_OFFSET
			case R_V850_TDA_4_4_OFFSET:
#endif
#ifdef R_V850_SDA_16_16_SPLIT_OFFSET
			case R_V850_SDA_16_16_SPLIT_OFFSET:
#endif
#ifdef R_V850_CALLT_6_7_OFFSET
			case R_V850_CALLT_6_7_OFFSET:
#endif
#ifdef R_V850_CALLT_16_16_OFFSET
			case R_V850_CALLT_16_16_OFFSET:
#endif
				/* These are relative relocations, which
				   have already been fixed up by the
				   linker at this point, so just ignore
				   them.  */ 
				continue;
			}
#endif /* USE_V850_RELOCS */

			q = *p;
			if (q->sym_ptr_ptr && *q->sym_ptr_ptr) {
				sym_name = (*(q->sym_ptr_ptr))->name;
				sym_section = (*(q->sym_ptr_ptr))->section;
				section_name=(*(q->sym_ptr_ptr))->section->name;
			} else {
				printf("ERROR: undefined relocation entry\n");
				rc = -1;
				continue;
			}
#ifndef TARGET_bfin
			/* Adjust the address to account for the GOT table which wasn't
			 * present in the relative file link.
			 */
			if (pic_with_got && !use_resolved)
			  q->address += got_size;
#endif

			/* A pointer to what's being relocated, used often
			   below.  */
			r_mem = sectionp + q->address;

			/*
			 *	Fixup offset in the actual section.
			 */
			addstr[0] = 0;
#ifndef TARGET_e1
  			if ((sym_addr = get_symbol_offset((char *) sym_name,
			    sym_section, symbols, number_of_symbols)) == -1) {
				sym_addr = 0;
			}
#else
			sym_addr = (*(q->sym_ptr_ptr))->value;
#endif			
			if (use_resolved) {
				/* Use the address of the symbol already in
				   the program text.  How this is handled may
				   still depend on the particular relocation
				   though.  */
				switch (q->howto->type) {
					int r2_type;
#ifdef TARGET_v850
				case R_V850_HI16_S:
					/* We specially handle adjacent
					   HI16_S/ZDA_15_16_OFFSET and
					   HI16_S/LO16 pairs that reference the
					   same address (these are usually
					   movhi/ld and movhi/movea pairs,
					   respectively).  */
					if (relcount == 0)
						r2_type = R_V850_NONE;
					else
						r2_type = p[1]->howto->type;
					if ((r2_type == R_V850_ZDA_15_16_OFFSET
					     || r2_type == R_V850_LO16)
					    && (p[0]->sym_ptr_ptr
						== p[1]->sym_ptr_ptr)
					    && (p[0]->addend == p[1]->addend))
					{
						relocation_needed = 1;

						switch (r2_type) {
						case R_V850_ZDA_15_16_OFFSET:
							pflags = 0x10000000;
							break;
						case R_V850_LO16:
							pflags = 0x20000000;
							break;
						}

						/* We don't really need the
						   actual value -- the bits
						   produced by the linker are
						   what we want in the final
						   flat file -- but get it
						   anyway if useful for
						   debugging.  */
						if (verbose) {
							unsigned char *r2_mem =
								sectionp
								+ p[1]->address;
							/* little-endian */
							int hi = r_mem[0]
								+ (r_mem[1] << 8);
							int lo = r2_mem[0]
								+ (r2_mem[1] << 8);
							/* Sign extend LO.  */
							lo = (lo ^ 0x8000)
								- 0x8000;

							/* Maybe ignore the LSB
							   of LO, which is
							   actually part of the
							   instruction.  */
							if (r2_type != R_V850_LO16)
								lo &= ~1;

							sym_addr =
								(hi << 16)
								+ lo;
						}
					} else
						goto bad_resolved_reloc;
					break;

				case R_V850_LO16:
					/* See if this is actually the
					   2nd half of a pair.  */
					if (p > relpp
					    && (p[-1]->howto->type
						== R_V850_HI16_S)
					    && (p[-1]->sym_ptr_ptr
						== p[0]->sym_ptr_ptr)
					    && (p[-1]->addend == p[0]->addend))
						break; /* not an error */
					else
						goto bad_resolved_reloc;

				case R_V850_HI16:
					goto bad_resolved_reloc;
				default:
					goto good_32bit_resolved_reloc;
#elif defined(TARGET_arm)
				case R_ARM_ABS32:
					relocation_needed = 1;
					break;
				case R_ARM_REL32:
				case R_ARM_THM_PC11:
				case R_ARM_THM_PC22:
					relocation_needed = 0;
					break;
				default:
					goto bad_resolved_reloc;
#elif defined(TARGET_m68k)
				case R_68K_32:
					goto good_32bit_resolved_reloc;
				case R_68K_PC32:
				case R_68K_PC16:
					/* The linker has already resolved
					   PC relocs for us.  In PIC links,
					   the symbol must be in the data
					   segment.  */
				case R_68K_NONE:
					continue;
				default:
					goto bad_resolved_reloc;
#else
				default:
					/* The default is to assume that the
					   relocation is relative and has
					   already been fixed up by the
					   linker (perhaps we ought to make
					   give an error by default, and
					   require `safe' relocations to be
					   enumberated explicitly?).  */
					goto good_32bit_resolved_reloc;
#endif
				good_32bit_resolved_reloc:
					if (bfd_big_endian (abs_bfd))
						sym_addr =
							(r_mem[0] << 24)
							+ (r_mem[1] << 16)
							+ (r_mem[2] << 8) 
							+ r_mem[3];
					else
						sym_addr =
							r_mem[0]
							+ (r_mem[1] << 8)
							+ (r_mem[2] << 16)
							+ (r_mem[3] << 24);
					relocation_needed = 1;
					break;

				bad_resolved_reloc:
					printf("ERROR: reloc type %s unsupported in this context\n",
					       q->howto->name);
					bad_relocs++;
					break;
				}
			} else {
				/* Calculate the sym address ourselves.  */
				sym_reloc_size = bfd_get_reloc_size(q->howto);

#if !defined(TARGET_h8300) && !defined(TARGET_e1) && !defined(TARGET_bfin) && !defined(TARGET_m68k)
				if (sym_reloc_size != 4) {
					printf("ERROR: bad reloc type %d size=%d for symbol=%s\n",
							(*p)->howto->type, sym_reloc_size, sym_name);
					bad_relocs++;
					rc = -1;
					continue;
				}
#endif

				switch ((*p)->howto->type) {

#if defined(TARGET_m68k)
				case R_68K_32:
					relocation_needed = 1;
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					break;
				case R_68K_PC16:
				case R_68K_PC32:
					sym_vma = 0;
					sym_addr += sym_vma + q->addend;
					sym_addr -= q->address;
					break;
#endif

#if defined(TARGET_arm)
				case R_ARM_ABS32:
					relocation_needed = 1;
					if (verbose)
						fprintf(stderr,
							"%s vma=0x%x, value=0x%x, address=0x%x "
							"sym_addr=0x%x rs=0x%x, opcode=0x%x\n",
							"ABS32",
							sym_vma, (*(q->sym_ptr_ptr))->value,
							q->address, sym_addr,
							(*p)->howto->rightshift,
							*(unsigned long *)r_mem);
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					break;
				case R_ARM_GOT32:
				case R_ARM_GOTPC:
					/* Should be fine as is */
					break;
				case R_ARM_PLT32:
					if (verbose)
						fprintf(stderr,
							"%s vma=0x%x, value=0x%x, address=0x%x "
							"sym_addr=0x%x rs=0x%x, opcode=0x%x\n",
							"PLT32",
							sym_vma, (*(q->sym_ptr_ptr))->value,
							q->address, sym_addr,
							(*p)->howto->rightshift,
							*(unsigned long *)r_mem);
				case R_ARM_PC24:
					sym_vma = 0;
					sym_addr = (sym_addr-q->address)>>(*p)->howto->rightshift;
					break;
#endif

#ifdef TARGET_v850
				case R_V850_32:
					relocation_needed = 1;
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					break;
#if defined(R_V850_ZDA_16_16_OFFSET) || defined(R_V850_ZDA_16_16_SPLIT_OFFSET)
#ifdef R_V850_ZDA_16_16_OFFSET
				case R_V850_ZDA_16_16_OFFSET:
#endif
#ifdef R_V850_ZDA_16_16_SPLIT_OFFSET
				case R_V850_ZDA_16_16_SPLIT_OFFSET:
#endif
					/* Can't support zero-relocations.  */
					printf ("ERROR: %s+0x%x: zero relocations not supported\n",
							sym_name, q->addend);
					continue;
#endif /* R_V850_ZDA_16_16_OFFSET || R_V850_ZDA_16_16_SPLIT_OFFSET */
#endif /* TARGET_v850 */

#ifdef TARGET_h8300
				case R_H8_DIR24R8:
					if (sym_reloc_size != 4) {
						printf("R_H8_DIR24R8 size %d\n", sym_reloc_size);
						bad_relocs++;
						continue;
					}
					relocation_needed = 1;
					sym_addr = (*(q->sym_ptr_ptr))->value;
					q->address -= 1;
					r_mem -= 1; /* tracks q->address */
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					sym_addr |= (*(unsigned char *)r_mem<<24);
					break;
				case R_H8_DIR24A8:
					if (sym_reloc_size != 4) {
						printf("R_H8_DIR24A8 size %d\n", sym_reloc_size);
						bad_relocs++;
						continue;
					}
					/* Absolute symbol done not relocation */
					relocation_needed = !bfd_is_abs_section(sym_section);
					sym_addr = (*(q->sym_ptr_ptr))->value;
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					break;
				case R_H8_DIR32:
				case R_H8_DIR32A16: /* currently 32,  could be made 16 */
					if (sym_reloc_size != 4) {
						printf("R_H8_DIR32 size %d\n", sym_reloc_size);
						bad_relocs++;
						continue;
					}
					relocation_needed = 1;
					sym_addr = (*(q->sym_ptr_ptr))->value;
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					break;
				case R_H8_PCREL16:
					sym_vma = 0;
					sym_addr = (*(q->sym_ptr_ptr))->value;
					sym_addr += sym_vma + q->addend;
					sym_addr -= (q->address + 2);
					if (bfd_big_endian(abs_bfd))
					*(unsigned short *)r_mem =
						bfd_big_endian(abs_bfd) ? htons(sym_addr) : sym_addr;
					continue;
				case R_H8_PCREL8:
					sym_vma = 0;
					sym_addr = (*(q->sym_ptr_ptr))->value;
					sym_addr += sym_vma + q->addend;
					sym_addr -= (q->address + 1);
					*(unsigned char *)r_mem = sym_addr;
					continue;
#endif

#ifdef TARGET_microblaze
				case R_MICROBLAZE_64:
		/* The symbol is split over two consecutive instructions.  
		   Flag this to the flat loader by setting the high bit of 
		   the relocation symbol. */
				{
					unsigned char *p = r_mem;
					unsigned long offset;
					pflags=0x80000000;

					/* work out the relocation */
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					/* grab any offset from the text */
					offset = (p[2]<<24) + (p[3] << 16) + (p[6] << 8) + (p[7]);
					/* Update the address */
					sym_addr += offset + sym_vma + q->addend;
					/* Write relocated pointer back */
					p[2] = (sym_addr >> 24) & 0xff;
					p[3] = (sym_addr >> 16) & 0xff;
					p[6] = (sym_addr >>  8) & 0xff;
					p[7] =  sym_addr        & 0xff;

					/* create a new reloc entry */
					flat_relocs = realloc(flat_relocs,
						(flat_reloc_count + 1) * sizeof(uint32_t));
					flat_relocs[flat_reloc_count] = pflags | (section_vma + q->address);
					flat_reloc_count++;
					relocation_needed = 0;
					pflags = 0;
			sprintf(&addstr[0], "+0x%x", sym_addr - (*(q->sym_ptr_ptr))->value -
					 bfd_section_vma(abs_bfd, sym_section));
			if (verbose)
				printf("  RELOC[%d]: offset=0x%x symbol=%s%s "
					"section=%s size=%d "
					"fixup=0x%x (reloc=0x%x)\n", flat_reloc_count,
					q->address, sym_name, addstr,
					section_name, sym_reloc_size,
					sym_addr, section_vma + q->address);
			if (verbose)
				printf("reloc[%d] = 0x%x\n", flat_reloc_count,
					 section_vma + q->address);

					continue;
				}
				case R_MICROBLAZE_32:
				{	
					unsigned char *p = r_mem;
					unsigned long offset;

					/* grab any offset from the text */
					offset = (p[0]<<24) + (p[1] << 16) + (p[2] << 8) + (p[3]);
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					/* This is a horrible kludge.  For some
					   reason, *sometimes* the offset is in
					   both addend and the code.  Detect
					   it, and cancel the effect.  Otherwise
					   the offset gets added twice - ouch.
					   There should be a better test
					   for this condition, based on the
					   BFD data structures */
					if(offset==q->addend)
						offset=0;

					sym_addr += offset + sym_vma + q->addend;
					relocation_needed = 1;
					break;
				}
				case R_MICROBLAZE_64_PCREL:
					sym_vma = 0;
					//sym_addr = (*(q->sym_ptr_ptr))->value;
					sym_addr += sym_vma + q->addend;
					sym_addr -= (q->address + 4);
					sym_addr = htonl(sym_addr);
					/* insert 16 MSB */
					* ((unsigned short *) (r_mem+2)) |= (sym_addr) & 0xFFFF;
					/* then 16 LSB */
					* ((unsigned short *) (r_mem+6)) |= (sym_addr >> 16) & 0xFFFF;
					/* We've done all the work, so continue
					   to next reloc instead of break */
					continue;

#endif /* TARGET_microblaze */
					
#ifdef TARGET_nios2
#define  htoniosl(x)	(x)
#define  niostohl(x)	(x)
				case R_NIOS2_BFD_RELOC_32:
					relocation_needed = 1;
					pflags = (FLAT_NIOS2_R_32 << 28);
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					/* modify target, in target order */
					*(unsigned long *)r_mem = htoniosl(sym_addr);
					break;
				case R_NIOS2_CALL26:
				{
					unsigned long exist_val;
					relocation_needed = 1;
					pflags = (FLAT_NIOS2_R_CALL26 << 28);
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					
					/* modify target, in target order */
					// exist_val = niostohl(*(unsigned long *)r_mem);
					exist_val = ((sym_addr >> 2) << 6);
					*(unsigned long *)r_mem = htoniosl(exist_val);
					break;
				}
				case R_NIOS2_HIADJ16:
				case R_NIOS2_HI16:
				{
					unsigned long exist_val;
					int r2_type;
					/* handle the adjacent HI/LO pairs */
					if (relcount == 0)
						r2_type = R_NIOS2_NONE;
					else
						r2_type = p[1]->howto->type;
					if ((r2_type == R_NIOS2_LO16)
					    && (p[0]->sym_ptr_ptr == p[1]->sym_ptr_ptr)
					    && (p[0]->addend == p[1]->addend)) 
					    {
							unsigned char * r2_mem = sectionp + p[1]->address;
							if (p[1]->address - q->address!=4)
								printf("Err: HI/LO not adjacent %d\n", p[1]->address - q->address);
							relocation_needed = 1;
							pflags = (q->howto->type == R_NIOS2_HIADJ16) 
								? FLAT_NIOS2_R_HIADJ_LO : FLAT_NIOS2_R_HI_LO;
							pflags <<= 28;
						
							sym_vma = bfd_section_vma(abs_bfd, sym_section);
							sym_addr += sym_vma + q->addend;

							/* modify high 16 bits, in target order */
							exist_val = niostohl(*(unsigned long *)r_mem);
							exist_val =  ((exist_val >> 22) << 22) | (exist_val & 0x3f);
							if (q->howto->type == R_NIOS2_HIADJ16)
								exist_val |= ((((sym_addr >> 16) + ((sym_addr >> 15) & 1)) & 0xFFFF) << 6);
							else
								exist_val |= (((sym_addr >> 16) & 0xFFFF) << 6);
							*(unsigned long *)r_mem = htoniosl(exist_val);

							/* modify low 16 bits, in target order */
							exist_val = niostohl(*(unsigned long *)r2_mem);
							exist_val =  ((exist_val >> 22) << 22) | (exist_val & 0x3f);
							exist_val |= ((sym_addr & 0xFFFF) << 6);
							*(unsigned long *)r2_mem = htoniosl(exist_val);
						
						} else 
							goto NIOS2_RELOC_ERR;
					}
					break;

				case R_NIOS2_GPREL:
				{
					unsigned long exist_val, temp;
					//long gp = get_symbol_offset("_gp", sym_section, symbols, number_of_symbols);
					long gp = get_gp_value(symbols, number_of_symbols);
					if (gp == -1) {
						printf("Err: unresolved symbol _gp when relocating %s\n", sym_name);
						goto NIOS2_RELOC_ERR;
					}
					/* _gp holds a absolute value, otherwise the ld cannot generate correct code */
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					//printf("sym=%x, %d, _gp=%x, %d\n", sym_addr+sym_vma, sym_addr+sym_vma, gp, gp);
					sym_addr += sym_vma + q->addend;
					sym_addr -= gp;
					//printf("sym - _gp=%x, %d\n", sym_addr, sym_addr);
					/* modify the target, in target order (little_endian) */
					exist_val = niostohl(*(unsigned long *)r_mem);
					temp = ((exist_val >> 6) & 0x3ff0000) | (sym_addr & 0xffff);
					temp <<= 6;
					temp |= (exist_val & 0x3f);
					*(unsigned long *)r_mem = htoniosl(temp);
					if (verbose)
						printf("omit: offset=0x%x symbol=%s%s "
								"section=%s size=%d "
								"fixup=0x%x (reloc=0x%x) GPREL\n", 
								q->address, sym_name, addstr,
								section_name, sym_reloc_size,
								sym_addr, section_vma + q->address);
					continue;
				}
				case R_NIOS2_PCREL16:
				{
					unsigned long exist_val;
					sym_vma = 0;
					sym_addr += sym_vma + q->addend;
					sym_addr -= (q->address + 4);
					/* modify the target, in target order (little_endian) */
					exist_val = niostohl(*(unsigned long *)r_mem);
					exist_val =  ((exist_val >> 22) << 22) | (exist_val & 0x3f);
					exist_val |= ((sym_addr & 0xFFFF) << 6);
					*(unsigned long *)r_mem = htoniosl(exist_val);
					if (verbose)
						printf("omit: offset=0x%x symbol=%s%s "
								"section=%s size=%d "
								"fixup=0x%x (reloc=0x%x) PCREL\n", 
								q->address, sym_name, addstr,
								section_name, sym_reloc_size,
								sym_addr, section_vma + q->address);
					continue;
				}

				case R_NIOS2_LO16:
					/* check if this is actually the 2nd half of a pair */
					if ((p > relpp)
						&& ((p[-1]->howto->type == R_NIOS2_HIADJ16) 
							|| (p[-1]->howto->type == R_NIOS2_HI16))
					    && (p[-1]->sym_ptr_ptr == p[0]->sym_ptr_ptr)
					    && (p[-1]->addend == p[0]->addend)) {
						if (verbose)
							printf("omit: offset=0x%x symbol=%s%s "
								"section=%s size=%d LO16\n", 
								q->address, sym_name, addstr,
								section_name, sym_reloc_size);
						continue;
					}

					/* error, fall through */

				case R_NIOS2_S16:
				case R_NIOS2_U16:
				case R_NIOS2_CACHE_OPX:
				case R_NIOS2_IMM5:
				case R_NIOS2_IMM6:
				case R_NIOS2_IMM8:
				case R_NIOS2_BFD_RELOC_16:
				case R_NIOS2_BFD_RELOC_8:
				case R_NIOS2_GNU_VTINHERIT:
				case R_NIOS2_GNU_VTENTRY:
				case R_NIOS2_UJMP:
				case R_NIOS2_CJMP:
				case R_NIOS2_CALLR:
NIOS2_RELOC_ERR:
					printf("Err: unexpected reloc type %s(%d)\n", q->howto->name, q->howto->type);
					bad_relocs++;
					continue;
#endif /* TARGET_nios2 */

#ifdef TARGET_sparc
				case R_SPARC_32:
				case R_SPARC_UA32:
					relocation_needed = 1;
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					break;
				case R_SPARC_PC22:
					sym_vma = 0;
					sym_addr += sym_vma + q->addend;
					sym_addr -= q->address;
					break;
				case R_SPARC_WDISP30:
					sym_addr = (((*(q->sym_ptr_ptr))->value-
						q->address) >> 2) & 0x3fffffff;
					sym_addr |= (
						ntohl(*(unsigned long *)r_mem)
						& 0xc0000000
						);
					break;
				case R_SPARC_HI22:
					relocation_needed = 1;
					pflags = 0x80000000;
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					sym_addr |= (
						htonl(*(unsigned long *)r_mem)
						& 0xffc00000
						);
					break;
				case R_SPARC_LO10:
					relocation_needed = 1;
					pflags = 0x40000000;
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					sym_addr &= 0x000003ff;
					sym_addr |= (
						htonl(*(unsigned long *)r_mem)
						& 0xfffffc00
						);
					break;
#endif /* TARGET_sparc */

#ifdef TARGET_bfin
				case R_pcrel12_jump:
				case R_pcrel12_jump_s:
				case R_pcrel24:
				case R_pcrel24_jump_l:
				case R_pcrel24_jump_x:
				case R_pcrel24_call_x:
				case R_pcrel10:
				case R_pcrel11:
				case R_pcrel5m2:
				  sym_addr += q->addend;// get the symbol addr
				  sym_vma = bfd_section_vma(abs_bfd, sym_section);
				  sym_addr -= q->address; // make it PC relative 
				  // implicitly assumes code section and symbol section are same
				  break;
				case R_got:
				    /* Ignore these.  */
				    break;

				case R_rimm16:
				    sym_addr += q->addend;
				    if(weak_und_symbol(sym_section->name, (*(q->sym_ptr_ptr))))
					continue;
				    if(0xFFFF0000 & sym_addr){
					fprintf (stderr, "Relocation overflow for rN = %s\n",sym_name);
					bad_relocs++;
				    }
				    flat_relocs = (uint32_t *)
					(realloc (flat_relocs, (flat_reloc_count + 1) * sizeof (uint32_t)));
				    if (bfin_set_reloc (flat_relocs + flat_reloc_count, 
							sym_section->name, sym_name,
							(*(q->sym_ptr_ptr)),
							0, FLAT_RELOC_PART_LO, 
							section_vma + q->address))
					bad_relocs++;
				    flat_reloc_count++;
				    break;
				    
				case R_luimm16:
				case R_huimm16:
				{
				    unsigned int sp;
				    unsigned int reloc_count_incr;
				    unsigned int hi_lo;

				    if (q->howto->type == R_luimm16)
					hi_lo = FLAT_RELOC_PART_LO;
				    else
					hi_lo = FLAT_RELOC_PART_HI;
				
				    sym_addr += q->addend;

				    flat_relocs = (uint32_t *)
					(realloc (flat_relocs, (flat_reloc_count + 2) * sizeof (uint32_t)));
				    reloc_count_incr = 1;
				    if (weak_und_symbol (sym_section->name, (*(q->sym_ptr_ptr))))
					continue;
				    if (0xFFFF0000 & sym_addr) {
					/* value is > 16 bits - use an extra field */
					/* see if we have already output that symbol */
					/* reloc may be addend from symbol and       */
					/* we can only store 16 bit offsets	     */
					sp = 1;
					if ((*(q->sym_ptr_ptr))->udata.i == 0
					    || flat_relocs[(*(q->sym_ptr_ptr))->udata.i] != sym_addr
					    || ((*(q->sym_ptr_ptr))->udata.i & 0xFFFF0000))
					{
					    reloc_count_incr = 2;
					    flat_relocs[flat_reloc_count + 1] = sym_addr;
					    (*(q->sym_ptr_ptr))->udata.i = flat_reloc_count + 1;
					    sym_addr = 0; // indication to loader to read next
					} else{
					    sym_addr = (*(q->sym_ptr_ptr))->udata.i;
					}
				    } else {
					sp = 0;
				    }

				    if (bfin_set_reloc (flat_relocs + flat_reloc_count, 
							sym_section->name, sym_name,
							(*(q->sym_ptr_ptr)),
							sp, hi_lo,
							section_vma + q->address))
					bad_relocs++;
				    flat_reloc_count += reloc_count_incr;
				    break;
				}
				case R_byte4_data:
				    sym_addr += q->addend;

				    if (weak_und_symbol (sym_section->name, *q->sym_ptr_ptr))
					continue;

				    flat_relocs = (uint32_t *)
					(realloc (flat_relocs, (flat_reloc_count + 1) * sizeof (uint32_t)));
				    if (bfin_set_reloc (flat_relocs + flat_reloc_count, 
							sym_section->name, sym_name,
							(*(q->sym_ptr_ptr)),
							2, FLAT_RELOC_PART_LO, 
							section_vma + q->address))
					bad_relocs++;

				    flat_reloc_count++;
				    break;

#endif //TARGET_bfin

#ifdef TARGET_sh
				case R_SH_DIR32:
					relocation_needed = 1;
					sym_vma = bfd_section_vma(abs_bfd, sym_section);
					sym_addr += sym_vma + q->addend;
					break;
				case R_SH_REL32:
					sym_vma = 0;
					sym_addr += sym_vma + q->addend;
					sym_addr -= q->address;
					break;
#endif /* TARGET_sh */

#ifdef TARGET_e1
#define  htoe1l(x)              htonl(x)
					
#if 0 
#define  DEBUG_E1
#endif

#ifdef   DEBUG_E1
#define  DBG_E1                 printf
#else
#define  DBG_E1(x, ...  )
#endif

#define _32BITS_RELOC 0x00000000
#define _30BITS_RELOC 0x80000000
#define _28BITS_RELOC 0x40000000
					{
				char *p;
				unsigned long   sec_vma, exist_val, S;
				case R_E1_CONST31:
						relocation_needed = 1;
						DBG_E1("Handling Reloc <CONST31>\n");
						sec_vma = bfd_section_vma(abs_bfd, sym_section);
						DBG_E1("sec_vma : [0x%x], sym_addr : [0x%x], q->address : [0x%x]\n",
										sec_vma, sym_addr, q->address);
						sym_addr = sec_vma + sym_addr;
						exist_val = *(unsigned long*)((unsigned long)sectionp + q->address + 2);        
						DBG_E1("Orig:exist_val : [0x%08x]\n", exist_val);
						exist_val = htoe1l(exist_val);
						DBG_E1("HtoBE:exist_val : [0x%08x]\n", exist_val);
						sym_addr += exist_val;
						pflags = _30BITS_RELOC;
						break;
				case R_E1_CONST31_PCREL:
						relocation_needed = 0;
						DBG_E1("Handling Reloc <CONST31_PCREL>\n");
						DBG_E1("DONT RELOCATE AT LOADING\n");
						sec_vma = bfd_section_vma(abs_bfd, sym_section);
						DBG_E1("sec_vma : [0x%x], sym_addr : [0x%x], q->address : [0x%x]\n",
										sec_vma, sym_addr, q->address);
						sym_addr =  sec_vma + sym_addr;
						DBG_E1("sym_addr =  sec_vma + sym_addr : [0x%x]\n", sym_addr );

						DBG_E1("q->address : 0x%x, section_vma : 0x%x\n", q->address,
																		section_vma );
						q->address = q->address + section_vma;
						DBG_E1("q->address += section_vma : 0x%x\n", q->address );

						if( (sym_addr = (sym_addr - q->address - 6)) < 0 )
								DBG_E1("NEGATIVE OFFSET in PC Relative instruction\n");
						DBG_E1( "sym_addr := sym_addr - q->address  - "
								"sizeof(CONST31_PCREL): [0x%x]\n",
								sym_addr );
						exist_val = *(unsigned long*)((unsigned long)sectionp + q->address + 2);              
						DBG_E1("Orig:exist_val : [0x%08x]\n", exist_val);
						exist_val = htoe1l(exist_val);
						DBG_E1("HtoBE:exist_val : [0x%08x]\n", exist_val);
						sym_addr |= exist_val;
						DBG_E1("sym_addr |=  exist_val) : [0x%x]\n", sym_addr );
						break;
				case R_E1_DIS29W_PCREL:
						relocation_needed = 0;
						DBG_E1("Handling Reloc <DIS29W_PCREL>\n");
						DBG_E1("DONT RELOCATE AT LOADING\n");
						sec_vma = bfd_section_vma(abs_bfd, sym_section);
						DBG_E1("sec_vma : [0x%x], sym_addr : [0x%x], q->address : [0x%x]\n",
										sec_vma, sym_addr, q->address);
						sym_addr =  sec_vma + sym_addr;
						DBG_E1("sym_addr =  sec_vma + sym_addr : [0x%x]\n", sym_addr );

						DBG_E1("q->address : 0x%x, section_vma : 0x%x\n", q->address,
																		section_vma );
						q->address = q->address + section_vma;
						DBG_E1("q->address += section_vma : 0x%x\n", q->address );

						if( (sym_addr = (sym_addr - q->address - 6)) < 0 )
								DBG_E1("NEGATIVE OFFSET in PC Relative instruction\n");
						DBG_E1( "sym_addr := sym_addr - q->address  - "
								"sizeof(CONST31_PCREL): [0x%x]\n",
								sym_addr );
						DBG_E1("sectionp:[0x%x], q->address:[0x%x]\n", sectionp, q->address );
						exist_val = *(unsigned long*)((unsigned long)sectionp + q->address + 2);       
						DBG_E1("Original:exist_val : [0x%08x]\n",exist_val);
						exist_val = htoe1l(exist_val);
						DBG_E1("HtoBE:exist_val : [0x%08x]\n",exist_val);
						sym_addr += exist_val;
						break;
				case R_E1_DIS29W:
						DBG_E1("Handling Reloc <DIS29W>\n");
						goto DIS29_RELOCATION;
				case R_E1_DIS29H:
						DBG_E1("Handling Reloc <DIS29H>\n");
						goto DIS29_RELOCATION;
				case R_E1_DIS29B:
						DBG_E1("Handling Reloc <DIS29B>\n");
DIS29_RELOCATION:
						relocation_needed = 1;
						sec_vma = bfd_section_vma(abs_bfd, sym_section);
						DBG_E1("sec_vma : [0x%x], sym_addr : [0x%08x]\n",
										sec_vma, sym_addr);
						sym_addr =  sec_vma + sym_addr;
						DBG_E1("sym_addr =  sec_vma + sym_addr : [0x%08x]\n", sym_addr);
						exist_val = *(unsigned long*)((unsigned long)sectionp + q->address + 2);                
						DBG_E1("Orig:exist_val : [0x%08x]\n", exist_val);
						exist_val = htoe1l(exist_val);
						DBG_E1("HtoBE:exist_val : [0x%08x]\n", exist_val);
						sym_addr +=  exist_val;
						DBG_E1("sym_addr +=  exist_val : [0x%08x]\n", sym_addr);
						pflags = _28BITS_RELOC;
						break;
				case R_E1_IMM32_PCREL:
						relocation_needed = 0;
						DBG_E1("Handling Reloc <IMM32_PCREL>\n");
						DBG_E1("DONT RELOCATE AT LOADING\n");
						sec_vma = bfd_section_vma(abs_bfd, sym_section);
						DBG_E1("sec_vma : [0x%x], sym_addr : [0x%x]\n",
										sec_vma, sym_addr);
						sym_addr =  sec_vma + sym_addr;

						DBG_E1("sym_addr =  sec_vma + sym_addr : [0x%x]\n", sym_addr );
						DBG_E1("q->address : 0x%x, section_vma : 0x%x\n", q->address,
																		section_vma );
						q->address = q->address + section_vma;
						DBG_E1("q->address += section_vma : 0x%x\n", q->address );

						if( (sym_addr = (sym_addr - q->address - 6 )) < 0 )
								DBG_E1("NEGATIVE OFFSET in PC Relative instruction\n");
						DBG_E1( "sym_addr := sym_addr - q->address  - "
								"sizeof(CONST31_PCREL): [0x%x]\n",
								sym_addr );
						DBG_E1("sectionp:[0x%x], q->address:[0x%x]\n", sectionp, q->address );
						exist_val = *(unsigned long*)((unsigned long)sectionp + q->address + 2);                 
 						DBG_E1("Original:exist_val : [0x%08x]\n",exist_val);
						exist_val = htoe1l(exist_val);
						DBG_E1("HtoBE:exist_val : [0x%08x]\n",exist_val);
						sym_addr += exist_val;
						break;
				case R_E1_IMM32:
						relocation_needed = 1;
						DBG_E1("Handling Reloc <IMM32>\n");
						sec_vma = bfd_section_vma(abs_bfd, sym_section);
						DBG_E1("sec_vma : [0x%x], sym_addr : [0x%x]\n",
										sec_vma, sym_addr);
						sym_addr =  sec_vma + sym_addr;
						DBG_E1("sym_addr =  sec_vma + sym_addr : [0x%x]\n", sym_addr );
						DBG_E1("sectionp:[0x%x], q->address:[0x%x]\n", sectionp, q->address );
						exist_val = *(unsigned long*)((unsigned long)sectionp + q->address + 2);                     
	 					DBG_E1("Original:exist_val : [0x%08x]\n",exist_val);
						exist_val = htoe1l(exist_val);
						DBG_E1("HtoBE:exist_val : [0x%08x]\n",exist_val);
						sym_addr += exist_val;
						pflags = _32BITS_RELOC;
						break;
				case R_E1_WORD:
						relocation_needed = 1;
						DBG_E1("Handling Reloc <WORD>\n");
						sec_vma = bfd_section_vma(abs_bfd, sym_section);
						DBG_E1("sec_vma : [0x%x], sym_addr : [0x%x]\n",
										sec_vma, sym_addr);
						sym_addr =  sec_vma + sym_addr;
						DBG_E1("sym_addr =  sec_vma + sym_addr : [0x%x]\n", sym_addr );
						exist_val = *(unsigned long*)((unsigned long)sectionp + q->address );
						DBG_E1("Orig:exist_val : [0x%08x]\n", exist_val);
						exist_val = htoe1l(exist_val);
						DBG_E1("HtoBE:exist_val : [0x%08x]\n", exist_val);
						sym_addr +=  exist_val;
						DBG_E1("sym_addr +=  exist_val : [0x%08x]\n", sym_addr);
						pflags = _32BITS_RELOC;
						break;
				}
#undef _32BITS_RELOC
#undef _30BITS_RELOC
#undef _28BITS_RELOC
#endif
				default:
					/* missing support for other types of relocs */
					printf("ERROR: bad reloc type %d\n", (*p)->howto->type);
					bad_relocs++;
					continue;
				}
			}

			sprintf(&addstr[0], "+0x%x", sym_addr - (*(q->sym_ptr_ptr))->value -
					 bfd_section_vma(abs_bfd, sym_section));


			/*
			 * for full elf relocation we have to write back the
			 * start_code relative value to use.
			 */
			if (!pic_with_got) {
#if defined(TARGET_arm)
				union {
					unsigned char c[4];
					unsigned long l;
				} tmp;
				long hl;
				int i0, i1, i2, i3;

				/*
				 * horrible nasty hack to support different endianess
				 */
				if (!bfd_big_endian(abs_bfd)) {
					i0 = 0;
					i1 = 1;
					i2 = 2;
					i3 = 3;
				} else {
					i0 = 3;
					i1 = 2;
					i2 = 1;
					i3 = 0;
				}

				tmp.l = *(unsigned long *)r_mem;
				hl = tmp.c[i0] | (tmp.c[i1] << 8) | (tmp.c[i2] << 16);
				if (use_resolved ||
					(((*p)->howto->type != R_ARM_PC24) &&
					((*p)->howto->type != R_ARM_PLT32)))
					hl |= (tmp.c[i3] << 24);
				else if (tmp.c[i2] & 0x80)
					hl |= 0xff000000; /* sign extend */
				if (!use_resolved)
					hl += sym_addr;
				tmp.c[i0] = hl & 0xff;
				tmp.c[i1] = (hl >> 8) & 0xff;
				tmp.c[i2] = (hl >> 16) & 0xff;
				if (use_resolved ||
					(((*p)->howto->type != R_ARM_PC24) &&
					((*p)->howto->type != R_ARM_PLT32)))
					tmp.c[i3] = (hl >> 24) & 0xff;
				if ((*p)->howto->type == R_ARM_ABS32)
					*(unsigned long *)r_mem = htonl(hl);
				else
					*(unsigned long *)r_mem = tmp.l;

#elif defined(TARGET_bfin)
				if ((*p)->howto->type == R_pcrel24
				    || (*p)->howto->type == R_pcrel24_jump_l
				    || (*p)->howto->type == R_pcrel24_jump_x
				    || (*p)->howto->type == R_pcrel24_call_x)
				{
				    sym_addr += 2*-1*PCREL24_MAGIC_OFFSET;
				    *((unsigned short *)(sectionp + q->address) + 1 + PCREL24_MAGIC_OFFSET)
					= (sym_addr >> 1) & 0xffff;
				    *((unsigned short *)(sectionp + q->address) + PCREL24_MAGIC_OFFSET)
					= (0xff00 & *((unsigned short *) (sectionp + q->address) + PCREL24_MAGIC_OFFSET)
					   | ((sym_addr >> 17) & 0xff));
				} else if ((*p)->howto->type == R_byte4_data) {
				    *((uint32_t *)(sectionp + q->address)) = sym_addr;
				} else if ((*p)->howto->type == R_pcrel12_jump
					   || (*p)->howto->type == R_pcrel12_jump_s) {
				    *((unsigned short *)(sectionp + q->address))
					= (0xf000 & *((unsigned short *)(sectionp + q->address))
					   | ((sym_addr >> 1) & 0xfff));
				} else if ((*p)->howto->type == R_pcrel10) {
				    *((unsigned short *)(sectionp + q->address))
					= (~0x3ff & *((unsigned short *)(sectionp + q->address))
					   | ((sym_addr >> 1) & 0x3ff));
				} else if ((*p)->howto->type == R_rimm16
					   || (*p)->howto->type == R_huimm16
					   || (*p)->howto->type == R_luimm16) {
				    /* for l and h we set the lower 16 bits which is only when it will be used */
				    *((unsigned short *) (sectionp + q->address)) = (unsigned short) sym_addr;
				} else if ((*p)->howto->type == R_pcrel5m2) {
				    *((unsigned short *)(sectionp + q->address))
					= (0xfff0 & *((unsigned short *)(sectionp + q->address))
					   | ((sym_addr >> 1) & 0xf));
				} else if ((*p)->howto->type == R_pcrel11){
				    *((unsigned short *)(sectionp + q->address))
					= (0xfc00 & *((unsigned short *)(sectionp + q->address))
					   | ((sym_addr >> 1) & 0x3ff));
				} else if (0xE0 <= (*p)->howto->type && 0xF3 >= (*p)->howto->type) {
				    //arith relocs dont generate a real relocation
				} else {
				    printf("Blackfin relocation fail for reloc type: 0x%x\n", (*p)->howto->type);
				}
#elif defined(TARGET_e1)
#define OPCODE_SIZE 2           /* Add 2 bytes, counting the opcode size*/
				switch ((*p)->howto->type) {
				case R_E1_CONST31:
				case R_E1_CONST31_PCREL:
				case R_E1_DIS29W_PCREL:
				case R_E1_DIS29W:
				case R_E1_DIS29H:
				case R_E1_DIS29B:
				case R_E1_IMM32_PCREL:
				case R_E1_IMM32:
						DBG_E1("In addr + 2:[0x%x] <- write [0x%x]\n",
								(sectionp + q->address + 2), sym_addr );
						*((unsigned long *) (sectionp + q->address + OPCODE_SIZE)) =
						htonl(sym_addr);
				break;
				case R_E1_WORD:
						DBG_E1("In addr : [0x%x] <- write [0x%x]\n",
								(sectionp + q->address), sym_addr );
						*((unsigned long *) (sectionp + q->address )) = htonl(sym_addr);
				break;
				default:
						printf("ERROR:Unhandled Relocation. Exiting...\n");
						exit(0);
				break;
				}
#else /* ! TARGET_arm && ! TARGET_e1 */

				switch (q->howto->type) {
#ifdef TARGET_v850
				case R_V850_HI16_S:
				case R_V850_HI16:
				case R_V850_LO16:
					/* Do nothing -- for cases we handle,
					   the bits produced by the linker are
					   what we want in the final flat file
					   (and other cases are errors).  Note
					   that unlike most relocated values,
					   it is stored in little-endian order,
					   but this is necessary to avoid
					   trashing the low-bit, and the float
					   loaders knows about it.  */
					break;
#endif /* TARGET_V850 */

#ifdef TARGET_nios2
				case R_NIOS2_BFD_RELOC_32:
				case R_NIOS2_CALL26:
				case R_NIOS2_HIADJ16:
				case R_NIOS2_HI16:
					/* do nothing */
					break;
#endif /* TARGET_nios2 */

#if defined(TARGET_m68k)
				case R_68K_PC16:
					if (sym_addr < -0x8000 || sym_addr > 0x7fff) {
						fprintf (stderr, "Relocation overflow for R_68K_PC16 relocation against %s\n", sym_name);
						bad_relocs++;
					} else {
						r_mem[0] = (sym_addr >>  8) & 0xff;
						r_mem[1] =  sym_addr        & 0xff;
					}
					break;
#endif

				default:
					/* The alignment of the build host
					   might be stricter than that of the
					   target, so be careful.  We store in
					   network byte order. */
					r_mem[0] = (sym_addr >> 24) & 0xff;
					r_mem[1] = (sym_addr >> 16) & 0xff;
					r_mem[2] = (sym_addr >>  8) & 0xff;
					r_mem[3] =  sym_addr        & 0xff;
				}
#endif /* !TARGET_arm */
			}

#ifdef TARGET_bfin
			else {
			    if ((*p)->howto->type == R_rimm16
				|| (*p)->howto->type == R_huimm16
				|| (*p)->howto->type == R_luimm16)
			    {
				/* for l and h we set the lower 16 bits which is only when it will be used */
				*((unsigned short *) (sectionp + q->address)) = (unsigned short) sym_addr;
			    } else if ((*p)->howto->type == R_byte4_data) {
				*((uint32_t *)(sectionp + q->address)) = sym_addr;
			    }
			}
#endif
			if (verbose)
				printf("  RELOC[%d]: offset=0x%x symbol=%s%s "
					"section=%s size=%d "
					"fixup=0x%x (reloc=0x%x)\n", flat_reloc_count,
					q->address, sym_name, addstr,
					section_name, sym_reloc_size,
					sym_addr, section_vma + q->address);

			/*
			 *	Create relocation entry (PC relative doesn't need this).
			 */
			if (relocation_needed) {
#ifndef TARGET_bfin
				flat_relocs = realloc(flat_relocs,
					(flat_reloc_count + 1) * sizeof(uint32_t));
#ifndef TARGET_e1
				flat_relocs[flat_reloc_count] = pflags |
					(section_vma + q->address);

				if (verbose)
					printf("reloc[%d] = 0x%x\n", flat_reloc_count,
							section_vma + q->address);
#else
				switch ((*p)->howto->type) {
				case R_E1_CONST31:
				case R_E1_CONST31_PCREL:
				case R_E1_DIS29W_PCREL:
				case R_E1_DIS29W:
				case R_E1_DIS29H:
				case R_E1_DIS29B:
				case R_E1_IMM32_PCREL:
				case R_E1_IMM32:
				flat_relocs[flat_reloc_count] = pflags |
						(section_vma + q->address + OPCODE_SIZE);
				if (verbose)
						printf("RELOCATION TABLE : reloc[%d] = [0x%x]\n", flat_reloc_count,
										 flat_relocs[flat_reloc_count] );
				break;
				case R_E1_WORD:
				flat_relocs[flat_reloc_count] = pflags |
						(section_vma + q->address);
				if (verbose)
						printf("RELOCATION TABLE : reloc[%d] = [0x%x]\n", flat_reloc_count,
										 flat_relocs[flat_reloc_count] );
				break;
				}
#endif
				flat_reloc_count++;
#endif
				relocation_needed = 0;
				pflags = 0;
			}

#if 0
printf("%s(%d): symbol name=%s address=0x%x section=%s -> RELOC=0x%x\n",
	__FILE__, __LINE__, sym_name, q->address, section_name,
	flat_relocs[flat_reloc_count]);
#endif
		}
	}
  }

  if (bad_relocs) {
	  printf("%d bad relocs\n", bad_relocs);
	  exit(1);
  }

  if (rc < 0)
	return(0);

  *n_relocs = flat_reloc_count;
  return flat_relocs;
}


static char * program;

static void usage(void)
{  
    fprintf(stderr, "Usage: %s [vrzd] [-p <abs-pic-file>] [-s stack-size] "
	"[-o <output-file>] <elf-file>\n\n"
	"       -v              : verbose operation\n"
	"       -r              : force load to RAM\n"
	"       -k              : enable kernel trace on load (for debug)\n"
	"       -z              : compress code/data/relocs\n"
	"       -d              : compress data/relocs\n"
	"       -a              : use existing symbol references\n"
	"                         instead of recalculating from\n"
	"                         relocation info\n"
        "       -R reloc-file   : read relocations from a separate file\n"
	"       -p abs-pic-file : GOT/PIC processing with files\n"
	"       -s stacksize    : set application stack size\n"
	"       -o output-file  : output file name\n\n",
	program);
	fprintf(stderr, "Compiled for " ARCH " architecture\n\n");
    exit(2);
}


/* Write NUM zeroes to STREAM.  */
static void write_zeroes (unsigned long num, FILE *stream)
{
  char zeroes[1024];
  if (num > 0) {
    /* It'd be nice if we could just use fseek, but that doesn't seem to
       work for stdio output files.  */
    memset(zeroes, 0x00, 1024);
    while (num > sizeof(zeroes)) {
      fwrite(zeroes, sizeof(zeroes), 1, stream);
      num -= sizeof(zeroes);
    }
    if (num > 0)
      fwrite(zeroes, num, 1, stream);
  }
}


int main(int argc, char *argv[])
{
  int fd;
  bfd *rel_bfd, *abs_bfd;
  asection *s;
  char *ofile=NULL, *pfile=NULL, *abs_file = NULL, *rel_file = NULL;
  char *fname = NULL;
  int opt;
  int i;
  int stack;
  char  cmd[1024];
  FILE *gf = NULL;

  asymbol **symbol_table;
  long number_of_symbols;

  unsigned long data_len = 0;
  unsigned long bss_len = 0;
  unsigned long text_len = 0;
  unsigned long reloc_len;

  unsigned long data_vma = ~0;
  unsigned long bss_vma = ~0;
  unsigned long text_vma = ~0;

  unsigned long text_offs;

  void *text;
  void *data;
  uint32_t *reloc;
  
  struct flat_hdr hdr;

  int gf_is_pipe = 0;

  program = argv[0];
  progname = argv[0];

  if (argc < 2)
  	usage();
  
  if (sizeof(hdr) != 64) {
    fprintf(stderr,
	    "Potential flat header incompatibility detected\n"
	    "header size should be 64 but is %d\n",
	    sizeof(hdr));
    exit(64);
  }

#ifndef TARGET_e1
  stack = 4096;
#else /* We need plenty of stack for both of them (Aggregate and Register) */
  stack = 0x2020;
#endif

  while ((opt = getopt(argc, argv, "avzdrkp:s:o:R:")) != -1) {
    switch (opt) {
    case 'v':
      verbose++;
      break;
    case 'r':
      load_to_ram++;
      break;
    case 'k':
      ktrace++;
      break;
    case 'z':
      compress = 1;
      break;
    case 'd':
      compress = 2;
      break;
    case 'p':
      pfile = optarg;
      break;
    case 'o':
      ofile = optarg;
      break;
    case 'a':
      use_resolved = 1;
      break;
    case 's':
      stack = atoi(optarg);
      break;
    case 'R':
      rel_file = optarg;
      break;
    default:
      fprintf(stderr, "%s Unknown option\n", argv[0]);
      usage();
      break;
    }
  }
  
  /*
   * if neither the -r or -p options was given,  default to
   * a RAM load as that is the only option that makes sense.
   */
  if (!load_to_ram && !pfile)
    load_to_ram = 1;

  filename = fname = argv[argc-1];

  if (pfile) {
    pic_with_got = 1;
    abs_file = pfile;
  } else
    abs_file = fname;

  if (! rel_file)
    rel_file = fname;

  if (!(rel_bfd = bfd_openr(rel_file, 0))) {
    fprintf(stderr, "Can't open %s\n", rel_file);
    exit(1);
  }

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

  if (abs_file == rel_file)
    abs_bfd = rel_bfd; /* one file does all */
  else {
    if (!(abs_bfd = bfd_openr(abs_file, 0))) {
      fprintf(stderr, "Can't open %s\n", abs_file);
      exit(1);
    }

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

  if (! (bfd_get_file_flags(rel_bfd) & HAS_RELOC)) {
    fprintf (stderr, "%s: Input file contains no relocation info\n", rel_file);
    exit (2);
  }

  if (use_resolved && !(bfd_get_file_flags(abs_bfd) & EXEC_P)) {
    /* `Absolute' file is not absolute, so neither are address
       contained therein.  */
    fprintf (stderr,
	     "%s: `-a' option specified with non-fully-resolved input file\n",
	     bfd_get_filename (abs_bfd));
    exit (2);
  }

  symbol_table = get_symbols(abs_bfd, &number_of_symbols);

  /* Group output sections into text, data, and bss, and calc their sizes.  */
  for (s = abs_bfd->sections; s != NULL; s = s->next) {
    unsigned long *vma, *len;
    bfd_size_type sec_size;
    bfd_vma sec_vma;

    if (s->flags & SEC_CODE) {
      vma = &text_vma;
      len = &text_len;
    } else if (s->flags & SEC_DATA) {
      vma = &data_vma;
      len = &data_len;
    } else if (s->flags & SEC_ALLOC) {
      vma = &bss_vma;
      len = &bss_len;
    } else
      continue;

    sec_size = bfd_section_size(abs_bfd, s);
    sec_vma  = bfd_section_vma(abs_bfd, s);

    if (sec_vma < *vma) {
      if (*len > 0)
	*len += sec_vma - *vma;
      else
	*len = sec_size;
      *vma = sec_vma;
    } else if (sec_vma + sec_size > *vma + *len)
      *len = sec_vma + sec_size - *vma;
  }

  if (text_len == 0) {
    fprintf (stderr, "%s: no .text section", abs_file);
    exit (2);
  }

  text = malloc(text_len);

  if (verbose)
    printf("TEXT -> vma=0x%x len=0x%x\n", text_vma, text_len);

  /* Read in all text sections.  */
  for (s = abs_bfd->sections; s != NULL; s = s->next)
    if (s->flags & SEC_CODE) 
      if (!bfd_get_section_contents(abs_bfd, s,
				   text + (s->vma - text_vma), 0,
				   bfd_section_size(abs_bfd, s)))
      {
	fprintf(stderr, "read error section %s\n", s->name);
	exit(2);
      }

  if (data_len == 0) {
    fprintf (stderr, "%s: no .data section", abs_file);
    exit (2);
  }
  data = malloc(data_len);

  if (verbose)
    printf("DATA -> vma=0x%x len=0x%x\n", data_vma, data_len);

  if ((text_vma + text_len) != data_vma) {
    if ((text_vma + text_len) > data_vma) {
      printf("ERROR: text=0x%x overlaps data=0x%x ?\n", text_len, data_vma);
      exit(1);
    }
    if (verbose)
      printf("WARNING: data=0x%x does not directly follow text=0x%x\n",
	  		data_vma, text_len);
    text_len = data_vma - text_vma;
  }

  /* Read in all data sections.  */
  for (s = abs_bfd->sections; s != NULL; s = s->next)
    if (s->flags & SEC_DATA) 
      if (!bfd_get_section_contents(abs_bfd, s,
				   data + (s->vma - data_vma), 0,
				   bfd_section_size(abs_bfd, s)))
      {
	fprintf(stderr, "read error section %s\n", s->name);
	exit(2);
      }

  /* Put common symbols in bss.  */
  bss_len += add_com_to_bss(symbol_table, number_of_symbols, bss_len);

  if (verbose)
    printf("BSS  -> vma=0x%x len=0x%x\n", bss_vma, bss_len);

  if ((data_vma + data_len) != bss_vma) {
    if ((data_vma + data_len) > bss_vma) {
      printf("ERROR: text=0x%x + data=0x%x overlaps bss=0x%x ?\n", text_len,
	  		data_len, bss_vma);
      exit(1);
    }
    if (verbose)
      printf("WARNING: bss=0x%x does not directly follow text=0x%x + data=0x%x(0x%x)\n",
      		bss_vma, text_len, data_len, text_len + data_len);
    data_len = bss_vma - data_vma;
  }

  reloc = output_relocs(abs_bfd, symbol_table, number_of_symbols, &reloc_len,
			text, text_len, text_vma, data, data_len, data_vma,
			rel_bfd);

  if (reloc == NULL)
    printf("No relocations in code!\n");

  text_offs = real_address_bits(text_vma);

  /* Fill in the binflt_flat header */
  memcpy(hdr.magic,"bFLT",4);
  hdr.rev         = htonl(FLAT_VERSION);
  hdr.entry       = htonl(sizeof(hdr) + bfd_get_start_address(abs_bfd));
  hdr.data_start  = htonl(sizeof(hdr) + text_offs + text_len);
  hdr.data_end    = htonl(sizeof(hdr) + text_offs + text_len +data_len);
  hdr.bss_end     = htonl(sizeof(hdr) + text_offs + text_len +data_len+bss_len);
  hdr.stack_size  = htonl(stack); /* FIXME */
  hdr.reloc_start = htonl(sizeof(hdr) + text_offs + text_len +data_len);
  hdr.reloc_count = htonl(reloc_len);
  hdr.flags       = htonl(0
	  | (load_to_ram ? FLAT_FLAG_RAM : 0)
	  | (ktrace ? FLAT_FLAG_KTRACE : 0)
	  | (pic_with_got ? FLAT_FLAG_GOTPIC : 0)
	  | (compress ? (compress == 2 ? FLAT_FLAG_GZDATA : FLAT_FLAG_GZIP) : 0)
	  );
  hdr.build_date = htonl((unsigned long)time(NULL));
  memset(hdr.filler, 0x00, sizeof(hdr.filler));

  for (i=0; i<reloc_len; i++) reloc[i] = htonl(reloc[i]);

  if (verbose) {
    printf("SIZE: .text=0x%04x, .data=0x%04x, .bss=0x%04x",
	text_len, data_len, bss_len);
    if (reloc)
      printf(", relocs=0x%04x", reloc_len);
    printf("\n");
  }
  
  if (!ofile) {
    ofile = malloc(strlen(fname) + 5 + 1); /* 5 to add suffix */
    strcpy(ofile, fname);
    strcat(ofile, ".bflt");
  }

  if ((fd = open (ofile, O_WRONLY|O_BINARY|O_CREAT|O_TRUNC, 0744)) < 0) {
    fprintf (stderr, "Can't open output file %s\n", ofile);
    exit(4);
  }

  write(fd, &hdr, sizeof(hdr));
  close(fd);

  /*
   * get the compression command ready
   */
  sprintf(cmd, "gzip -f -9 >> %s", ofile);

#define	START_COMPRESSOR do { \
		if (gf) \
			if (gf_is_pipe) \
				pclose(gf); \
			else \
				fclose(gf); \
		if (!(gf = popen(cmd, "w" BINARY_FILE_OPTS))) { \
			fprintf(stderr, "Can't run cmd %s\n", cmd); \
			exit(4); \
		} \
		gf_is_pipe = 1; \
	} while (0)

  gf = fopen(ofile, "ab");	/* Add 'b' to support non-posix (ie windows) */
  if (!gf) {
  	fprintf(stderr, "Can't open file %s for writing\n", ofile); \
	exit(4);
  }

  if (compress == 1)
  	START_COMPRESSOR;

  /* Fill in any hole at the beginning of the text segment.  */
  if (verbose)
	  printf("ZERO before text len=0x%x\n", text_offs);
  write_zeroes(text_offs, gf);

  /* Write the text segment.  */
  fwrite(text, text_len, 1, gf);

  if (compress == 2)
  	START_COMPRESSOR;

  /* Write the data segment.  */
  fwrite(data, data_len, 1, gf);

  if (reloc)
    fwrite(reloc, reloc_len * 4, 1, gf);

  if(gf_is_pipe)
    pclose(gf);
  else
  fclose(gf);

  exit(0);
}


/*
 * this __MUST__ be at the VERY end of the file - do NOT move!!
 *
 * Local Variables:
 * c-basic-offset: 4
 * tab-width: 8
 * end:
 * vi: tabstop=8 shiftwidth=4 textwidth=79 noexpandtab
 */