there's really no need to hide the fields of LambdaInfo

Author: vtjnash

src/alloc.c

@@ -364,26 +364,21 @@ JL_DLLEXPORT jl_lambda_info_t *jl_spec_lambda_info(jl_lambda_info_t *li, jl_svec
     nli->inferred = 0;
     if (jl_options.compile_enabled == JL_OPTIONS_COMPILE_OFF && li != NULL) {
         // copy fptr from the unspecialized method definition
-        nli->fptr = li->fptr;
-        nli->jlcall_api = li->jlcall_api;
-        nli->functionObjects.functionObject = li->functionObjects.functionObject;
-        nli->functionObjects.specFunctionObject = li->functionObjects.specFunctionObject;
-        nli->functionID = li->functionID;
-        nli->specFunctionID = li->functionID;
-        if (nli->fptr == NULL) {
+        nli->functionObjects = li->functionObjects;
+        if (nli->functionObjects.fptr == NULL) {
             jl_printf(JL_STDERR,"code missing for ");
             jl_static_show(JL_STDERR, (jl_value_t*)nli);
             jl_printf(JL_STDERR, "  sysimg may not have been built with --compile=all\n");
         }
     }
     else {
-        nli->fptr = NULL;
-        nli->jlcall_api = 0;
+        nli->functionObjects.fptr = NULL;
+        nli->functionObjects.jlcall_api = 0;
         nli->functionObjects.functionObject = NULL;
         nli->functionObjects.specFunctionObject = NULL;
         nli->functionObjects.cFunctionList = NULL;
-        nli->functionID = 0;
-        nli->specFunctionID = 0;
+        nli->functionObjects.functionID = 0;
+        nli->functionObjects.specFunctionID = 0;
     }
     return nli;
 }

src/builtins.c

@@ -1086,7 +1086,7 @@ jl_value_t *jl_mk_builtin_func(const char *name, jl_fptr_t fptr)
     jl_value_t *f = jl_new_generic_function_with_supertype(sname, jl_core_module, jl_builtin_type, 0);
     jl_method_info_t *li = jl_new_method_info(jl_nothing, jl_emptysvec, jl_core_module);
     li->name = sname;
-    li->unspecialized->fptr = fptr;
+    li->unspecialized->functionObjects.fptr = fptr;
     // TODO jb/functions: what should li->ast be?
     li->unspecialized->ast = (jl_value_t*)jl_exprn(lambda_sym,0);
     jl_gc_wb(li->unspecialized, li->unspecialized->ast);
@@ -1097,7 +1097,7 @@ jl_value_t *jl_mk_builtin_func(const char *name, jl_fptr_t fptr)
 jl_fptr_t jl_get_builtin_fptr(jl_value_t *b)
 {
     assert(jl_subtype(b, (jl_value_t*)jl_builtin_type, 1));
-    return jl_gf_mtable(b)->cache->func->fptr;
+    return jl_gf_mtable(b)->cache->func->functionObjects.fptr;
 }
 
 static void add_builtin_func(const char *name, jl_fptr_t fptr)

src/codegen.cpp

@@ -854,12 +854,12 @@ static Function *to_function(jl_lambda_info_t *li, jl_cyclectx_t *cyclectx)
         #endif
         f = (llvm::Function*)definitions.functionObject;
         specf = (llvm::Function*)definitions.specFunctionObject;
-        li->functionID = jl_assign_functionID(f, 0);
+        li->functionObjects.functionID = jl_assign_functionID(f, 0);
         if (specf)
-            li->specFunctionID = jl_assign_functionID(specf, 1);
+            li->functionObjects.specFunctionID = jl_assign_functionID(specf, 1);
         if (f->getFunctionType() != jl_func_sig)
             // mark the pointer as jl_fptr_sparam_t calling convention
-            li->jlcall_api = 1;
+            li->functionObjects.jlcall_api = 1;
         //n_emit++;
     }
     JL_CATCH {
@@ -1057,7 +1057,7 @@ extern "C" void jl_generate_fptr(jl_lambda_info_t *li)
     JL_LOCK(codegen);
     // objective: assign li->fptr
     assert(li->functionObjects.functionObject);
-    if (li->fptr == NULL) {
+    if (li->functionObjects.fptr == NULL) {
         JL_SIGATOMIC_BEGIN();
         #ifdef USE_MCJIT
         if (imaging_mode) {
@@ -1076,16 +1076,16 @@ extern "C" void jl_generate_fptr(jl_lambda_info_t *li)
                 }
             }
             jl_finalize_module(m);
-            li->fptr = (jl_fptr_t)jl_ExecutionEngine->getFunctionAddress(((Function*)li->functionObjects.functionObject)->getName());
+            li->functionObjects.fptr = (jl_fptr_t)jl_ExecutionEngine->getFunctionAddress(((Function*)li->functionObjects.functionObject)->getName());
         }
         else {
-            li->fptr = (jl_fptr_t)getAddressForOrCompileFunction((Function*)li->functionObjects.functionObject);
+            li->functionObjects.fptr = (jl_fptr_t)getAddressForOrCompileFunction((Function*)li->functionObjects.functionObject);
         }
         #else
-        li->fptr = (jl_fptr_t)jl_ExecutionEngine->getPointerToFunction((Function*)li->functionObjects.functionObject);
+        li->functionObjects.fptr = (jl_fptr_t)jl_ExecutionEngine->getPointerToFunction((Function*)li->functionObjects.functionObject);
         #endif
 
-        assert(li->fptr != NULL);
+        assert(li->functionObjects.fptr != NULL);
 #ifndef KEEP_BODIES
         if (!imaging_mode)
             ((Function*)li->functionObjects.functionObject)->deleteBody();
@@ -1369,12 +1369,12 @@ void *jl_get_llvmf(jl_function_t *f, jl_tupletype_t *tt, bool getwrapper, bool g
         return llvmf;
     }
 
-    if (linfo->fptr && !jl_getUnwindInfo((uintptr_t)linfo->fptr)) {
+    if (linfo->functionObjects.fptr && !jl_getUnwindInfo((uintptr_t)linfo->functionObjects.fptr)) {
         // Not in in the current ExecutionEngine
         // found in the system image: force a recompile
         linfo->functionObjects.specFunctionObject = NULL;
         linfo->functionObjects.functionObject = NULL;
-        linfo->fptr = NULL;
+        linfo->functionObjects.fptr = NULL;
     }
     if (linfo->functionObjects.functionObject == NULL) {
         jl_compile_linfo(linfo, NULL);
@@ -5148,7 +5148,7 @@ extern "C" void jl_fptr_to_llvm(void *fptr, jl_lambda_info_t *lam, int specsig)
 {
     if (imaging_mode) {
         if (!specsig) {
-            lam->fptr = (jl_fptr_t)fptr; // in imaging mode, it's fine to use the fptr, but we don't want it in the shadow_module
+            lam->functionObjects.fptr = (jl_fptr_t)fptr; // in imaging mode, it's fine to use the fptr, but we don't want it in the shadow_module
         }
     }
     else {
@@ -5192,16 +5192,16 @@ extern "C" void jl_fptr_to_llvm(void *fptr, jl_lambda_info_t *lam, int specsig)
             add_named_global(f, (void*)fptr);
         }
         else {
-            if (lam->jlcall_api == 1) { // jl_func_sig_sparams -- don't bother emitting the FunctionObject (since can't be used right now)
-                assert(lam->fptr == NULL);
-                lam->fptr = (jl_fptr_t)fptr;
+            if (lam->functionObjects.jlcall_api == 1) { // jl_func_sig_sparams -- don't bother emitting the FunctionObject (since can't be used right now)
+                assert(lam->functionObjects.fptr == NULL);
+                lam->functionObjects.fptr = (jl_fptr_t)fptr;
             }
             else {
                 Function *f = jlcall_func_to_llvm(funcName, fptr, shadow_module);
                 if (lam->functionObjects.functionObject == NULL) {
                     lam->functionObjects.functionObject = (void*)f;
-                    assert(lam->fptr == NULL);
-                    lam->fptr = (jl_fptr_t)fptr;
+                    assert(lam->functionObjects.fptr == NULL);
+                    lam->functionObjects.fptr = (jl_fptr_t)fptr;
                 }
             }
         }

src/dump.c

@@ -847,11 +847,11 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
         write_int8(s, li->pure);
         write_int8(s, li->called);
         // save functionObject pointers
-        jl_serialize_fptr(s, li->fptr);
-        write_int32(s, li->functionID);
-        write_int32(s, li->specFunctionID);
-        if (li->functionID)
-            write_int8(s, li->jlcall_api);
+        jl_serialize_fptr(s, li->functionObjects.fptr);
+        write_int32(s, li->functionObjects.functionID);
+        write_int32(s, li->functionObjects.specFunctionID);
+        if (li->functionObjects.functionID)
+            write_int8(s, li->functionObjects.jlcall_api);
     }
     else if (jl_typeis(v, jl_module_type)) {
         jl_serialize_module(s, (jl_module_t*)v);
@@ -1504,19 +1504,19 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         li->inferred = read_int8(s);
         li->pure = read_int8(s);
         li->called = read_int8(s);
+        li->inInference = 0;
+        li->inCompile = 0;
         li->functionObjects.functionObject = NULL;
         li->functionObjects.cFunctionList = NULL;
         li->functionObjects.specFunctionObject = NULL;
-        li->inInference = 0;
-        li->inCompile = 0;
-        li->functionID = 0;
-        li->specFunctionID = 0;
+        li->functionObjects.functionID = 0;
+        li->functionObjects.specFunctionID = 0;
         int32_t cfunc_llvm, func_llvm;
-        li->fptr = jl_deserialize_fptr(s);
+        li->functionObjects.fptr = jl_deserialize_fptr(s);
         func_llvm = read_int32(s);
         cfunc_llvm = read_int32(s);
         jl_delayed_fptrs(li, func_llvm, cfunc_llvm);
-        li->jlcall_api = func_llvm ? read_int8(s) : 0;
+        li->functionObjects.jlcall_api = func_llvm ? read_int8(s) : 0;
         return (jl_value_t*)li;
     }
     else if (vtag == (jl_value_t*)jl_module_type) {

src/gf.c

@@ -845,15 +845,15 @@ static jl_value_t *lookup_match(jl_value_t *a, jl_value_t *b, jl_svec_t **penv,
 static jl_value_t *jl_call_unspecialized(jl_svec_t *sparam_vals, jl_lambda_info_t *meth,
                                          jl_value_t **args, uint32_t nargs)
 {
-    if (__unlikely(meth->fptr == NULL)) {
+    if (__unlikely(meth->functionObjects.fptr == NULL)) {
         jl_compile_linfo(meth, NULL);
         jl_generate_fptr(meth);
     }
     assert(jl_svec_len(meth->def->sparam_syms) == jl_svec_len(sparam_vals));
-    if (__likely(meth->jlcall_api == 0))
-        return meth->fptr(args[0], &args[1], nargs-1);
+    if (__likely(meth->functionObjects.jlcall_api == 0))
+        return meth->functionObjects.fptr(args[0], &args[1], nargs-1);
     else
-        return ((jl_fptr_sparam_t)meth->fptr)(sparam_vals, args[0], &args[1], nargs-1);
+        return ((jl_fptr_sparam_t)meth->functionObjects.fptr)(sparam_vals, args[0], &args[1], nargs-1);
 }
 
 JL_DLLEXPORT jl_method_info_t *jl_instantiate_staged(jl_method_info_t *generator, jl_tupletype_t *tt, jl_svec_t *env)
@@ -1494,7 +1494,7 @@ jl_lambda_info_t *jl_get_specialization1(jl_tupletype_t *types, void *cyclectx)
     if (sf == NULL || sf->inInference)
         goto not_found;
     if (sf->functionObjects.functionObject == NULL) {
-        if (sf->fptr != NULL)
+        if (sf->functionObjects.fptr != NULL)
             goto not_found;
         jl_compile_linfo(sf, cyclectx);
     }
@@ -1704,9 +1704,9 @@ static void _compile_all_deq(jl_array_t *found)
             if (complete) {
                 // keep track of whether all possible signatures have been cached (and thus whether it can skip trying to compile the unspecialized function)
                 // this is necessary because many intrinsics try to call static_eval and thus are not compilable unspecialized
-                if (!linfo->functionID)
+                if (!linfo->functionObjects.functionID)
                     // indicate that this method doesn't need a functionID because it was fully covered above
-                    linfo->functionID = -1;
+                    linfo->functionObjects.functionID = -1;
                 continue;
             }
         }
@@ -1720,11 +1720,11 @@ static void _compile_all_deq(jl_array_t *found)
             linfo->functionObjects.functionObject = NULL;
             linfo->functionObjects.specFunctionObject = NULL;
             linfo->functionObjects.cFunctionList = NULL;
-            linfo->functionID = 0;
-            linfo->specFunctionID = 0;
+            linfo->functionObjects.functionID = 0;
+            linfo->functionObjects.specFunctionID = 0;
         }
         jl_compile_linfo(linfo, NULL);
-        assert(linfo->functionID > 0);
+        assert(linfo->functionObjects.functionID > 0);
     }
     jl_printf(JL_STDERR, "\n");
 }
@@ -1735,7 +1735,7 @@ static void _compile_all_enq_ml(jl_methlist_t *ml, jl_array_t *found)
         if (ml->func != NULL) {
             // found a lambda specialization (not a placeholder guard)
             jl_lambda_info_t *linfo = (jl_lambda_info_t*)ml->func;
-            if (!linfo->functionID || !linfo->inferred)
+            if (!linfo->functionObjects.functionID || !linfo->inferred)
                 // and it still needs to be compiled
                 jl_cell_1d_push(found, (jl_value_t*)linfo);
         }
@@ -1750,7 +1750,7 @@ static void _compile_all_enq_methods(jl_method_info_t *ml, jl_array_t *found)
         if (!ml->isstaged) {
             // method definitions -- compile unspecialized field
             jl_lambda_info_t *linfo = ml->unspecialized;
-            if (!linfo->functionID || !linfo->inferred) {
+            if (!linfo->functionObjects.functionID || !linfo->inferred) {
                 // and it still needs to be compiled
                 jl_cell_1d_push(found, (jl_value_t*)ml);
             }

src/jltypes.c

@@ -3479,20 +3479,29 @@ void jl_init_types(void)
     jl_lambda_info_type =
         jl_new_datatype(jl_symbol("LambdaInfo"),
                         jl_any_type, jl_emptysvec,
-                        jl_svec(7, jl_symbol("ast"),
+                        jl_svec(18, jl_symbol("ast"),
                                 jl_symbol("rettype"),
                                 jl_symbol("sparam_vals"),
                                 jl_symbol("specTypes"),
                                 jl_symbol("unspecialized_ducttape"),
                                 jl_symbol("def"),
-                                jl_symbol("pure")),
-                        jl_svec(7, jl_any_type,
+                                jl_symbol("called"),
+                                jl_symbol("pure"),
+                                jl_symbol("inferred"),
+                                jl_symbol("inInference"),
+                                jl_symbol("inCompile"),
+                                jl_symbol(""), jl_symbol(""), jl_symbol(""),
+                                jl_symbol(""), jl_symbol(""), jl_symbol("fptr"), jl_symbol("")),
+                        jl_svec(18, jl_any_type,
                                 jl_any_type,
                                 jl_simplevector_type,
                                 jl_any_type,
                                 jl_any_type,
                                 jl_any_type,
-                                jl_bool_type),
+                                jl_int32_type,
+                                jl_bool_type, jl_bool_type, jl_bool_type, jl_bool_type,
+                                jl_any_type, jl_any_type, jl_any_type,
+                                jl_int32_type, jl_int32_type, jl_any_type, jl_bool_type),
                         0, 1, 4);
 
     jl_method_info_type =
@@ -3577,6 +3586,10 @@ void jl_init_types(void)
     jl_svecset(jl_typename_type->types, 6, jl_long_type);
     jl_svecset(jl_methtable_type->types, 5, jl_long_type);
     jl_svecset(jl_lambda_info_type->types, 5, jl_method_info_type);
+    jl_svecset(jl_lambda_info_type->types, 11, jl_voidpointer_type);
+    jl_svecset(jl_lambda_info_type->types, 12, jl_voidpointer_type);
+    jl_svecset(jl_lambda_info_type->types, 13, jl_voidpointer_type);
+    jl_svecset(jl_lambda_info_type->types, 16, jl_voidpointer_type);
 
     jl_compute_field_offsets(jl_datatype_type);
     jl_compute_field_offsets(jl_typename_type);

src/julia.h

@@ -279,11 +279,13 @@ typedef jl_value_t *(*jl_fptr_sparam_t)(jl_svec_t*, jl_value_t*, jl_value_t**, u
 typedef struct _jl_datatype_t jl_tupletype_t;
 
 typedef struct _jl_llvm_functions_t {
-    void *functionObject;       // jlcall llvm Function
-    void *cFunctionList;        // c callable llvm Functions
-
-    // specialized llvm Function (common core for the other two)
-    void *specFunctionObject;
+    void *functionObject;     // jlcall llvm Function
+    void *cFunctionList;      // c callable llvm Functions
+    void *specFunctionObject; // specialized llvm Function (common core for the other two)
+    int32_t functionID;       // index that this function will have in the codegen table
+    int32_t specFunctionID;   // index that this specFunction will have in the codegen table
+    jl_fptr_t fptr;           // jlcall entry point
+    uint8_t jlcall_api;       // the c-abi for fptr; 0 = jl_fptr_t, 1 = jl_fptr_sparam_t
 } jl_llvm_functions_t;
 
 typedef struct _jl_method_info_t {
@@ -330,25 +332,18 @@ typedef struct _jl_lambda_info_t {
     // this keeps codegen happy if the method contains intrinsics that depend on an sparam
     struct _jl_lambda_info_t *unspecialized_ducttape;
     jl_method_info_t *def;  // original this is specialized from
+    uint32_t called;  // bit flags: whether each of the first 8 arguments is called
     uint8_t pure;
-    uint8_t called;  // bit flags: whether each of the first 8 arguments is called
-
-    // hidden fields:
-    uint8_t inferred : 1;
-    uint8_t jlcall_api : 1;     // the c-abi for fptr; 0 = jl_fptr_t, 1 = jl_fptr_sparam_t
-    uint8_t inInference : 1;    // flags to tell if inference is running on this function
-                                // used to avoid infinite recursion
-    uint8_t inCompile : 1;
-    jl_fptr_t fptr;             // jlcall entry point
+    uint8_t inferred;
+    uint8_t inInference; // flags to tell if inference is running on this function
+                         // used to avoid infinite recursion
+    uint8_t inCompile;
 
     // On the old JIT, handles to all Functions generated for this linfo
     // For the new JITs, handles to declarations in the shadow module
     // with the same name as the generated functions for this linfo, suitable
     // for referencing in LLVM IR
     jl_llvm_functions_t functionObjects;
-
-    int32_t functionID; // index that this function will have in the codegen table
-    int32_t specFunctionID; // index that this specFunction will have in the codegen table
 } jl_lambda_info_t;
 
 typedef jl_value_t jl_function_t;

src/julia_internal.h

@@ -61,14 +61,14 @@ void jl_compile_linfo(jl_lambda_info_t *li, void *cyclectx);
 // invoke (compiling if necessary) the jlcall function pointer for a method
 STATIC_INLINE jl_value_t *jl_call_method_internal(jl_lambda_info_t *meth, jl_value_t **args, uint32_t nargs)
 {
-    if (__unlikely(meth->fptr == NULL)) {
+    if (__unlikely(meth->functionObjects.fptr == NULL)) {
         jl_compile_linfo(meth, NULL);
         jl_generate_fptr(meth);
     }
-    if (meth->jlcall_api == 0)
-        return meth->fptr(args[0], &args[1], nargs-1);
+    if (meth->functionObjects.jlcall_api == 0)
+        return meth->functionObjects.fptr(args[0], &args[1], nargs-1);
     else
-        return ((jl_fptr_sparam_t)meth->fptr)(meth->sparam_vals, args[0], &args[1], nargs-1);
+        return ((jl_fptr_sparam_t)meth->functionObjects.fptr)(meth->sparam_vals, args[0], &args[1], nargs-1);
 }
 
 jl_tupletype_t *jl_argtype_with_function(jl_function_t *f, jl_tupletype_t *types);