kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

Fixed compilation errors when USE_DLN_A_OUT

Browse source
This commit is contained in:
Nobuyoshi Nakada 2021-03-12 20:01:03 +09:00
parent 850448abd5
commit c9d0053e67
No known key found for this signature in database
GPG key ID: 7CD2805BFA3770C6
1 changed files with 66 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

103
dln.c
View file

@ -157,6 +157,9 @@ static const char funcname_prefix[sizeof(FUNCNAME_PREFIX) - 1] = FUNCNAME_PREFIX
# define DLN_DEFAULT_LIB_PATH "/lib:/usr/lib:/usr/local/lib:." # define DLN_DEFAULT_LIB_PATH "/lib:/usr/lib:/usr/local/lib:."
#endif #endif
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h> #include <errno.h>
static int dln_errno; static int dln_errno;
@ -188,7 +191,7 @@ static int dln_init_p = 0;
static st_table *sym_tbl; static st_table *sym_tbl;
static st_table *undef_tbl; static st_table *undef_tbl;
static int load_lib(); static int load_lib(const char *);
static int static int
load_header(int fd, struct exec *hdrp, long disp) load_header(int fd, struct exec *hdrp, long disp)
@ -304,7 +307,7 @@ load_sym(int fd, struct exec *hdrp, long disp)
} }
lseek(fd, disp + N_SYMOFF(*hdrp), 0); lseek(fd, disp + N_SYMOFF(*hdrp), 0);
if (read(fd, buffer, hdrp->a_syms + size) != hdrp->a_syms + size) { if (read(fd, buffer, hdrp->a_syms + size) != (ssize_t)(hdrp->a_syms + size)) {
free(buffer); free(buffer);
goto err_noexec; goto err_noexec;
} }
@ -338,7 +341,7 @@ sym_hash(struct exec *hdrp, struct nlist *syms)
} }
while (sym < end) { while (sym < end) {
st_insert(tbl, sym->n_un.n_name, sym); st_insert(tbl, (st_data_t)sym->n_un.n_name, (st_data_t)sym);
sym++; sym++;
} }
return tbl; return tbl;
@ -453,8 +456,9 @@ load_text_data(int fd, struct exec *hdrp, int bss, long disp)
} }
static int static int
undef_print(char *key, char *value) undef_print(st_data_t k, st_data_t v, st_data_t a)
{ {
char *key = (char *)k;
fprintf(stderr, " %s\n", key); fprintf(stderr, " %s\n", key);
return ST_CONTINUE; return ST_CONTINUE;
} }
@ -463,7 +467,7 @@ static void
dln_print_undef(void) dln_print_undef(void)
{ {
fprintf(stderr, " Undefined symbols:\n"); fprintf(stderr, " Undefined symbols:\n");
st_foreach(undef_tbl, undef_print, NULL); st_foreach(undef_tbl, undef_print, 0);
} }
static void static void
@ -514,7 +518,7 @@ link_undef(const char *name, long base, struct relocation_info *reloc)
if (reloc_tbl == NULL) { if (reloc_tbl == NULL) {
reloc_tbl = st_init_numtable(); reloc_tbl = st_init_numtable();
} }
st_insert(reloc_tbl, u_no++, obj); st_insert(reloc_tbl, u_no++, (st_data_t)obj);
} }
struct reloc_arg { struct reloc_arg {
@ -523,8 +527,10 @@ struct reloc_arg {
}; };
static int static int
reloc_undef(int no, struct undef *undef, struct reloc_arg *arg) reloc_undef(st_data_t no, st_data_t v, st_data_t a)
{ {
struct undef *undef = (void *)v;
struct reloc_arg *arg = (void *)a;
int datum; int datum;
char *address; char *address;
#if defined(__sun) && defined(__sparc) #if defined(__sun) && defined(__sparc)
@ -590,7 +596,7 @@ unlink_undef(const char *name, long value)
arg.name = name; arg.name = name;
arg.value = value; arg.value = value;
st_foreach(reloc_tbl, reloc_undef, &arg); st_foreach(reloc_tbl, reloc_undef, (st_data_t)&arg);
} }
#ifdef N_INDR #ifdef N_INDR
@ -599,8 +605,10 @@ struct indr_data {
}; };
static int static int
reloc_repl(int no, struct undef *undef, struct indr_data *data) reloc_repl(st_data_t no, st_data_t v, st_data_t a)
{ {
struct undef *undef = (void *)v;
struct indr_data *data = (void *)a;
if (strcmp(data->name0, undef->name) == 0) { if (strcmp(data->name0, undef->name) == 0) {
free(undef->name); free(undef->name);
undef->name = strdup(data->name1); undef->name = strdup(data->name1);
@ -640,13 +648,15 @@ load_1(int fd, long disp, const char *need_init)
end = syms + (hdr.a_syms / sizeof(struct nlist)); end = syms + (hdr.a_syms / sizeof(struct nlist));
while (sym < end) { while (sym < end) {
struct nlist *old_sym; struct nlist *old_sym;
st_data_t old_data;
int value = sym->n_value; int value = sym->n_value;
#ifdef N_INDR #ifdef N_INDR
if (sym->n_type == (N_INDR | N_EXT)) { if (sym->n_type == (N_INDR | N_EXT)) {
char *key = sym->n_un.n_name; char *key = sym->n_un.n_name;
if (st_lookup(sym_tbl, sym[1].n_un.n_name, &old_sym)) { if (st_lookup(sym_tbl, (st_data_t)sym[1].n_un.n_name, &old_data)) {
old_sym = (struct nlist *)old_data;
if (st_delete(undef_tbl, (st_data_t*)&key, NULL)) { if (st_delete(undef_tbl, (st_data_t*)&key, NULL)) {
unlink_undef(key, old_sym->n_value); unlink_undef(key, old_sym->n_value);
free(key); free(key);
@ -657,9 +667,9 @@ load_1(int fd, long disp, const char *need_init)
data.name0 = sym->n_un.n_name; data.name0 = sym->n_un.n_name;
data.name1 = sym[1].n_un.n_name; data.name1 = sym[1].n_un.n_name;
st_foreach(reloc_tbl, reloc_repl, &data); st_foreach(reloc_tbl, reloc_repl, (st_data_t)&data);
st_insert(undef_tbl, strdup(sym[1].n_un.n_name), NULL); st_insert(undef_tbl, (st_data_t)strdup(sym[1].n_un.n_name), 0);
if (st_delete(undef_tbl, (st_data_t*)&key, NULL)) { if (st_delete(undef_tbl, (st_data_t*)&key, NULL)) {
free(key); free(key);
} }
@ -669,9 +679,12 @@ load_1(int fd, long disp, const char *need_init)
} }
#endif #endif
if (sym->n_type == (N_UNDF | N_EXT)) { if (sym->n_type == (N_UNDF | N_EXT)) {
if (st_lookup(sym_tbl, sym->n_un.n_name, &old_sym) == 0) { if (st_lookup(sym_tbl, (st_data_t)sym->n_un.n_name, &old_data) == 0) {
old_sym = NULL; old_sym = NULL;
} }
else {
old_sym = (struct nlist *)old_data;
}
if (value) { if (value) {
if (old_sym) { if (old_sym) {
@ -680,8 +693,8 @@ load_1(int fd, long disp, const char *need_init)
} }
else { else {
int rnd = int rnd =
value >= sizeof(double) ? sizeof(double) - 1 value >= (int)sizeof(double) ? sizeof(double) - 1
: value >= sizeof(long) ? sizeof(long) - 1 : value >= (int)sizeof(long) ? sizeof(long) - 1
: sizeof(short) - 1; : sizeof(short) - 1;
sym->n_type = N_COMM; sym->n_type = N_COMM;
@ -697,8 +710,8 @@ load_1(int fd, long disp, const char *need_init)
sym->n_value = old_sym->n_value; sym->n_value = old_sym->n_value;
} }
else { else {
sym->n_value = (long)dln_undefined; sym->n_value = (unsigned long)dln_undefined;
st_insert(undef_tbl, strdup(sym->n_un.n_name), NULL); st_insert(undef_tbl, (st_data_t)strdup(sym->n_un.n_name), 0);
} }
} }
} }
@ -711,6 +724,7 @@ load_1(int fd, long disp, const char *need_init)
sym = syms; sym = syms;
while (sym < end) { while (sym < end) {
struct nlist *new_sym; struct nlist *new_sym;
st_data_t new_data;
char *key; char *key;
switch (sym->n_type) { switch (sym->n_type) {
@ -721,8 +735,8 @@ load_1(int fd, long disp, const char *need_init)
sym->n_value += block; sym->n_value += block;
if (st_lookup(sym_tbl, sym->n_un.n_name, &new_sym) != 0 if (st_lookup(sym_tbl, (st_data_t)sym->n_un.n_name, &new_data) != 0
&& new_sym->n_value != (long)dln_undefined) { && (new_sym = (struct nlist *)new_data)->n_value != (unsigned long)dln_undefined) {
dln_errno = DLN_ECONFL; dln_errno = DLN_ECONFL;
goto err_exit; goto err_exit;
} }
@ -736,7 +750,7 @@ load_1(int fd, long disp, const char *need_init)
new_sym = (struct nlist*)xmalloc(sizeof(struct nlist)); new_sym = (struct nlist*)xmalloc(sizeof(struct nlist));
*new_sym = *sym; *new_sym = *sym;
new_sym->n_un.n_name = strdup(sym->n_un.n_name); new_sym->n_un.n_name = strdup(sym->n_un.n_name);
st_insert(sym_tbl, new_sym->n_un.n_name, new_sym); st_insert(sym_tbl, (st_data_t)new_sym->n_un.n_name, (st_data_t)new_sym);
break; break;
case N_TEXT: case N_TEXT:
@ -848,7 +862,7 @@ load_1(int fd, long disp, const char *need_init)
for (sym = syms; sym<end; sym++) { for (sym = syms; sym<end; sym++) {
char *name = sym->n_un.n_name; char *name = sym->n_un.n_name;
if (name[0] == '_' && sym->n_value >= block) { if (name[0] == '_' && sym->n_value >= (unsigned long)block) {
if (strcmp(name+1, "dln_libs_to_be_linked") == 0) { if (strcmp(name+1, "dln_libs_to_be_linked") == 0) {
libs_to_be_linked = (char**)sym->n_value; libs_to_be_linked = (char**)sym->n_value;
} }
@ -889,28 +903,45 @@ load_1(int fd, long disp, const char *need_init)
return -1; return -1;
} }
static int target_offset; struct search_undef_args {
st_table *lib_tbl;
int target_offset;
};
static int static int
search_undef(const char *key, int value, st_table *lib_tbl) search_undef(st_data_t key, st_data_t value, st_data_t a)
{ {
long offset; struct search_undef_args *args = (void *)a;
st_table *lib_tbl = args->lib_tbl;
st_data_t offset;
if (st_lookup(lib_tbl, key, &offset) == 0) return ST_CONTINUE; if (st_lookup(lib_tbl, key, &offset) == 0) return ST_CONTINUE;
target_offset = offset; args->target_offset = (int)offset;
return ST_STOP; return ST_STOP;
} }
static int
search_undef_target(struct st_table *undef_tbl, struct st_table *lib_tbl)
{
struct search_undef_args args;
args.lib_tbl = lib_tbl;
args.target_offset = -1;
st_foreach(undef_tbl, search_undef, (st_data_t)&args);
return args.target_offset;
}
struct symdef { struct symdef {
int rb_str_index; int rb_str_index;
int lib_offset; int lib_offset;
}; };
const char *dln_librrb_ary_path = DLN_DEFAULT_LIB_PATH; const char dln_librrb_ary_path[] = DLN_DEFAULT_LIB_PATH;
static int static int
load_lib(const char *lib) load_lib(const char *lib)
{ {
char *path, *file, fbuf[MAXPATHLEN]; const char *path;
char *file, fbuf[MAXPATHLEN];
char *envpath = 0; char *envpath = 0;
char armagic[SARMAG]; char armagic[SARMAG];
int fd, size; int fd, size;
@ -962,6 +993,7 @@ load_lib(const char *lib)
if (strncmp(ahdr.ar_name, "__.SYMDEF", 9) == 0) { if (strncmp(ahdr.ar_name, "__.SYMDEF", 9) == 0) {
/* make hash table from __.SYMDEF */ /* make hash table from __.SYMDEF */
int target_offset;
lib_tbl = st_init_strtable(); lib_tbl = st_init_strtable();
data = (int*)xmalloc(size); data = (int*)xmalloc(size);
@ -973,14 +1005,11 @@ load_lib(const char *lib)
while (nsym > 0) { while (nsym > 0) {
char *name = name_base + base->rb_str_index; char *name = name_base + base->rb_str_index;
st_insert(lib_tbl, name, base->lib_offset + sizeof(ahdr)); st_insert(lib_tbl, (st_data_t)name, base->lib_offset + sizeof(ahdr));
nsym--; nsym--;
base++; base++;
} }
for (;;) { while ((target_offset = search_undef_target(undef_tbl, lib_tbl)) != -1) {
target_offset = -1;
st_foreach(undef_tbl, search_undef, lib_tbl);
if (target_offset == -1) break;
if (load_1(fd, target_offset, 0) == -1) { if (load_1(fd, target_offset, 0) == -1) {
st_free_table(lib_tbl); st_free_table(lib_tbl);
free(data); free(data);
@ -1018,8 +1047,8 @@ load_lib(const char *lib)
sym = syms; sym = syms;
end = syms + (hdr.a_syms / sizeof(struct nlist)); end = syms + (hdr.a_syms / sizeof(struct nlist));
while (sym < end) { while (sym < end) {
if (sym->n_type == N_EXT|N_TEXT if (sym->n_type == (N_EXT|N_TEXT)
&& st_lookup(undef_tbl, sym->n_un.n_name, NULL)) { && st_lookup(undef_tbl, (st_data_t)sym->n_un.n_name, NULL)) {
break; break;
} }
sym++; sym++;
@ -1075,10 +1104,10 @@ load(const char *file)
void* void*
dln_sym(const char *name) dln_sym(const char *name)
{ {
struct nlist *sym; st_data_t sym;
if (st_lookup(sym_tbl, name, &sym)) if (st_lookup(sym_tbl, (st_data_t)name, &sym))
return (void*)sym->n_value; return (void*)((struct nlist *)sym)->n_value;
return NULL; return NULL;
} }