LDSO_FULLNAME=ld-uClibc-$(MAJOR_VERSION).$(MINOR_VERSION).so

TARGET_CFLAGS+=-fPIC -D__PIC__ -DUCLIBC_ROOT_DIR=\"$(DEVEL_PREFIX)\" -DUCLIBC_BUILD_DIR=\"$(shell cd $(TOPDIR); pwd)\"

COBJS=$(patsubst %.c,%.o, $(CSRC))

ASRC=$(shell ls $(TARGET_ARCH)/*.S)

AOBJS=$(patsubst %.S,%.o, $(ASRC))

strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);

if (reloc_type != R_ARM_JUMP_SLOT) {

_dl_progname);

_dl_exit(1);

};

got_addr = (char **) instr_addr;

#ifdef DL_DEBUG

strtab + symtab[symtab_index].st_name);

#endif

new_addr = _dl_find_hash(strtab + symtab[symtab_index].st_name,

tpnt->symbol_scope, (unsigned long) got_addr, tpnt, 0);

if (!new_addr) {

_dl_progname, strtab + symtab[symtab_index].st_name);

_dl_exit(1);

};

#ifdef DL_DEBUG

if ((unsigned long) got_addr < 0x40000000) {

strtab + symtab[symtab_index].st_name);

} else {

*got_addr = new_addr;

*reloc_addr += (unsigned long) tpnt->loadaddr;

break;

default:

_dl_progname);

#ifdef VERBOSE_DLINKER

#endif

if (symtab_index)

_dl_exit(1);

};

};

* here, so all bases should be covered.

*/

if (!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_GLOBAL) {

_dl_progname, strtab + symtab[symtab_index].st_name);

goof++;

}

topbits = newvalue & 0xfe000000;

if (topbits != 0xfe000000 && topbits != 0x00000000)

{

_dl_exit(1);

}

}

case R_ARM_COPY:

#if 0

/* Do this later */

_dl_memcpy((void *) symtab[symtab_index].st_value,

(void *) symbol_addr, symtab[symtab_index].st_size);

#endif

break;

default:

#ifdef VERBOSE_DLINKER

#endif

if (symtab_index)

_dl_exit(1);

};

symtab[symtab_index].st_name, xpnt->next,

(unsigned long) reloc_addr, NULL, 1);

if (!symbol_addr) {

_dl_progname, strtab + symtab[symtab_index].st_name);

goof++;

};

#include "ld.so.h" /* Pull in the name of ld.so */

const char *_dl_progname=_dl_static_progname;

static char *_dl_not_lazy = 0;

static char *_dl_trace_loaded_objects = 0;

static int (*_dl_elf_main) (int, char **, char **);

static int (*_dl_elf_init) (void);

void *(*_dl_malloc_function) (int size) = NULL;

aux_dat += 2;

}

* (esp since SEND_STDERR() needs this on some platforms... */

load_addr = auxv_t[AT_BASE].a_un.a_val;

header = (elfhdr *) auxv_t[AT_BASE].a_un.a_ptr;

}

}

_dl_trace_loaded_objects = _dl_getenv("LD_TRACE_LOADED_OBJECTS", envp);

/* OK, we now have the application in the list, and we have some

basic stuff in place. Now search through the list for other shared

libraries that should be loaded, and insert them on the list in the

{

tpnt1 = _dl_load_shared_library(_dl_secure, NULL, str);

if (!tpnt1) {

if (_dl_trace_loaded_objects)

else {

"library '%s'\n", _dl_progname, str);

_dl_exit(15);

}

} else {

if (_dl_trace_loaded_objects

&& !tpnt1->usage_count) {

/* this is a real hack to make ldd not print

* the library itself when run on a library. */

if (_dl_strcmp(_dl_progname, str) != 0)

(unsigned) tpnt1->loadaddr);

}

rpnt->next = (struct dyn_elf *)

_dl_malloc(sizeof(struct dyn_elf));

_dl_memset(rpnt->next, 0, sizeof(*(rpnt->next)));

if (!_dl_stat(LDSO_PRELOAD, &st)) {

if ((fd = _dl_open(LDSO_PRELOAD, O_RDONLY)) < 0) {

_dl_progname, LDSO_PRELOAD);

} else {

preload = (caddr_t) _dl_mmap(0, st.st_size + 1,

PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);

_dl_close(fd);

if (preload == (caddr_t) - 1) {

_dl_progname, LDSO_PRELOAD);

} else {

char c, *cp, *cp2;

tpnt1 = _dl_load_shared_library(0, NULL, cp2);

if (!tpnt1) {

if (_dl_trace_loaded_objects)

else {

_dl_progname, cp2);

_dl_exit(15);

} else {

if (_dl_trace_loaded_objects

&& !tpnt1->usage_count) {

tpnt1->libname, (unsigned) tpnt1->loadaddr);

}

rpnt->next = (struct dyn_elf *)

_dl_malloc(sizeof(struct dyn_elf));

_dl_memset(rpnt->next, 0,

_dl_get_last_path_component(tpnt->libname)) == 0) {

struct elf_resolve *ttmp;

if (_dl_trace_loaded_objects && !tpnt->usage_count) {

lpnt, tpnt->libname, (unsigned) tpnt->loadaddr);

}

ttmp = _dl_loaded_modules;

while (ttmp->next)

ttmp = ttmp->next;

continue;

}

if (!(tpnt1 = _dl_load_shared_library(0, tcurr, lpnt))) {

if (_dl_trace_loaded_objects)

else {

_dl_progname, lpnt);

_dl_exit(16);

}

} else {

if (_dl_trace_loaded_objects && !tpnt1->usage_count)

(unsigned) tpnt1->loadaddr);

rpnt->next = (struct dyn_elf *)

_dl_malloc(sizeof(struct dyn_elf));

_dl_memset(rpnt->next, 0, sizeof(*(rpnt->next)));

_dl_unmap_cache();

#endif

/* ldd uses uses this. I am not sure how you pick up the other flags */

if (_dl_trace_loaded_objects) {

_dl_warn = _dl_getenv("LD_WARN", envp);

if (!_dl_warn)

_dl_exit(0);

}

/*

* If the program interpreter is not in the module chain, add it. This will

if (_dl_symbol_tables)

goof += _dl_copy_fixups(_dl_symbol_tables);

if (goof || _dl_trace_loaded_objects)

_dl_exit(0);

/* OK, at this point things are pretty much ready to run. Now we

need to touch up a few items that are required, and then

#undef DL_DEBUG

#ifdef DL_DEBUG

else {

if (!_dl_atexit)

if (!tpnt->dynamic_info[DT_FINI])

}

#endif

#undef DL_DEBUG

goof += _dl_fixup(tpnt->next);

if (tpnt->dynamic_info[DT_REL]) {

#ifdef ELF_USES_RELOCA

_dl_progname);

_dl_exit(17);

#else

goof += _dl_parse_relocation_information(tpnt,

tpnt->dynamic_info[DT_RELA], tpnt->dynamic_info[DT_RELASZ], 0);

#else

_dl_progname);

_dl_exit(18);

#endif

_dl_mmap_zero = _dl_malloc_addr = _dl_mmap((void *) 0, size,

PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);

if (_dl_mmap_check_error(_dl_mmap_zero)) {

_dl_exit(20);

}

}

return str;

}

if (_dl_stat(LDSO_CACHE, &st)

|| (fd = _dl_open(LDSO_CACHE, O_RDONLY)) < 0) {

_dl_cache_addr = (caddr_t) - 1; /* so we won't try again */

return -1;

}

_dl_cache_addr = (caddr_t) _dl_mmap(0, _dl_cache_size, PROT_READ, MAP_SHARED, fd, 0);

_dl_close(fd);

if (_dl_cache_addr == (caddr_t) - 1) {

_dl_progname, LDSO_CACHE);

return -1;

}

(sizeof(header_t) + header->nlibs * sizeof(libentry_t))

|| _dl_cache_addr[_dl_cache_size - 1] != '\0')

{

LDSO_CACHE);

goto fail;

}

if (libent[i].sooffset >= strtabsize ||

libent[i].liboffset >= strtabsize)

{

goto fail;

}

}

* NO! When we open shared libraries we may search several paths.

* it is inappropriate to generate an error here.

*/

#endif

_dl_internal_error_number = DL_ERROR_NOFILE;

return NULL;

epnt->e_ident[2] != 'L' ||

epnt->e_ident[3] != 'F')

{

libname);

_dl_internal_error_number = DL_ERROR_NOTELF;

_dl_close(infile);

{

_dl_internal_error_number =

(epnt->e_type != ET_DYN ? DL_ERROR_NOTDYN : DL_ERROR_NOTMAGIC);

"\n", _dl_progname, libname);

_dl_close(infile);

return NULL;

if (ppnt->p_type == PT_DYNAMIC) {

if (dynamic_addr)

_dl_progname, libname);

dynamic_addr = ppnt->p_vaddr;

dynamic_size = ppnt->p_filesz;

status = (char *) _dl_mmap((char *) (piclib ? 0 : minvma),

maxvma - minvma, PROT_NONE, flags | MAP_ANONYMOUS, -1, 0);

if (_dl_mmap_check_error(status)) {

_dl_internal_error_number = DL_ERROR_MMAP_FAILED;

_dl_close(infile);

return NULL;

ppnt->p_offset & 0x7ffff000);

if (_dl_mmap_check_error(status)) {

_dl_progname, libname);

_dl_internal_error_number = DL_ERROR_MMAP_FAILED;

_dl_munmap((char *) libaddr, maxvma - minvma);

ppnt->p_filesz, LXFLAGS(ppnt->p_flags), flags,

infile, ppnt->p_offset & 0x7ffff000);

if (_dl_mmap_check_error(status)) {

_dl_internal_error_number = DL_ERROR_MMAP_FAILED;

_dl_munmap((char *) libaddr, maxvma - minvma);

_dl_close(infile);

if (!dynamic_addr) {

_dl_internal_error_number = DL_ERROR_NODYNAMIC;

_dl_progname, libname);

return NULL;

}

int copyrel);

extern int _dl_linux_dynamic_link(void);

extern char * _dl_library_path;

extern char * _dl_not_lazy;

extern unsigned long _dl_elf_hash(const char * name);

static inline int _dl_symbol(char * name)

if (reloc_type != R_386_JMP_SLOT) {

_dl_progname);

_dl_exit(1);

};

got_addr = (char **) instr_addr;

#ifdef DEBUG

strtab + symtab[symtab_index].st_name);

#endif

new_addr = _dl_find_hash(strtab + symtab[symtab_index].st_name,

tpnt->symbol_scope, (unsigned long) got_addr, tpnt, 0);

if (!new_addr) {

_dl_progname, strtab + symtab[symtab_index].st_name);

_dl_exit(1);

};

/* #define DEBUG_LIBRARY */

#ifdef DEBUG_LIBRARY

if ((unsigned long) got_addr < 0x40000000) {

strtab + symtab[symtab_index].st_name);

} else {

*got_addr = new_addr;

*reloc_addr += (unsigned long) tpnt->loadaddr;

break;

default:

_dl_progname);

#ifdef VERBOSE_DLINKER

#endif

if (symtab_index)

_dl_exit(1);

};

};

*/

if (!symbol_addr &&

ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_GLOBAL) {

_dl_progname, strtab + symtab[symtab_index].st_name);

goof++;

}

case R_386_COPY:

#if 0

/* Do this later */

_dl_memcpy((void *) symtab[symtab_index].st_value,

(void *) symbol_addr, symtab[symtab_index].st_size);

#endif

break;

default:

#ifdef VERBOSE_DLINKER

#endif

if (symtab_index)

_dl_exit(1);

};

symtab[symtab_index].st_name, xpnt->next,

(unsigned long) reloc_addr, NULL, 1);

if (!symbol_addr) {

_dl_progname, strtab + symtab[symtab_index].st_name);

goof++;

};

#include "ld.so.h" /* Pull in the name of ld.so */

const char *_dl_progname=_dl_static_progname;

static char *_dl_not_lazy = 0;

static char *_dl_trace_loaded_objects = 0;

static int (*_dl_elf_main) (int, char **, char **);

static int (*_dl_elf_init) (void);

void *(*_dl_malloc_function) (int size) = NULL;

aux_dat += 2;

}

* (esp since SEND_STDERR() needs this on some platforms... */

load_addr = auxv_t[AT_BASE].a_un.a_val;

header = (elfhdr *) auxv_t[AT_BASE].a_un.a_ptr;

}

}

_dl_trace_loaded_objects = _dl_getenv("LD_TRACE_LOADED_OBJECTS", envp);

/* OK, we now have the application in the list, and we have some

basic stuff in place. Now search through the list for other shared

libraries that should be loaded, and insert them on the list in the

{

tpnt1 = _dl_load_shared_library(_dl_secure, NULL, str);

if (!tpnt1) {

if (_dl_trace_loaded_objects)

else {

"library '%s'\n", _dl_progname, str);

_dl_exit(15);

}

} else {

if (_dl_trace_loaded_objects

&& !tpnt1->usage_count) {

/* this is a real hack to make ldd not print

* the library itself when run on a library. */

if (_dl_strcmp(_dl_progname, str) != 0)

(unsigned) tpnt1->loadaddr);

}

rpnt->next = (struct dyn_elf *)

_dl_malloc(sizeof(struct dyn_elf));

_dl_memset(rpnt->next, 0, sizeof(*(rpnt->next)));

if (!_dl_stat(LDSO_PRELOAD, &st)) {

if ((fd = _dl_open(LDSO_PRELOAD, O_RDONLY)) < 0) {

_dl_progname, LDSO_PRELOAD);

} else {

preload = (caddr_t) _dl_mmap(0, st.st_size + 1,

PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);

_dl_close(fd);

if (preload == (caddr_t) - 1) {

_dl_progname, LDSO_PRELOAD);

} else {

char c, *cp, *cp2;

tpnt1 = _dl_load_shared_library(0, NULL, cp2);

if (!tpnt1) {

if (_dl_trace_loaded_objects)

else {

_dl_progname, cp2);

_dl_exit(15);

} else {

if (_dl_trace_loaded_objects

&& !tpnt1->usage_count) {

tpnt1->libname, (unsigned) tpnt1->loadaddr);

}

rpnt->next = (struct dyn_elf *)

_dl_malloc(sizeof(struct dyn_elf));

_dl_memset(rpnt->next, 0,

_dl_get_last_path_component(tpnt->libname)) == 0) {

struct elf_resolve *ttmp;

if (_dl_trace_loaded_objects && !tpnt->usage_count) {

lpnt, tpnt->libname, (unsigned) tpnt->loadaddr);

}

ttmp = _dl_loaded_modules;

while (ttmp->next)

ttmp = ttmp->next;

continue;

}

if (!(tpnt1 = _dl_load_shared_library(0, tcurr, lpnt))) {

if (_dl_trace_loaded_objects)

else {

_dl_progname, lpnt);

_dl_exit(16);

}

} else {

if (_dl_trace_loaded_objects && !tpnt1->usage_count)

(unsigned) tpnt1->loadaddr);

rpnt->next = (struct dyn_elf *)

_dl_malloc(sizeof(struct dyn_elf));

_dl_memset(rpnt->next, 0, sizeof(*(rpnt->next)));

_dl_unmap_cache();

#endif

/* ldd uses uses this. I am not sure how you pick up the other flags */

if (_dl_trace_loaded_objects) {

_dl_warn = _dl_getenv("LD_WARN", envp);

if (!_dl_warn)

_dl_exit(0);

}

/*

* If the program interpreter is not in the module chain, add it. This will

if (_dl_symbol_tables)

goof += _dl_copy_fixups(_dl_symbol_tables);

if (goof || _dl_trace_loaded_objects)

_dl_exit(0);

/* OK, at this point things are pretty much ready to run. Now we

need to touch up a few items that are required, and then

#undef DL_DEBUG

#ifdef DL_DEBUG

else {

if (!_dl_atexit)

if (!tpnt->dynamic_info[DT_FINI])

}

#endif

#undef DL_DEBUG

goof += _dl_fixup(tpnt->next);

if (tpnt->dynamic_info[DT_REL]) {

#ifdef ELF_USES_RELOCA

_dl_progname);

_dl_exit(17);</