diff options
Diffstat (limited to 'package/elf2flt/src/elf2flt.c')
| -rw-r--r-- | package/elf2flt/src/elf2flt.c | 2152 |
1 files changed, 2152 insertions, 0 deletions
diff --git a/package/elf2flt/src/elf2flt.c b/package/elf2flt/src/elf2flt.c new file mode 100644 index 000000000..65a116c6c --- /dev/null +++ b/package/elf2flt/src/elf2flt.c @@ -0,0 +1,2152 @@ +/* + * 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 + */ |