Make library executable; Minimize Plugin deps(!!); other minor tweaks

Author: jasonnyberg

CMakeLists.txt

@@ -1,24 +1,32 @@
 cmake_minimum_required(VERSION 2.6)
 
-project(j2 LANGUAGES C)
+project(jj LANGUAGES C)
 
 add_definitions(-std=gnu99)
 add_definitions(-ggdb3)
 add_definitions(-fdebug-types-section)
 add_definitions(-fno-eliminate-unused-debug-types)
-add_definitions(-DLTTNG)
 add_definitions(-fdebug-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/=)
+add_definitions(-ftls-model=local-dynamic)
 
 include_directories(.)
 
 #add_definitions(-O3)
 #add_definitions(-gdwarf-4)
 
-add_library(reflect SHARED trace.c util.c cll.c listree.c reflect.c compile.c vm.c extensions.c)
-add_executable(jj jj.c)
-target_link_libraries(jj reflect dwarf elf dw dl ffi pthread urcu urcu-bp urcu-common lttng-ust lttng-ctl lttng-ust-tracepoint)
+# build a shared library that is also an executable(!!)
+add_library(reflect SHARED trace.c util.c cll.c listree.c reflect.c compile.c vm.c extensions.c jj.c)
+target_compile_options(reflect PUBLIC "-fPIC")
+target_link_libraries(reflect "-pie -Wl,-E")
+
+target_link_libraries(reflect dwarf elf dw dl ffi pthread)
+
+add_definitions(-DLTTNG)
+target_link_libraries(reflect urcu urcu-bp urcu-common lttng-ust lttng-ctl lttng-ust-tracepoint)
 
-set_property(TARGET reflect jj PROPERTY POSITION_INDEPENDENT_CODE ON)
+# build a demo executable that dynamically links reflection as a plugin
+add_executable(jj jj_plugin.c)
+target_link_libraries(jj dl)
 
 install(TARGETS reflect jj
         RUNTIME DESTINATION bin COMPONENT j2

bootstrap.edict

@@ -20,7 +20,8 @@
 [a b int_add! a@ limit int_nequal! slowloop!]@slowloop
 [int! @limit limit@ int! 0@ @a int! 1@ @b slowloop! | locals!]@slowbench
 
-[vm_eval(ROOT [ROOT<ARG0 decaps! stack! ! encaps! <RETURN>@>] [square(3)]) stack!]@async_test1
+[square(3)]@square3
+[vm_eval(ROOT [ROOT<ARG0 decaps! stack! ! encaps! <RETURN>@>] [square3!]) stack!]@async_test1
 
 [[]<@thunk @root @sig encaps(vm_continuation(encaps(sig) root thunk))>/]@continuation
 [[]<@continuation @arg vm_async(continuation arg)@thread>]@async
@@ -35,6 +36,8 @@
  stack!
  ]@async_test7
 
+[vm_eval(ROOT [ROOT<ARG0 decaps! stack! ! encaps! <RETURN>@>] [testimport3!]) stack!]@async_test8
+
 [minus(1)]@decrement
 
 [[[repl(get_stdin!)|]! repeat!]@repeat repeat!]/

extensions.c

@@ -74,8 +74,7 @@ extern void vm_try(int exp) { if (exp) vm_throw(LTV_NULL); }
 
 extern FILE *file_open(char *filename,char *opts) { return fopen(filename,opts); }
 extern void file_close(FILE *fp) { fclose(fp); }
-extern void pinglib(char *filename)
-{
+extern void pinglib(char *filename) {
     void *dlhandle=dlopen(filename,RTLD_LAZY | RTLD_GLOBAL | RTLD_NODELETE | RTLD_DEEPBIND);
     if (!dlhandle)
         fprintf(OUTFILE,"dlopen error: handle %x %s\n",dlhandle,dlerror());

jj.c

@@ -33,10 +33,14 @@
  * not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "reflect.h" // cif_init
 #include "vm.h"
 
 const char *bootstrap=
     "[@input_stream [brl(input_stream) ! lambda!]@lambda lambda! |]@repl\n" // define repl
     "ROOT<repl(get_stdin())> [RETURN] ARG0 @";                              // read from stdin
 
-int main(int argc, char *argv[]) { return vm_bootstrap(argc>1?argv[1]:(char *) bootstrap); }
+int main(int argc, char *argv[]) {
+    cif_init(1); // must dlopen NULL when running as executable
+    return vm_bootstrap(argc > 1 ? argv[1] : (char *)bootstrap);
+}

jj_plugin.c

@@ -0,0 +1,75 @@
+/*
+ * j2 - A simple concatenative programming language that can understand
+ *      the structure of and dynamically link with compatible C binaries.
+ *
+ * Copyright (C) 2011 Jason Nyberg <jasonnyberg@gmail.com>
+ * Copyright (C) 2018 Jason Nyberg <jasonnyberg@gmail.com> (dual-licensed)
+ * (C) Copyright 2019 Hewlett Packard Enterprise Development LP.
+ *
+ * This file is part of j2.
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either
+ *
+ *   * the GNU Lesser General Public License as published by the Free
+ *     Software Foundation; either version 3 of the License, or (at
+ *     your option) any later version
+ *
+ * or
+ *
+ *   * the GNU General Public License as published by the Free
+ *     Software Foundation; either version 3 of the License, or (at
+ *     your option) any later version
+ *
+ * or both in parallel, as here.
+ *
+ * j2 is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received copies of the GNU General Public License and
+ * the GNU Lesser General Public License along with this program.  If
+ * not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+#include "vm.h"
+
+const char *bootstrap=
+    "[@input_stream [brl(input_stream) ! lambda!]@lambda lambda! |]@repl\n" // define repl
+    "ROOT<repl(get_stdin())> [RETURN] ARG0 @";                              // read from stdin
+
+int main(int argc, char *argv[]) { return vm_bootstrap(argc>1?argv[1]:(char *) bootstrap); }
+*/
+
+
+#include <stdio.h>
+#include <dlfcn.h> // dlopen/dlsym/dlclose
+
+const char *bootstrap =
+    "[@input_stream [brl(input_stream) ! lambda!]@lambda lambda! |]@repl\n" // define repl
+    "ROOT<repl(get_stdin())> [RETURN] ARG0 @";
+
+int main(int argc, char *argv[]) {
+    int status = 0;
+    void *dlhandle = NULL;
+
+    dlerror(); // reset
+    dlhandle = dlopen("libreflect.so", RTLD_LAZY | RTLD_GLOBAL | RTLD_NODELETE | RTLD_DEEPBIND);
+    if (!dlhandle) {
+        printf("dlopen libreflect.so failed, error %s\n", dlerror());
+        goto done;
+    }
+
+    dlerror(); // reset
+    int *(*vm_bootstrap)(char *) = dlsym(dlhandle, "vm_bootstrap");
+    if (vm_bootstrap) {
+        vm_bootstrap(argc > 1 ? argv[1] : (char *) bootstrap);
+    }
+
+    dlclose(dlhandle);
+done:
+    return status;
+}
+

makefile

@@ -6,6 +6,9 @@ SHELL:=bash
 
 all: compile
 
+# makefile version of reflection-as-plugin demo
+jj: jj_plugin.c ; gcc -g jj_plugin.c -o jj -ldl
+
 switch-compiler:; sudo update-alternatives --config c++
 build:; mkdir build
 cmake: build; cd build && cmake ..

reflect.c

@@ -61,18 +61,17 @@ static int cif_curate_module(LTV *module, int bootstrap);
 
 LTV *cif_module = NULL; // initialized/populated during bootstrap
 
-__attribute__((constructor))
-static void init(void)
-{
-    Dl_info dl_info;
-    dladdr((void *)init, &dl_info);
-    fprintf(ERRFILE,CODE_RED "reflection module path is: %s" CODE_RESET "\n",dl_info.dli_fname);
-    cif_module=LTV_init(NEW(LTV),(char *) dl_info.dli_fname,strlen(dl_info.dli_fname),LT_DUP|LT_RO);
-    try_depth=1;
-    cif_preview_module(cif_module);
-
-    print_ltv(ERRFILE,CODE_RED,cif_module,CODE_RESET "\n",0);
-    cif_curate_module(cif_module,true);
+void cif_init(int bootstrap) {
+    if (!cif_module) {
+        Dl_info dl_info;
+        dladdr((void *)cif_init, &dl_info);
+        fprintf(ERRFILE, CODE_RED "reflection module path is: %s" CODE_RESET "\n", dl_info.dli_fname);
+        cif_module = LTV_init(NEW(LTV), (char *)dl_info.dli_fname, strlen(dl_info.dli_fname), LT_DUP | LT_RO);
+        cif_preview_module(cif_module);
+
+        print_ltv(ERRFILE, CODE_RED, cif_module, CODE_RESET "\n", 0);
+        cif_curate_module(cif_module, bootstrap);
+    }
 }
 
 char *Type_pushUVAL(TYPE_UVALUE *uval,char *buf);
@@ -1588,7 +1587,7 @@ int cif_curate_module(LTV *module,int bootstrap)
 
     int resolve_symbols(char *filename) {
         char *f=bootstrap?NULL:filename;
-        if (!(dlhandle=dlopen(f,RTLD_LAZY | RTLD_GLOBAL | RTLD_NODELETE | RTLD_DEEPBIND)))
+        if (!(dlhandle = dlopen(f, RTLD_LAZY | RTLD_GLOBAL | RTLD_NODELETE | RTLD_DEEPBIND)))
             fprintf(OUTFILE,"failed while dlopen'ing %s; continuing without resolving global functions/variables\n",dlerror());
 
         STRY(ltv_traverse(index[1],resolve_types,resolve_types)!=NULL,"linking symbolic type info names"); // links symbols on pre- and post-passes

reflect.h

@@ -182,6 +182,8 @@ typedef struct
 
 extern LTV *cif_module;
 
+void cif_init(int bootstrap);
+
 extern LTV *cif_create_cvar(LTV *type,void *data,char *member);
 extern LTV *cif_assign_cvar(LTV *cvar,LTV *ltv);
 extern int cif_print_cvar(FILE *ofile,LTV *ltv,int depth);

util.c

@@ -48,7 +48,7 @@ __thread FILE *ERRFILE_VAR=NULL;
 
 int Gmymalloc=0;
 
-int try_depth=-1;
+int try_depth=0;
 int try_loglev=2;
 int try_infolev=1;
 int try_edepth=2;
@@ -84,9 +84,9 @@ void try_loginfo(const char *func,const char *cond)
     memset(logstr,' ',TRY_STRLEN);
     switch (try_infolev)
     {
-        case 3: snprintf(logstr+indent,TRY_STRLEN,"%s:%s:" CODE_UL "Finished %s",func,cond,try_context.msgstr); break;
-        case 2: snprintf(logstr+indent,TRY_STRLEN,"%s:" CODE_UL "Finished %s",func,try_context.msgstr); break;
-        case 1: snprintf(logstr+indent,TRY_STRLEN,"Finished %s",try_context.msgstr); break;
+        case 3: snprintf(logstr+indent,TRY_STRLEN,"%s:%s:" CODE_UL "%s",func,cond,try_context.msgstr); break;
+        case 2: snprintf(logstr+indent,TRY_STRLEN,"%s:" CODE_UL "%s",func,try_context.msgstr); break;
+        case 1: snprintf(logstr+indent,TRY_STRLEN,"%s",try_context.msgstr); break;
         case 0: snprintf(logstr+indent,TRY_STRLEN,"%s",""); break;
     }
 
@@ -99,9 +99,9 @@ void try_logerror(const char *func,const char *cond,int status)
     char errstr[TRY_STRLEN];
     switch (try_loglev)
     {
-        case 3: snprintf(errstr,TRY_STRLEN,"%s:%s:Failed while %s",func,cond,try_context.msgstr); break;
-        case 2: snprintf(errstr,TRY_STRLEN,"%s:Failed while %s",func,try_context.msgstr); break;
-        case 1: snprintf(errstr,TRY_STRLEN,"Failed while %s",try_context.msgstr); break;
+        case 3: snprintf(errstr,TRY_STRLEN,"%s:%s:Failed to %s",func,cond,try_context.msgstr); break;
+        case 2: snprintf(errstr,TRY_STRLEN,"%s:Failed to %s",func,try_context.msgstr); break;
+        case 1: snprintf(errstr,TRY_STRLEN,"Failed to %s",try_context.msgstr); break;
         case 0: snprintf(errstr,TRY_STRLEN,"%s",""); break;
     }
 

vm.c

@@ -89,19 +89,21 @@ typedef struct {
     unsigned skipdepth;
 } VM_ENV;
 
-__thread LTV *vm_env_stack=NULL; // every thread can have a stack of vm_environments (supports interpreter->C->interpreter->C...
 __thread VM_ENV *vm_env=NULL; // every thread can have an active vm environment
 
 static LTV *vm_ltv_container=NULL; // holds LTVs we don't want garbage-collected
 static LTV *fun_pop_bc=NULL;
 
 __attribute__((constructor))
-static void init(void)
-{
-    VM_CMD fun_pop_asm[] = {{VMOP_FUN_POP}};
-    vm_ltv_container=LTV_NULL_LIST;
-    fun_pop_bc=compile(jit_asm,fun_pop_asm,1);
-    LTV_put(LTV_list(vm_ltv_container),fun_pop_bc,HEAD,NULL);
+static void init(void) {
+    static int initialized = 0;
+    if (!initialized) {
+        VM_CMD fun_pop_asm[] = {{VMOP_FUN_POP}};
+        vm_ltv_container = LTV_NULL_LIST;
+        fun_pop_bc = compile(jit_asm, fun_pop_asm, 1);
+        LTV_put(LTV_list(vm_ltv_container), fun_pop_bc, HEAD, NULL);
+        initialized++;
+    }
 }
 
 
@@ -685,8 +687,7 @@ static void vm_closure_thunk(ffi_cif *CIF,void *RET,void **ARGS,void *USER_DATA)
     int status=0;
     char *argid=NULL;
 
-    if (!vm_env_stack)
-        vm_env_stack=LTV_NULL_LIST;
+    LTV *vm_env_stack = LTV_NULL_LIST;
 
     LTV *continuation=(LTV *) USER_DATA;
 
@@ -765,7 +766,7 @@ extern LTV *vm_eval(LTV *root,LTV *code,LTV *arg) {
 }
 
 extern int vm_bootstrap(char *bootstrap) {
-    try_depth=0;
+    cif_init(0); // must dlopen as lib name when running from library
     LTV *rval=vm_eval(cif_module,LTV_init(NEW(LTV),bootstrap,-1,LT_NONE),LTV_NULL);
     if (rval)
         print_ltv(OUTFILE,"",rval,"\n",0);