Hi gcc-help,
I have a three questions about dynamic compilation using gcc which I post
to gcc-help since I have been unable to find much on the issue using FAQs
and Google. I hope someone can provide answers or pointers to information.
Background: I need a function
void *source2dl(const char *source,int flag);
which, given a C source text, compiles the source into a dynamic library
and returns a handle to that library. The signature of source2dl() above
is identical to that of dlopen(), but source2dl() takes a C source as
input where dlopen() takes the pathname of a shared object.
I include a working but in some respects inconvenient implementation of
source2dl() below. My questions come after the implementation of
source2dl().
---------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <dlfcn.h>
//Die with last word from perror
void pdie(const char *msg){perror(msg);exit(0);}
//Die with last word from dlerror
void dldie(const char *msg){printf("%s: %s\n",msg,dlerror());exit(0);}
//Convert source text to dynamic library
void *source2dl(const char *source,int flag){
int fd[2];pid_t pid;int status;void *dl;
//Create pipe for piping source to gcc
if(pipe(fd)<0) pdie("pipe()");
//Fork a gcc, pipe source to it, wait for gcc to exit
pid=fork();
if(pid<0) pdie("fork()");
if(pid==0){
// Child process: close write end of pipe
close(fd[1]);
// Send pipe input to stdin
close(STDIN_FILENO);
dup2(fd[0],STDIN_FILENO);
// Invoke gcc with the following arguments:
// -x c Tell gcc that we provide C source
// -pipe Use pipes between gcc stages
// -fPIC -shared Make shared object
// -Wl,-soname,dl.so Pass suitable options to linker
// -o dl.so Write shared object to dl.so
execl("/usr/bin/gcc","gcc","-x","c","-pipe","-","-fPIC","-shared",
"-Wl,-soname,dl.so","-o","dl.so",(char *)NULL);
// Complain if execl() returns
pdie("execl()");}
//Parent process: close read end of pipe
close(fd[0]);
//Pipe source to gcc
write(fd[1],source,strlen(source));
close(fd[1]);
//Wait for gcc to exit
if(wait(&status)<0) pdie("wait()");
//Load output from gcc and return it
dl=dlopen("./dl.so",flag);
if(!dl) dldie("dlopen()");
return dl;}
//Main program for testing source2dl()
int main(int argc,char *argv[]){
//Set prog to
//#include <stdio.h>
//void fct(){printf("Hello world\n");}
char *prog="#include <stdio.h>\nvoid fct(){printf(\"Hello
world\\n\");}\n";
//Convert prog to dl and extract fct
void (*fct)()=dlsym(source2dl(prog,RTLD_NOW),"fct");
if(!fct) dldie("dlsym()");
//Invoke fct
(*fct)();
return 0;}
---------------------------------------------------------------------
The program above prints "Hello world" to stdout as intended. However,
here are my questions:
Question 1. The dlopen(), dlclose(), dlsym(), and dlerror() functions from
libdl provide a library interface to the dynamic loader. Does there exist
a similar library interface to gcc so that one can avoid the
pipe-fork-execve-wait overhead of running gcc in a separate process?
Question 2. The implementation of source2dl() above uses a temporary file
named dl.so for the shared object produced by gcc and read by dlopen. It
would be convenient if communication from gcc to dlopen could go via a
pipe. Does anyone know a way to tell gcc to write the shared object to
stdout?
Question 3. Following up on Question 2, does anyone know a way to tell
glopen to read the shared object from stdin?
I hope someone listening at gcc-help can help on these questions or give
pointers to information or give suggestions for alternative ways of doing
dynamic compilation.
Cheers,
Klaus
