#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/fcntl.h>
#include <sys/unistd.h>
#include <erl.h>
#include <hashtab.h>
#include <recycle.h>
#include <tamtypes.h>
#include <kernel.h>

Include dependency graph for erl.c:

Data Structures
struct	elf_header_t

struct	elf_section_t

struct	elf_symbol_t

struct	elf_reloc_t

struct	loosy_t

struct	dependancy_t

Macros
#define	DEBUG 1

#define	STANDALONE 1

#define	FORCE_ALIGN 1

#define	dprintf(a...)

#define	rprintf(a...)

#define	REL_TYPE 1

#define	PROGBITS 1

#define	NOBITS 8

#define	REL 9

#define	GLOBAL 1

#define	WEAK 2

#define	NOTYPE 0

#define	OBJECT 1

#define	FUNC 2

#define	SECTION 3

#define	R_MIPS_32 2

#define	R_MIPS_26 4

#define	R_MIPS_HI16 5

#define	R_MIPS_LO16 6

#define	free_and_return(code)

#define	O_BINARY 0

Typedefs
typedef int(*	func_t) (void)

typedef int(*	start_t) (int argc, char **argv)

Functions
static u32	align (u32 x, int align)

static struct loosy_t *	create_loosy (struct erl_record_t erl, u8 reloc, int type)

static void	destroy_loosy (struct loosy_t *l)

static void	r_destroy_loosy (struct loosy_t *l)

static struct symbol_t *	create_symbol (struct erl_record_t *provider, u32 address)

static void	destroy_symbol (struct symbol_t *s)

static struct erl_record_t *	allocate_erl_record ()

static void	destroy_erl_record (struct erl_record_t *erl)

static int	apply_reloc (u8 *reloc, int type, u32 addr)

struct symbol_t *	erl_find_local_symbol (const char symbol, struct erl_record_t erl)

static struct symbol_t *	r_find_symbol (const char symbol, struct erl_record_t erl)

struct symbol_t *	erl_find_symbol (const char *symbol)

static struct dependancy_t *	add_dependancy (struct erl_record_t depender, struct erl_record_t provider)

static void	destroy_dependancy (struct dependancy_t *d)

static void	r_destroy_dependancy_r (struct erl_record_t erl, struct dependancy_t d)

static void	destroy_dependancy_r (struct erl_record_t *erl)

static void	add_loosy (struct erl_record_t erl, u8 reloc, int type, const char *symbol)

static int	fix_loosy (struct erl_record_t provider, const char symbol, u32 address)

static int	is_local (const char *symbol)

static int	add_symbol (struct erl_record_t erl, const char symbol, u32 address)

int	erl_add_global_symbol (const char *symbol, u32 address)

static int	read_erl (int elf_handle, u8 elf_mem, u32 addr, struct erl_record_t *p_erl_record)

static struct erl_record_t *	_init_load_erl_wrapper_from_file (char *erl_id)

static struct erl_record_t *	load_erl (const char fname, u8 elf_mem, u32 addr, int argc, char **argv)

struct erl_record_t *	_init_load_erl_from_file (const char fname, char erl_id)

struct erl_record_t *	load_erl_from_file (const char fname, int argc, char *argv)

struct erl_record_t *	load_erl_from_mem (u8 mem, int argc, char *argv)

struct erl_record_t *	load_erl_from_mem_to_addr (u8 mem, u32 addr, int argc, char *argv)

struct erl_record_t *	load_erl_from_file_to_addr (const char fname, u32 addr, int argc, char *argv)

struct erl_record_t *	_init_load_erl_from_file_to_addr (const char fname, u32 addr, char erl_id)

void	r_unload_dependancies (char **d)

int	unload_erl (struct erl_record_t *erl)

struct erl_record_t *	erl_resolve (u32 address)

struct erl_record_t *	find_erl (const char *name)

void	erl_flush_symbols (struct erl_record_t *erl)

Variables
static const char *	local_names []

static struct erl_record_t *	erl_record_root = 0

static htab *	global_symbols = 0

static htab *	loosy_relocs = 0

char	_init_erl_prefix [256] = ""

static struct dependancy_t *	dependancy_root = 0

static reroot *	symbol_recycle = 0

erl_loader_t	_init_load_erl = _init_load_erl_wrapper_from_file

Detailed Description

The relocatable elf loader/linker.

Definition in file erl.c.

Macro Definition Documentation

◆ DEBUG

#define DEBUG 1

Definition at line 16 of file erl.c.

◆ dprintf

#define dprintf ( a... )

Definition at line 33 of file erl.c.

◆ FORCE_ALIGN

#define FORCE_ALIGN 1

Definition at line 18 of file erl.c.

◆ free_and_return

#define free_and_return ( code )

Value:

    if (!elf_mem) { \
    if (names) free(names); \
    if (strtab_names) free(strtab_names); \
    if (sec) free(sec); \
    if (sym) free(sym); \
    if ((code < 0) && erl_record) destroy_erl_record(erl_record); \
} \
return code

◆ FUNC

#define FUNC 2

Definition at line 195 of file erl.c.

◆ GLOBAL

#define GLOBAL 1

Definition at line 191 of file erl.c.

◆ NOBITS

#define NOBITS 8

Definition at line 189 of file erl.c.

◆ NOTYPE

#define NOTYPE 0

Definition at line 193 of file erl.c.

◆ O_BINARY

#define O_BINARY 0

Definition at line 925 of file erl.c.

◆ OBJECT

#define OBJECT 1

Definition at line 194 of file erl.c.

◆ PROGBITS

#define PROGBITS 1

Definition at line 188 of file erl.c.

◆ R_MIPS_26

#define R_MIPS_26 4

Definition at line 198 of file erl.c.

◆ R_MIPS_32

#define R_MIPS_32 2

Definition at line 197 of file erl.c.

◆ R_MIPS_HI16

#define R_MIPS_HI16 5

Definition at line 199 of file erl.c.

◆ R_MIPS_LO16

#define R_MIPS_LO16 6

Definition at line 200 of file erl.c.

◆ REL

#define REL 9

Definition at line 190 of file erl.c.

◆ REL_TYPE

#define REL_TYPE 1

Definition at line 187 of file erl.c.

◆ rprintf

#define rprintf ( a... )

Definition at line 34 of file erl.c.

◆ SECTION

#define SECTION 3

Definition at line 196 of file erl.c.

◆ STANDALONE

#define STANDALONE 1

Definition at line 17 of file erl.c.

◆ WEAK

#define WEAK 2

Definition at line 192 of file erl.c.

Typedef Documentation

◆ func_t

typedef int(* func_t) (void)

Definition at line 928 of file erl.c.

◆ start_t

typedef int(* start_t) (int argc, char **argv)

Definition at line 929 of file erl.c.

Function Documentation

◆ _init_load_erl_from_file()

struct erl_record_t* _init_load_erl_from_file	(	const char *	fname,
		char *	erl_id
	)

Definition at line 1012 of file erl.c.

                                                                                   {
     char tfname[1024];
     struct erl_record_t * r;
     char * argv[2];
  
     if (erl_id)
         if ((r = find_erl(erl_id)))
             return r;
  
     argv[0] = erl_id;
     argv[1] = 0;
  
     strcpy(tfname, _init_erl_prefix);
     strcat(tfname, fname);
  
     return load_erl_from_file(tfname, 1, argv);
 }

References _init_erl_prefix, erl_id, find_erl(), and load_erl_from_file().

Referenced by _init_load_erl_wrapper_from_file(), and main().

◆ _init_load_erl_from_file_to_addr()

struct erl_record_t* _init_load_erl_from_file_to_addr	(	const char *	fname,
		u32	addr,
		char *	erl_id
	)

Definition at line 1055 of file erl.c.

                                                                                                     {
     char tfname[1024];
     struct erl_record_t * r;
     char * argv[2];
  
     if (erl_id)
         if ((r = find_erl(erl_id)))
             return r;
  
     argv[0] = erl_id;
     argv[1] = 0;
  
     strcpy(tfname, _init_erl_prefix);
     strcat(tfname, fname);
  
     return load_erl_from_file_to_addr(tfname, addr, 1, argv);
 }

References _init_erl_prefix, erl_id, find_erl(), and load_erl_from_file_to_addr().

◆ _init_load_erl_wrapper_from_file()

static struct erl_record_t* _init_load_erl_wrapper_from_file ( char * erl_id )

static

Definition at line 931 of file erl.c.

                                                                              {
     char tmpnam[256];
     strcpy(tmpnam, erl_id);
     strcat(tmpnam, ".erl");
     return _init_load_erl_from_file(tmpnam, erl_id);
 }

References _init_load_erl_from_file(), and erl_id.

◆ add_dependancy()

static struct dependancy_t* add_dependancy	(	struct erl_record_t *	depender,
		struct erl_record_t *	provider
	)

static

Definition at line 450 of file erl.c.

                                                                                                             {
     struct dependancy_t * d;
  
     if (depender == provider)
         return 0;
  
     if (!(d = (struct dependancy_t *) malloc(sizeof(struct dependancy_t))))
         return 0;
  
     d->depender = depender;
     d->provider = provider;
  
     if ((d->next = dependancy_root))
         d->next->prev = d;
  
     d->prev = 0;
     dependancy_root = d;
  
     return d;
 }

References dependancy_root, dependancy_t::depender, dependancy_t::next, dependancy_t::prev, and dependancy_t::provider.

Referenced by fix_loosy(), and read_erl().

◆ add_loosy()

static void add_loosy	(	struct erl_record_t *	erl,
		u8 *	reloc,
		int	type,
		const char *	symbol
	)

static

Definition at line 499 of file erl.c.

                                                                                             {
     struct loosy_t * l;
  
     l = create_loosy(erl, reloc, type);
  
     if (!loosy_relocs)
         loosy_relocs = hcreate(6);
  
     if (!hadd(loosy_relocs, symbol, strlen(symbol), l)) {
         l->next = hstuff(loosy_relocs);
         hstuff(loosy_relocs) = l;
     } else {
         hkey(loosy_relocs) = (ub1 *)strdup(symbol);
     }
 }

References create_loosy(), loosy_t::erl, hadd(), hcreate(), hkey, hstuff, loosy_relocs, loosy_t::next, loosy_t::reloc, and loosy_t::type.

Referenced by read_erl().

◆ add_symbol()

static int add_symbol	(	struct erl_record_t *	erl,
		const char *	symbol,
		u32	address
	)

static

Definition at line 546 of file erl.c.

                                                                                    {
     htab * symbols;
  
     if (erl) {
         symbols = erl->symbols;
     } else {
         if (!global_symbols)
             global_symbols = hcreate(6);
         symbols = global_symbols;
     }
  
     if (!is_local(symbol) && erl_find_symbol(symbol))
         return -1;
  
     dprintf("Adding symbol %s at address %08X\n", symbol, address);
  
     if (fix_loosy(erl, symbol, address)) {
 #ifdef _EE
         FlushCache(2);
         FlushCache(0);
 #endif
     }
  
     hadd(symbols, strdup(symbol), strlen(symbol), create_symbol(erl, address));
  
     return 0;
 }

References create_symbol(), dprintf, loosy_t::erl, erl_find_symbol(), fix_loosy(), FlushCache(), global_symbols, hadd(), hcreate(), is_local(), and erl_loader_t::symbols.

Referenced by erl_add_global_symbol(), and read_erl().

◆ align()

static u32 align	(	u32	x,
		int	align
	)

static

Definition at line 286 of file erl.c.

                                    {
 #ifdef FORCE_ALIGN
     if (align < 16)
         align = 16;
 #endif
  
     align--;
  
     if (x & align) {
         x |= align;
         x++;
     }
  
     return x;
 }

References x.

Referenced by read_erl().

◆ allocate_erl_record()

static struct erl_record_t* allocate_erl_record ( )

static

Definition at line 349 of file erl.c.

                                                    {
     struct erl_record_t * r;
  
     if (!(r = (struct erl_record_t *) malloc(sizeof(struct erl_record_t))))
         return 0;
  
     r->bytes = NULL;
     r->symbols = hcreate(6);
  
     if ((r->next = erl_record_root))
         r->next->prev = r;
     r->prev = 0;
     erl_record_root = r;
  
     r->flags = 0;
  
     return r;
 }

References erl_loader_t::bytes, erl_record_root, erl_loader_t::flags, hcreate(), erl_loader_t::next, NULL, erl_loader_t::prev, and erl_loader_t::symbols.

Referenced by read_erl().

◆ apply_reloc()

static int apply_reloc	(	u8 *	reloc,
		int	type,
		u32	addr
	)

static

Definition at line 392 of file erl.c.

                                                        {
     u32 u_current_data;
     s32 s_current_data;
         u32 newstate;
  
         if (((u32)reloc)&0x3)
         {
                 printf("Unaligned reloc (%p) type=%d!\n", reloc, type);
         }
         memcpy(&u_current_data, reloc, 4);
         memcpy(&s_current_data, reloc, 4);
  
     switch (type) {
         case R_MIPS_32:
                 newstate = s_current_data + addr;
                 break;
         case R_MIPS_26:
                 newstate = (u_current_data & 0xfc000000) | (((u_current_data & 0x03ffffff) + (addr >> 2)) & 0x3ffffff);
                 break;
         case R_MIPS_HI16:
                 newstate = (u_current_data & 0xffff0000) | ((((s_current_data << 16) >> 16) + (addr >> 16) + ((addr & 0xffff) >= 0x8000 ? 1 : 0)) & 0xffff);
                 break;
         case R_MIPS_LO16:
                 newstate = (u_current_data & 0xffff0000) | ((((s_current_data << 16) >> 16) + (addr & 0xffff)) & 0xffff);
                 break;
         default:
                 return -1;
     }
  
         memcpy(reloc, &newstate, 4);
  
     dprintf("Changed data at %08X from %08X to %08X.\n", reloc, u_current_data, newstate);
     return 0;
 }

References dprintf, R_MIPS_26, R_MIPS_32, R_MIPS_HI16, and R_MIPS_LO16.

Referenced by fix_loosy(), and read_erl().

◆ create_loosy()

static struct loosy_t* create_loosy	(	struct erl_record_t *	erl,
		u8 *	reloc,
		int	type
	)

static

Definition at line 302 of file erl.c.

                                                                                       {
     struct loosy_t * r;
  
     if (!(r = (struct loosy_t *) malloc(sizeof(struct loosy_t))))
         return 0;
  
     r->reloc = reloc;
     r->type = type;
     r->next = 0;
     r->erl = erl;
  
     return r;
 }

References loosy_t::erl, loosy_t::next, loosy_t::reloc, and loosy_t::type.

Referenced by add_loosy().

◆ create_symbol()

static struct symbol_t* create_symbol	(	struct erl_record_t *	provider,
		u32	address
	)

static

Definition at line 331 of file erl.c.

                                                                                     {
     struct symbol_t * r;
  
     if (!symbol_recycle)
         symbol_recycle = remkroot(sizeof(struct symbol_t));
  
     r = (struct symbol_t *) renew(symbol_recycle);
  
     r->provider = provider;
     r->address = address;
  
     return r;
 }

References symbol_t::address, symbol_t::provider, remkroot(), renew, and symbol_recycle.

Referenced by add_symbol().

◆ destroy_dependancy()

static void destroy_dependancy ( struct dependancy_t * d )

static

Definition at line 471 of file erl.c.

                                                         {
     if (d->prev)
         d->prev->next = d->next;
     else
         dependancy_root = d->next;
  
     if (d->next)
         d->next->prev = d->prev;
  
     free(d);
 }

References dependancy_root, dependancy_t::next, and dependancy_t::prev.

Referenced by r_destroy_dependancy_r().

◆ destroy_dependancy_r()

static void destroy_dependancy_r ( struct erl_record_t * erl )

static

Definition at line 495 of file erl.c.

                                                             {
     r_destroy_dependancy_r(erl, dependancy_root);
 }

References dependancy_root, and r_destroy_dependancy_r().

Referenced by unload_erl().

◆ destroy_erl_record()

static void destroy_erl_record ( struct erl_record_t * erl )

static

Definition at line 368 of file erl.c.

                                                           {
     if (!erl)
         return;
  
     if (erl->bytes) {
         if (erl->flags & ERL_FLAG_CLEAR)
             memset(erl->bytes, 0, erl->fullsize);
         if (!(erl->flags & ERL_FLAG_STATIC))
             free(erl->bytes);
     }
  
     erl_flush_symbols(erl);
  
     if (erl->prev)
         erl->prev->next = erl->next;
     else
         erl_record_root = erl->next;
  
     if (erl->next)
         erl->next->prev = erl->prev;
  
     free(erl);
 }

References erl_loader_t::bytes, ERL_FLAG_CLEAR, ERL_FLAG_STATIC, erl_flush_symbols(), erl_record_root, erl_loader_t::flags, erl_loader_t::fullsize, erl_loader_t::next, and erl_loader_t::prev.

Referenced by unload_erl().

◆ destroy_loosy()

static void destroy_loosy ( struct loosy_t * l )

static

Definition at line 316 of file erl.c.

                                               {
     free(l);
 }

Referenced by r_destroy_loosy().

◆ destroy_symbol()

static void destroy_symbol ( struct symbol_t * s )

static

Definition at line 345 of file erl.c.

                                                 {
     redel(symbol_recycle, s);
 }

References redel, s, and symbol_recycle.

Referenced by erl_flush_symbols().

◆ erl_add_global_symbol()

int erl_add_global_symbol	(	const char *	symbol,
		u32	address
	)

Definition at line 574 of file erl.c.

                                                             {
     return add_symbol(0, symbol, address);
 }

References add_symbol().

Referenced by export_symbols().

◆ erl_find_local_symbol()

struct symbol_t* erl_find_local_symbol	(	const char *	symbol,
		struct erl_record_t *	erl
	)

Definition at line 427 of file erl.c.

                                                                                         {
     if (!erl)
         return 0;
     if (hfind(erl->symbols, symbol, strlen(symbol)))
         return hstuff(erl->symbols);
     return 0;
 }

References hfind(), hstuff, and erl_loader_t::symbols.

Referenced by load_erl(), and unload_erl().

◆ erl_find_symbol()

struct symbol_t* erl_find_symbol ( const char * symbol )

Definition at line 443 of file erl.c.

                                                        {
     if (global_symbols)
         if (hfind(global_symbols, symbol, strlen(symbol)))
             return hstuff(global_symbols);
     return r_find_symbol(symbol, erl_record_root);
 }

References erl_record_root, global_symbols, hfind(), hstuff, and r_find_symbol().

Referenced by add_symbol(), main(), and read_erl().

◆ erl_flush_symbols()

void erl_flush_symbols ( struct erl_record_t * erl )

Definition at line 1145 of file erl.c.

                                                   {
     if (!erl->symbols)
         return;
  
     if (hfirst(erl->symbols)) do {
         destroy_symbol((struct symbol_t *) hstuff(erl->symbols));
         free(hkey(erl->symbols));
         hdel(erl->symbols);
     } while (hcount(erl->symbols));
  
     hdestroy(erl->symbols);
  
     erl->symbols = 0;
 }

References destroy_symbol(), hcount, hdel(), hdestroy(), hfirst(), hkey, hstuff, and erl_loader_t::symbols.

Referenced by destroy_erl_record(), and unload_erl().

◆ erl_resolve()

struct erl_record_t* erl_resolve ( u32 address )

Definition at line 1121 of file erl.c.

                                                {
     struct erl_record_t * r;
  
     for (r = erl_record_root; r; r = r->next) {
         u32 r_ptr = (u32) r->bytes;
         if ((address >= r_ptr) && (address < (r_ptr + r->fullsize)))
             return r;
     }
  
     return 0;
 }

References erl_loader_t::bytes, erl_record_root, erl_loader_t::fullsize, and erl_loader_t::next.

◆ find_erl()

struct erl_record_t* find_erl ( const char * name )

Definition at line 1133 of file erl.c.

                                                   {
     struct erl_record_t * r;
  
     for (r = erl_record_root; r; r = r->next) {
         if (r->name)
             if (!strcmp(name, r->name))
                 return r;
     }
  
     return 0;
 }

References erl_record_root, erl_loader_t::name, and erl_loader_t::next.

Referenced by _init_load_erl_from_file(), _init_load_erl_from_file_to_addr(), and r_unload_dependancies().

◆ fix_loosy()

static int fix_loosy	(	struct erl_record_t *	provider,
		const char *	symbol,
		u32	address
	)

static

Definition at line 515 of file erl.c.

                                                                                        {
     struct loosy_t * l;
     int count = 0;
  
     if (!loosy_relocs)
         return count;
  
     if (hfind(loosy_relocs, symbol, strlen(symbol))) {
         for (l = hstuff(loosy_relocs); l; l = l->next) {
             apply_reloc(l->reloc, l->type, address);
             add_dependancy(l->erl, provider);
             count++;
         }
         r_destroy_loosy(hstuff(loosy_relocs));
         free(hkey(loosy_relocs));
         hdel(loosy_relocs);
     }
  
     return count;
 }

References add_dependancy(), apply_reloc(), loosy_t::erl, hdel(), hfind(), hkey, hstuff, loosy_relocs, loosy_t::next, r_destroy_loosy(), loosy_t::reloc, and loosy_t::type.

Referenced by add_symbol().

◆ is_local()

static int is_local ( const char * symbol )

static

Definition at line 536 of file erl.c.

                                          {
     const char ** p;
  
     for (p = local_names; *p; p++)
         if (!strcmp(*p, symbol))
             return 1;
  
     return 0;
 }

References local_names.

Referenced by add_symbol().

◆ load_erl()

static struct erl_record_t* load_erl	(	const char *	fname,
		u8 *	elf_mem,
		u32	addr,
		int	argc,
		char **	argv
	)

static

Definition at line 940 of file erl.c.

                                                                                                           {
     struct erl_record_t * r;
     struct symbol_t * s;
     int elf_handle = 0;
  
     dprintf("Reading ERL file.\n");
  
     if (fname) {
         if ((elf_handle = open(fname, O_RDONLY | O_BINARY)) < 0) {
             dprintf("Error operning erl file: %s\n", fname);
             return 0;
         }
     }
  
     if (read_erl(elf_handle, elf_mem, addr, &r) < 0) {
         dprintf("Error loading erl file.\n");
         if (fname) {
             close(elf_handle);
         }
         return 0;
     }
  
     if (fname) {
         close(elf_handle);
     }
  
         if ((s = erl_find_local_symbol("erl_id", r))) {
                 r->name = *(char **) s->address;
         } else {
                 r->name = 0;
         }
  
     dprintf("erl_id = %08X.\n", r->name);
  
     if ((s = erl_find_local_symbol("erl_dependancies", r))) {
         r->dependancies = (char **) s->address;
     } else {
         r->dependancies = 0;
     }
  
     dprintf("erl_dependancies = %08X.\n", r->dependancies);
  
     if (r->dependancies) {
         char ** d;
         for (d = r->dependancies; *d; d++) {
             dprintf("Loading dependancy: %s.\n", *d);
             _init_load_erl(*d);
         }
     }
  
     if ((s = erl_find_local_symbol("_init", r))) {
         dprintf("_init = %08X\n", s->address);
 #ifdef _EE
         ((func_t)s->address)();
 #endif
     }
  
     if ((s = erl_find_local_symbol("_start", r))) {
         int _start_ret;
         dprintf("_start = %08X\n", s->address);
 #ifdef _EE
         if ((_start_ret = ((start_t)s->address)(argc, argv))) {
             dprintf("Module's _start returned %i, unloading module.\n", _start_ret);
             if (unload_erl(r))
                 return 0;
         }
 #endif
     }
  
     return r;
 }

References _init_load_erl, erl_loader_t::dependancies, dprintf, erl_find_local_symbol(), erl_loader_t::name, O_BINARY, read_erl(), s, and unload_erl().

Referenced by load_erl_from_file(), load_erl_from_file_to_addr(), load_erl_from_mem(), and load_erl_from_mem_to_addr().

◆ load_erl_from_file()

struct erl_record_t* load_erl_from_file	(	const char *	fname,
		int	argc,
		char **	argv
	)

Definition at line 1030 of file erl.c.

                                                                                      {
     return load_erl(fname, 0, ERL_DYN_ADDR, argc, argv);
 }

References ERL_DYN_ADDR, and load_erl().

Referenced by _init_load_erl_from_file().

◆ load_erl_from_file_to_addr()

struct erl_record_t* load_erl_from_file_to_addr	(	const char *	fname,
		u32	addr,
		int	argc,
		char **	argv
	)

Definition at line 1048 of file erl.c.

                                                                                                        {
     return load_erl(fname, 0, addr, argc, argv);
 }

References load_erl().

Referenced by _init_load_erl_from_file_to_addr().

◆ load_erl_from_mem()

struct erl_record_t* load_erl_from_mem	(	u8 *	mem,
		int	argc,
		char **	argv
	)

Definition at line 1034 of file erl.c.

                                                                           {
     return load_erl(0, mem, ERL_DYN_ADDR, argc, argv);
 }

References ERL_DYN_ADDR, and load_erl().

◆ load_erl_from_mem_to_addr()

struct erl_record_t* load_erl_from_mem_to_addr	(	u8 *	mem,
		u32	addr,
		int	argc,
		char **	argv
	)

Definition at line 1041 of file erl.c.

                                                                                             {
     return load_erl(0, mem, addr, argc, argv);
 }

References load_erl().

◆ r_destroy_dependancy_r()

static void r_destroy_dependancy_r	(	struct erl_record_t *	erl,
		struct dependancy_t *	d
	)

static

Definition at line 483 of file erl.c.

                                                                                        {
     if (!d)
         return;
  
     r_destroy_dependancy_r(erl, d->next);
  
     if (erl == d->depender)
         destroy_dependancy(d);
  
     return;
 }

References dependancy_t::depender, destroy_dependancy(), and dependancy_t::next.

Referenced by destroy_dependancy_r().

◆ r_destroy_loosy()

static void r_destroy_loosy ( struct loosy_t * l )

static

Definition at line 320 of file erl.c.

                                                 {
     if (!l)
         return;
  
     r_destroy_loosy(l->next);
  
     destroy_loosy(l);
 }

References destroy_loosy(), and loosy_t::next.

Referenced by fix_loosy().

◆ r_find_symbol()

static struct symbol_t* r_find_symbol	(	const char *	symbol,
		struct erl_record_t *	erl
	)

static

Definition at line 435 of file erl.c.

                                                                                        {
     if (!erl)
         return 0;
     if (hfind(erl->symbols, symbol, strlen(symbol)))
         return hstuff(erl->symbols);
     return r_find_symbol(symbol, erl->next);
 }

References hfind(), hstuff, erl_loader_t::next, and erl_loader_t::symbols.

Referenced by erl_find_symbol().

◆ r_unload_dependancies()

void r_unload_dependancies ( char ** d )

Definition at line 1073 of file erl.c.

                                       {
     struct erl_record_t * erl;
     if (!(*d))
         return;
  
     r_unload_dependancies(d + 1);
  
     if ((erl = find_erl(*d)))
         unload_erl(erl);
 }

References find_erl(), and unload_erl().

Referenced by unload_erl().

◆ read_erl()

static int read_erl	(	int	elf_handle,
		u8 *	elf_mem,
		u32	addr,
		struct erl_record_t **	p_erl_record
	)

static

Definition at line 578 of file erl.c.

                                                                                                  {
     struct elf_header_t head;
     struct elf_section_t * sec = 0;
     struct elf_symbol_t * sym = 0;
     struct elf_reloc_t reloc;
     int i, j;
     // int erx_compressed; // Not used
     char * names = 0, * strtab_names = 0, * reloc_section = 0;
     int symtab = 0, strtab = 0, linked_strtab = 0;
     u8 * magic;
     u32 fullsize = 0;
     struct erl_record_t * erl_record = 0;
     struct symbol_t * s;
  
     *p_erl_record = 0;
  
 #define free_and_return(code) if (!elf_mem) { \
     if (names) free(names); \
     if (strtab_names) free(strtab_names); \
     if (sec) free(sec); \
     if (sym) free(sym); \
     if ((code < 0) && erl_record) destroy_erl_record(erl_record); \
 } \
 return code
  
     if (!(erl_record = allocate_erl_record())) {
         dprintf("Memory allocation error.\n");
         free_and_return(-1);
     }
  
    // Reading the main ELF header.
     if (elf_mem) {
         memcpy(&head, elf_mem, sizeof(head));
     } else {
         lseek(elf_handle, 0, SEEK_SET);
         read(elf_handle, &head, sizeof(head));
     }
  
     magic = head.e_ident.cook.ei_magic;
  
     if ((magic[0] != 0x7f) || (magic[1] != 'E') || (magic[2] != 'L') || ((magic[3] != 'F') && (magic[3] != 'X'))) {
         dprintf("Not an ELF file.\n");
         free_and_return(-1);
     }
  
     // erx_compressed = magic[3] == 'X'; //not used
  
     dprintf("ELF Class    : %s\n", elf_classes[head.e_ident.cook.ei_class]);
     dprintf("Data encoding: %s\n", elf_encodings[head.e_ident.cook.ei_data]);
     dprintf("Elf version  : %i\n", head.e_ident.cook.ei_version);
     if (head.e_type == 0xffff) {
         dprintf("Object type  : Processor specific (hi)\n");
     } else if (head.e_type == 0xff00) {
         dprintf("Object type  : Processor specific (lo)\n");
     } else {
         dprintf("Object type  : %s\n", elf_types[head.e_type]);
     }
     dprintf("Machine type : %s\n", elf_machines[head.e_machine]);
     dprintf("Object ver.  : %i\n", head.e_version);
     dprintf("Elf entry    : %08X\n", head.e_entry);
     dprintf("PH offset    : %08X\n", head.e_phoff);
     dprintf("SH offset    : %08X\n", head.e_shoff);
     dprintf("Flags        : %08X\n", head.e_flags);
     dprintf("Header size  : %04X\n", head.e_ehsize);
     dprintf("PH ent. size : %04X\n", head.e_phentsize);
     dprintf("PH number    : %04X\n", head.e_phnum);
     dprintf("SH ent. size : %04X\n", head.e_shentsize);
     dprintf("SH number    : %04X\n", head.e_shnum);
     dprintf("SH str index : %04X\n", head.e_shstrndx);
  
     if (head.e_type != REL_TYPE) {
         dprintf("File isn't a relocatable ELF file.\n");
         free_and_return(-1);
     }
  
    // Reading the section table.
     if (sizeof(struct elf_section_t) != head.e_shentsize) {
         dprintf("Inconsistancy in section table entries.\n");
         free_and_return(-1);
     }
  
     // **TODO** handle compession
     if (elf_mem) {
         sec = (struct elf_section_t *) (elf_mem + head.e_shoff);
     } else {
         if (!(sec = (struct elf_section_t *) malloc(sizeof(struct elf_section_t) * head.e_shnum))) {
             dprintf("Not enough memory.\n");
             free_and_return(-1);
         }
         lseek(elf_handle, head.e_shoff, SEEK_SET);
         read(elf_handle, sec, sizeof(struct elf_section_t) * head.e_shnum);
     }
  
    // Reading the section names's table.
     // **TODO** handle compession
     if (elf_mem) {
         names = (char *) (elf_mem + sec[head.e_shstrndx].sh_offset);
     } else {
         if (!(names = (char *) malloc(sec[head.e_shstrndx].sh_size))) {
             dprintf("Not enough memory.\n");
             free_and_return(-1);
         }
         lseek(elf_handle, sec[head.e_shstrndx].sh_offset, SEEK_SET);
         read(elf_handle, names, sec[head.e_shstrndx].sh_size);
     }
  
  
    // Parsing the sections, and displaying them at the same time.
     dprintf("##: type   flags offset   size       link info align entsize name\n");
     for (i = 1; i < head.e_shnum; i++) {
         if (!strcmp(names + sec[i].sh_name, ".symtab")) {
             symtab = i;
             linked_strtab = sec[i].sh_link;
         } else if (!strcmp(names + sec[i].sh_name, ".strtab")) {
             strtab = i;
         }
  
         if ((sec[i].sh_type == PROGBITS) || (sec[i].sh_type == NOBITS)) {
            // Let's use this, it's not filled for relocatable objects.
             fullsize = align(fullsize, sec[i].sh_addralign);
             sec[i].sh_addr = fullsize;
             fullsize += sec[i].sh_size;
             dprintf("Section to load at %08X:\n", sec[i].sh_addr);
         }
  
         dprintf("%2i: ", i);
         if (sec[i].sh_type <= 0xff) {
             rprintf("%-8s ", section_types[sec[i].sh_type]);
         } else if (sec[i].sh_type == 0x70000006) {
             rprintf("Reginfo  ");
         } else {
             rprintf("UNKNOW   ");
         }
  
         rprintf(  "%3s ", section_flags[sec[i].sh_flags & 7]);
         rprintf( "%08X ", sec[i].sh_offset);
         rprintf( "%08X ", sec[i].sh_size);
         rprintf(  "%5i ", sec[i].sh_link);
         rprintf(  "%5i ", sec[i].sh_info);
         rprintf(  "%5i ", sec[i].sh_addralign);
         rprintf("%5i   ", sec[i].sh_entsize);
         rprintf(  "%s\n", names + sec[i].sh_name);
     }
  
     if (symtab) {
         dprintf("Discovered symtab = %i\n", symtab);
     } else {
         dprintf("No symbol table.\n");
         free_and_return(-1);
     }
  
     if (strtab) {
         dprintf("Discovered strtab = %i\n", strtab);
     } else {
         dprintf("No string table.\n");
         free_and_return(-1);
     }
  
     if (strtab != linked_strtab) {
         dprintf("Warning, inconsistancy: strtab != symtab.sh_link (%i != %i)\n", strtab, linked_strtab);
         free_and_return(-1);
     }
  
     if (sizeof(struct elf_symbol_t) != sec[symtab].sh_entsize) {
         dprintf("Symbol entries not consistant.\n");
         free_and_return(-1);
     }
  
     dprintf("Computed needed size to load the erl file: %i\n", fullsize);
  
    // Loading progbits sections.
     if (addr == ERL_DYN_ADDR) {
         erl_record->bytes = (u8 *) malloc(fullsize);
         if (!erl_record->bytes) {
             dprintf("Cannot allocate ERL bytes.\n");
             free_and_return(-1);
         }
     } else {
         erl_record->bytes = (u8 *) addr;
         erl_record->flags |= ERL_FLAG_STATIC;
     }
  
     erl_record->fullsize = fullsize;
     dprintf("Base address: %08X\n", erl_record->bytes);
     for (i = 1; i < head.e_shnum; i++) {
         switch (sec[i].sh_type) {
         case PROGBITS:
             // **TODO** handle compession
             dprintf("Reading section %s at %08X.\n", names + sec[i].sh_name, erl_record->bytes + sec[i].sh_addr);
             if (elf_mem) {
                 memcpy(erl_record->bytes + sec[i].sh_addr, elf_mem + sec[i].sh_offset, sec[i].sh_size);
             } else {
                 lseek(elf_handle, sec[i].sh_offset, SEEK_SET);
                 read(elf_handle, erl_record->bytes + sec[i].sh_addr, sec[i].sh_size);
             }
             break;
         case NOBITS:
             dprintf("Zeroing section %s at %08X.\n", names + sec[i].sh_name, erl_record->bytes + sec[i].sh_addr);
             memset(erl_record->bytes + sec[i].sh_addr, 0, sec[i].sh_size);
             break;
         }
     }
  
  
    // Loading strtab.
     // **TODO** handle compession
     if (elf_mem) {
         strtab_names = (char *) (elf_mem + sec[strtab].sh_offset);
     } else {
         if (!(strtab_names = (char *) malloc(sec[strtab].sh_size))) {
             dprintf("Not enough memory.\n");
             free_and_return(-1);
         }
         lseek(elf_handle, sec[strtab].sh_offset, SEEK_SET);
         read(elf_handle, strtab_names, sec[strtab].sh_size);
     }
  
  
    // Loading symtab.
     // **TODO** handle compession
     if (elf_mem) {
         sym = (struct elf_symbol_t *) (elf_mem + sec[symtab].sh_offset);
     } else {
         if (!(sym = (struct elf_symbol_t *) malloc(sec[symtab].sh_size))) {
             dprintf("Not enough memory.\n");
             free_and_return(-1);
         }
         lseek(elf_handle, sec[symtab].sh_offset, SEEK_SET);
         read(elf_handle, sym, sec[symtab].sh_size);
     }
  
    // Parsing sections to find relocation sections.
     for (i = 0; i < head.e_shnum; i++) {
         if (sec[i].sh_type != REL)
             continue;
         dprintf("Section %i (%s) contains relocations for section %i (%s):\n",
                 i, names + sec[i].sh_name, sec[i].sh_info, names + sec[sec[i].sh_info].sh_name);
  
         if (sec[i].sh_entsize != sizeof(struct elf_reloc_t)) {
             dprintf("Warning: inconsistancy in relocation table.\n");
             free_and_return(-1);
         }
  
        // Loading relocation section.
         // **TODO** handle compession
         if (elf_mem) {
           reloc_section = (char *)(elf_mem + sec[i].sh_offset);
         } else {
             lseek(elf_handle, sec[i].sh_offset, SEEK_SET);
             if (!(reloc_section = (char *) malloc(sec[i].sh_size))) {
                 dprintf("Not enough memory.\n");
                 free_and_return(-1);
             }
             lseek(elf_handle, sec[i].sh_offset, SEEK_SET);
             read(elf_handle, reloc_section, sec[i].sh_size);
         }
  
        // We found one relocation section, let's parse it to relocate.
         dprintf("   Num: Offset   Type           Symbol\n");
         for (j = 0; j < (sec[i].sh_size / sec[i].sh_entsize); j++) {
             int sym_n;
  
             reloc = *((struct elf_reloc_t *) (reloc_section + j * sec[i].sh_entsize));
  
             sym_n = reloc.r_info >> 8;
             dprintf("%6i: %08X %-14s %3i: ", j, reloc.r_offset, reloc_types[reloc.r_info & 255], sym_n);
  
             switch(sym[sym_n].st_info & 15) {
             case NOTYPE:
                 rprintf("external symbol reloc to symbol %s\n", strtab_names + sym[sym_n].st_name);
                 if (!(s = erl_find_symbol(strtab_names + sym[sym_n].st_name))) {
                     printf("%s: Symbol not found, adding as loosy relocation.\n", strtab_names + sym[sym_n].st_name);
                     add_loosy(erl_record, erl_record->bytes + sec[sec[i].sh_info].sh_addr + reloc.r_offset, reloc.r_info & 255, strtab_names + sym[sym_n].st_name);
                 } else {
                     dprintf("Found symbol at %08X, relocating.\n", s->address);
                     if (apply_reloc(erl_record->bytes + sec[sec[i].sh_info].sh_addr + reloc.r_offset, reloc.r_info & 255, s->address) < 0) {
                         dprintf("Something went wrong in relocation.");
                         free_and_return(-1);
                     }
                     add_dependancy(erl_record, s->provider);
                 }
                 break;
             case SECTION:
                 rprintf("internal section reloc to section %i (%s)\n", sym[sym_n].st_shndx, names + sec[sym[sym_n].st_shndx].sh_name);
                 dprintf("Relocating at %08X.\n", erl_record->bytes + sec[sym[sym_n].st_shndx].sh_addr);
                 if (apply_reloc(erl_record->bytes + sec[sec[i].sh_info].sh_addr + reloc.r_offset, reloc.r_info & 255, (u32) (erl_record->bytes + sec[sym[sym_n].st_shndx].sh_addr)) < 0) {
                     dprintf("Something went wrong in relocation.");
                     free_and_return(-1);
                 }
                 break;
             case OBJECT:
             case FUNC:
                 rprintf("internal relocation to symbol %s\n", strtab_names + sym[sym_n].st_name);
                 if ((s = erl_find_symbol(strtab_names + sym[sym_n].st_name))) {
                     dprintf("Symbol already exists at %08X. Let's use it instead.\n", s->address);
                     if (apply_reloc(erl_record->bytes + sec[sec[i].sh_info].sh_addr + reloc.r_offset, reloc.r_info & 255, s->address) < 0) {
                         dprintf("Something went wrong in relocation.");
                         free_and_return(-1);
                     }
                     add_dependancy(erl_record, s->provider);
                 } else {
                     dprintf("Relocating at %08X.\n", erl_record->bytes + sec[sym[sym_n].st_shndx].sh_addr + sym[sym_n].st_value);
                     if (apply_reloc(erl_record->bytes + sec[sec[i].sh_info].sh_addr + reloc.r_offset, reloc.r_info & 255, (u32) (erl_record->bytes + sec[sym[sym_n].st_shndx].sh_addr + sym[sym_n].st_value)) < 0) {
                         dprintf("Something went wrong in relocation.");
                         free_and_return(-1);
                     }
                 }
                 break;
             default:
                 rprintf("Unknown relocation. Bug inside.\n");
                 free_and_return(-1);
             }
         }
         if (!elf_mem)
             free(reloc_section);
     }
  
     dprintf("   Num: Value    Size     Type    Bind      Ndx Name\n");
     for (i = 0; i < sec[symtab].sh_size / sec[symtab].sh_entsize; i++) {
         if (((sym[i].st_info >> 4) == GLOBAL) || ((sym[i].st_info >> 4) == WEAK)) {
             if ((sym[i].st_info & 15) != NOTYPE) {
                 dprintf("Export symbol:\n");
                 if (add_symbol(erl_record, strtab_names + sym[i].st_name, ((u32)erl_record->bytes) + sec[sym[i].st_shndx].sh_addr + sym[i].st_value) < 0) {
                     dprintf("Symbol probably already exists, let's ignore that.\n");
 //                  free_and_return(-1);
                 }
             }
         }
  
         dprintf("%6i: %08X %08X %-7s %-6s %6i %-10s : %s\n", i,
           sym[i].st_value, sym[i].st_size, symbol_types[sym[i].st_info & 15],
           binding_types[sym[i].st_info >> 4], sym[i].st_shndx,
           sym[i].st_name ? strtab_names + sym[i].st_name : "(null)",
           sym[i].st_shndx ? names + sec[sym[i].st_shndx].sh_name : "(null)");
     }
  
 #ifdef _EE
     FlushCache(2);
     FlushCache(0);
 #endif
  
     *p_erl_record = erl_record;
  
     free_and_return(0);
 }

Referenced by load_erl().

◆ unload_erl()

int unload_erl ( struct erl_record_t * erl )

Definition at line 1084 of file erl.c.

                                           {
     struct symbol_t * s;
     struct dependancy_t * p;
  
     dprintf("Unloading module %s.\n", erl->name ? erl->name : "(noname)");
  
     if ((erl->flags) & ERL_FLAG_STICKY) {
         dprintf("Module is sticky, won't unload.\n");
         return 0;
     }
  
     for (p = dependancy_root; p; p = p->next) {
         if (p->provider == erl) {
             dprintf("Other modules depend on it, won't unload.\n");
             return 0;
         }
     }
  
     if ((s = erl_find_local_symbol("_fini", erl))) {
         dprintf("_fini = %08X\n", s->address);
 #ifdef _EE
         ((func_t)s->address)();
 #endif
     }
  
     if (erl->dependancies)
         r_unload_dependancies(erl->dependancies);
  
     erl_flush_symbols(erl);
  
     destroy_dependancy_r(erl);
  
     destroy_erl_record(erl);
  
     return 1;
 }

References erl_loader_t::dependancies, dependancy_root, destroy_dependancy_r(), destroy_erl_record(), dprintf, erl_find_local_symbol(), ERL_FLAG_STICKY, erl_flush_symbols(), erl_loader_t::flags, erl_loader_t::name, dependancy_t::next, dependancy_t::provider, r_unload_dependancies(), and s.

Referenced by load_erl(), and r_unload_dependancies().

Variable Documentation

◆ _init_erl_prefix

char _init_erl_prefix[256] = ""

Definition at line 281 of file erl.c.

Referenced by _init_load_erl_from_file(), _init_load_erl_from_file_to_addr(), and parse_boot_path().

◆ _init_load_erl

erl_loader_t _init_load_erl = _init_load_erl_wrapper_from_file

Definition at line 938 of file erl.c.

Referenced by load_erl().

◆ dependancy_root

struct dependancy_t* dependancy_root = 0

static

Definition at line 283 of file erl.c.

Referenced by add_dependancy(), destroy_dependancy(), destroy_dependancy_r(), and unload_erl().

◆ erl_record_root

struct erl_record_t* erl_record_root = 0

static

Definition at line 276 of file erl.c.

Referenced by allocate_erl_record(), destroy_erl_record(), erl_find_symbol(), erl_resolve(), and find_erl().

◆ global_symbols

htab* global_symbols = 0

static

Definition at line 278 of file erl.c.

Referenced by add_symbol(), and erl_find_symbol().

◆ local_names

const char* local_names[]

static

Initial value:

= {
    "_init",
    "_fini",
    "erl_id",
    "erl_dependancies",
    "erl_copyright",
    "erl_version",
    "_start",
    0
}

Definition at line 205 of file erl.c.

Referenced by is_local().

◆ loosy_relocs

htab* loosy_relocs = 0

static

Definition at line 279 of file erl.c.

Referenced by add_loosy(), and fix_loosy().

◆ symbol_recycle

reroot* symbol_recycle = 0

static

Definition at line 329 of file erl.c.

Referenced by create_symbol(), and destroy_symbol().

Data Structures

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ DEBUG

◆ dprintf

◆ FORCE_ALIGN

◆ free_and_return

◆ FUNC

◆ GLOBAL

◆ NOBITS

◆ NOTYPE

◆ O_BINARY

◆ OBJECT

◆ PROGBITS

◆ R_MIPS_26

◆ R_MIPS_32

◆ R_MIPS_HI16

◆ R_MIPS_LO16

◆ REL

◆ REL_TYPE

◆ rprintf

◆ SECTION

◆ STANDALONE

◆ WEAK

Typedef Documentation

◆ func_t

◆ start_t

Function Documentation

◆ _init_load_erl_from_file()

◆ _init_load_erl_from_file_to_addr()

◆ _init_load_erl_wrapper_from_file()

◆ add_dependancy()

◆ add_loosy()

◆ add_symbol()

◆ align()

◆ allocate_erl_record()

◆ apply_reloc()

◆ create_loosy()

◆ create_symbol()

◆ destroy_dependancy()

◆ destroy_dependancy_r()

◆ destroy_erl_record()

◆ destroy_loosy()

◆ destroy_symbol()

◆ erl_add_global_symbol()

◆ erl_find_local_symbol()

◆ erl_find_symbol()

◆ erl_flush_symbols()

◆ erl_resolve()

◆ find_erl()

◆ fix_loosy()

◆ is_local()

◆ load_erl()

◆ load_erl_from_file()

◆ load_erl_from_file_to_addr()

◆ load_erl_from_mem()

◆ load_erl_from_mem_to_addr()

◆ r_destroy_dependancy_r()

◆ r_destroy_loosy()

◆ r_find_symbol()

◆ r_unload_dependancies()

◆ read_erl()

◆ unload_erl()

Variable Documentation

◆ _init_erl_prefix

◆ _init_load_erl

◆ dependancy_root

◆ erl_record_root

◆ global_symbols

◆ local_names

◆ loosy_relocs

◆ symbol_recycle