This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/C/load_dl.c

271 lines
6.5 KiB
C
Raw Normal View History

/*************************************************************************
2017-11-08 09:29:01 +00:00
* *
* YAP Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* *
**************************************************************************
* *
* File: load_dl.c *
* comments: dl based dynamic loaderr of external routines *
* tested on i486-linuxelf *
*************************************************************************/
#include "Yap.h"
#include "YapHeap.h"
2016-04-05 02:22:04 +01:00
#include "Yatom.h"
#include "yapio.h"
2016-04-05 02:22:04 +01:00
#include "Foreign.h"
#if LOAD_DL
2014-03-04 12:00:13 +00:00
// use SWI-Prolog code if all else fails
2016-04-05 02:22:04 +01:00
char *findExecutable(const char *av0, char *buffer);
2014-03-04 12:00:13 +00:00
#include <dlfcn.h>
#include <stdio.h>
2016-04-05 02:22:04 +01:00
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
2013-01-13 17:55:13 +00:00
#if defined(__APPLE__)
2015-06-18 00:24:47 +01:00
#include <dlfcn.h>
2016-04-05 02:22:04 +01:00
#include <mach-o/dyld.h>
2015-06-18 00:24:47 +01:00
#endif
typedef void (*prismf)(void);
/* only works for dlls */
2016-04-05 02:22:04 +01:00
int Yap_CallFunctionByName(const char *thing_string);
2016-04-05 02:22:04 +01:00
int Yap_CallFunctionByName(const char *thing_string) {
void *handle = dlopen(NULL, RTLD_LAZY
2012-04-18 20:14:56 +01:00
#ifndef __CYGWIN__
#ifdef RTLD_NOLOAD
2016-04-05 02:22:04 +01:00
| RTLD_NOLOAD
#endif
2012-04-18 20:14:56 +01:00
#endif
2017-11-08 09:29:01 +00:00
);
// you could do RTLD_NOW as well. shouldn't matter
if (!handle) {
CACHE_REGS
2016-04-05 02:22:04 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1,
"Dynamic linking on main module : %s\n", dlerror());
}
2016-04-05 02:22:04 +01:00
prismf *addr = (prismf *)dlsym(handle, thing_string);
if (addr)
(*addr)();
dlclose(handle);
return TRUE;
}
/*
* YAP_FindExecutable(argv[0]) should be called on yap initialization to
* locate the executable of Yap
2017-11-08 09:29:01 +00:00
*/
2016-04-05 02:22:04 +01:00
char *Yap_FindExecutable(void) {
2013-01-13 17:55:13 +00:00
#if HAVE_GETEXECNAME
2014-03-04 12:00:13 +00:00
// Solaris
return getexecname();
2013-01-13 17:55:13 +00:00
#elif __APPLE__
2016-07-31 10:29:47 +01:00
char *buf = malloc(YAP_FILENAME_MAX);
2014-03-06 15:39:56 +00:00
2016-07-31 10:29:47 +01:00
uint32_t size;
if (!_NSGetExecutablePath(buf, &size)) {
buf = realloc(buf, size + 1);
2014-03-06 15:39:56 +00:00
return buf;
2017-11-08 09:29:01 +00:00
}
return "yap";
2014-03-04 12:00:13 +00:00
#elif defined(__linux__)
2017-11-15 12:18:19 +00:00
char *buf = malloc(YAP_FILENAME_MAX);
ssize_t len = readlink("/proc/self/exe", buf, YAP_FILENAME_MAX - 1);
2016-04-05 02:22:04 +01:00
2014-03-04 12:00:13 +00:00
if (len != -1) {
buf[len] = '\0';
return buf;
}
2016-04-05 02:22:04 +01:00
// follow through to standard method
#elif defined(__FreeBSD__) || defined(__DragonFly__)
2014-03-04 12:00:13 +00:00
enum { BUFFERSIZE = 1024 };
char *buf = malloc(BUFFERSIZE);
2016-04-05 02:22:04 +01:00
ssize_t len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
2014-03-04 12:00:13 +00:00
if (len != -1) {
buf[len] = '\0';
return buf;
}
int mib[4];
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_PATHNAME;
mib[3] = -1; // current process
size_t cb = BUFFERSIZE;
sysctl(mib, 4, buf, &cb, NULL, 0);
2016-04-05 02:22:04 +01:00
// follow through to standard method
2013-01-13 17:55:13 +00:00
#endif
2016-04-05 02:22:04 +01:00
return NULL;
}
2016-04-05 02:22:04 +01:00
void *Yap_LoadForeignFile(char *file, int flags) {
2015-11-09 11:26:22 +00:00
CACHE_REGS
int dlflag;
2010-06-18 10:30:23 +01:00
void *out;
2016-04-05 02:22:04 +01:00
if (flags & EAGER_LOADING)
dlflag = RTLD_NOW;
else
dlflag = RTLD_LAZY;
2016-04-05 02:22:04 +01:00
if (flags & GLOBAL_LOADING)
dlflag |= RTLD_GLOBAL;
2010-08-03 01:11:13 +01:00
#ifndef __CYGWIN__
2016-04-05 02:22:04 +01:00
else
dlflag |= RTLD_LOCAL;
2010-08-03 01:11:13 +01:00
#endif
2016-08-23 15:51:39 +01:00
out = (void *)dlopen(file, dlflag);
2015-11-09 11:26:22 +00:00
if (out == NULL) {
2016-04-05 02:22:04 +01:00
const char *m_os = dlerror();
2015-11-18 15:06:25 +00:00
if (m_os) {
2016-10-20 04:44:59 +01:00
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
strncpy(LOCAL_ErrorMessage, m_os, MAX_ERROR_MSG_SIZE - 1);
2015-11-18 15:06:25 +00:00
} else {
LOCAL_ErrorMessage = "dlopen failed";
}
2010-06-18 10:30:23 +01:00
}
return out;
}
2016-04-05 02:22:04 +01:00
int Yap_CallForeignFile(void *handle, char *f) {
YapInitProc proc = (YapInitProc)dlsym(handle, f);
2010-06-18 10:30:23 +01:00
if (!proc) {
2015-09-25 10:57:26 +01:00
/* Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "dlsym error %s\n", dlerror());*/
return FALSE;
2010-06-18 10:30:23 +01:00
}
2016-04-05 02:22:04 +01:00
(*proc)();
return TRUE;
}
2016-04-05 02:22:04 +01:00
int Yap_CloseForeignFile(void *handle) {
if (dlclose(handle) < 0) {
CACHE_REGS
2015-09-25 10:57:26 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "dlclose error %s\n", dlerror());
2010-06-18 10:30:23 +01:00
return -1;
}
return 0;
}
/*
* LoadForeign(ofiles,libs,proc_name,init_proc) dynamically loads foreign
* code files and libraries and locates an initialization routine
2017-11-08 09:29:01 +00:00
*/
2017-12-05 15:14:57 +00:00
static Int LoadForeign(StringList
ofiles, StringList libs, char *proc_name,
2016-04-05 02:22:04 +01:00
YapInitProc *init_proc) {
CACHE_REGS
2017-05-08 18:51:29 +01:00
LOCAL_ErrorMessage = NULL;
while (libs) {
const char *file = AtomName(libs->name);
#ifdef __osf__
2016-04-05 02:22:04 +01:00
if ((libs->handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY)) == NULL)
#else
2017-12-10 01:22:45 +00:00
if ((libs->handle = dlopen(file, RTLD_LAZY | RTLD_GLOBAL)) ==
2017-11-08 09:29:01 +00:00
NULL)
#endif
2017-11-08 09:29:01 +00:00
{
if (LOCAL_ErrorMessage == NULL) {
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
strcpy(LOCAL_ErrorMessage, dlerror());
}
}
libs = libs->next;
}
while (ofiles) {
2016-04-05 02:22:04 +01:00
/* load libraries first so that their symbols are available to
other routines */
const char *file = AtomName(ofiles->name);
2017-12-10 01:22:45 +00:00
if ((ofiles->handle = dlopen(file, RTLD_LAZY | RTLD_GLOBAL)) ==
2017-11-08 09:29:01 +00:00
NULL)
{
2017-11-08 09:29:01 +00:00
if (LOCAL_ErrorMessage == NULL) {
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
fprintf(stderr, "dlopen of image %s failed: %s\n", LOCAL_FileNameBuf,
dlerror());
2017-05-08 18:51:29 +01:00
}
}
2017-11-08 09:29:01 +00:00
if (ofiles->handle && proc_name && !*init_proc)
*init_proc = (YapInitProc)dlsym(ofiles->handle, proc_name);
ofiles = ofiles->next;
2017-11-08 09:29:01 +00:00
}
2017-11-08 09:29:01 +00:00
if (!*init_proc && LOCAL_ErrorMessage == NULL) {
char *buf = malloc(1058);
snprintf(buf, 1058 - 1, "Could not locate routine %s in %s: %s\n",
proc_name, LOCAL_FileNameBuf, dlerror());
return LOAD_FAILLED;
2017-11-08 09:29:01 +00:00
}
return LOAD_SUCCEEDED;
}
2016-04-05 02:22:04 +01:00
Int Yap_LoadForeign(StringList ofiles, StringList libs, char *proc_name,
YapInitProc *init_proc) {
return LoadForeign(ofiles, libs, proc_name, init_proc);
}
2016-04-05 02:22:04 +01:00
void Yap_ShutdownLoadForeign(void) {
ForeignObj *f_code;
f_code = ForeignCodeLoaded;
while (f_code != NULL) {
StringList objs, libs, old;
ForeignObj *of_code = f_code;
objs = f_code->objs;
while (objs != NULL) {
old = objs;
if (dlclose(objs->handle) != 0)
2016-04-05 02:22:04 +01:00
return; /* ERROR */
objs = objs->next;
2013-01-13 17:55:13 +00:00
Yap_FreeCodeSpace((ADDR)old);
}
libs = f_code->libs;
while (libs != NULL) {
old = libs;
if (dlclose(libs->handle) != 0)
2016-04-05 02:22:04 +01:00
return; /* ERROR */
libs = libs->next;
2013-01-13 17:55:13 +00:00
Yap_FreeCodeSpace((ADDR)old);
}
f_code = f_code->next;
Yap_FreeCodeSpace((ADDR)of_code);
}
/*
make sure that we don't try to close foreign code several times, eg,
from within an error handler
*/
ForeignCodeLoaded = NULL;
}
2016-04-05 02:22:04 +01:00
Int Yap_ReLoadForeign(StringList ofiles, StringList libs, char *proc_name,
YapInitProc *init_proc) {
return (LoadForeign(ofiles, libs, proc_name, init_proc));
}
#endif
#if SIMICS
2016-04-05 02:22:04 +01:00
void dlopen(void) {}
2016-04-05 02:22:04 +01:00
void dlclose(void) {}
2016-04-05 02:22:04 +01:00
void dlsym(void) {}
#endif