cglobal: Add an option to bypass jlplt mechanism

base/compiler/tfuncs.jl

@@ -278,7 +278,10 @@ add_tfunc(Core.Intrinsics.llvmcall, 3, INT_INF, llvmcall_tfunc, 10)
     isa(t, Const) && return isa(t.val, Type) ? Ptr{t.val} : Ptr
     return isType(t) ? Ptr{t.parameters[1]} : Ptr
 end
-add_tfunc(Core.Intrinsics.cglobal, 1, 2, cglobal_tfunc, 5)
+@nospecs function cglobal_tfunc(𝕃::AbstractLattice, fptr, t, useplt)
+    return cglobal_tfunc(𝕃, fptr, t)
+end
+add_tfunc(Core.Intrinsics.cglobal, 1, 3, cglobal_tfunc, 5)
 
 add_tfunc(Core.Intrinsics.have_fma, 1, 1, @nospecs((𝕃::AbstractLattice, x)->Bool), 1)
 add_tfunc(Core.Intrinsics.arraylen, 1, 1, @nospecs((𝕃::AbstractLattice, x)->Int), 4)

src/builtins.c

@@ -1873,8 +1873,12 @@ JL_CALLABLE(jl_f_intrinsic_call)
 {
     JL_TYPECHK(intrinsic_call, intrinsic, F);
     enum intrinsic f = (enum intrinsic)*(uint32_t*)jl_data_ptr(F);
-    if (f == cglobal && nargs == 1)
-        f = cglobal_auto;
+    if (f == cglobal) {
+        if (nargs == 1)
+            f = cglobal_auto;
+        else if (nargs == 3)
+            f = cglobal_pltarg;
+    }
     unsigned fargs = intrinsic_nargs[f];
     if (!fargs)
         jl_errorf("`%s` must be compiled to be called", jl_intrinsic_name(f));

src/ccall.cpp

@@ -671,13 +671,15 @@ static jl_cgval_t emit_runtime_call(jl_codectx_t &ctx, JL_I::intrinsic f, const
 static jl_cgval_t emit_cglobal(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
 {
     ++EmittedCGlobals;
-    JL_NARGS(cglobal, 1, 2);
+    JL_NARGS(cglobal, 1, 3);
     jl_value_t *rt = NULL;
     Value *res;
     native_sym_arg_t sym = {};
     JL_GC_PUSH2(&rt, &sym.gcroot);
+    bool use_jlplt = true;
 
-    if (nargs == 2) {
+    rt = (jl_value_t*)jl_voidpointer_type;
+    if (nargs >= 2) {
         rt = static_eval(ctx, args[2]);
         if (rt == NULL) {
             JL_GC_POP();
@@ -690,9 +692,19 @@ static jl_cgval_t emit_cglobal(jl_codectx_t &ctx, jl_value_t **args, size_t narg
         JL_TYPECHK(cglobal, type, rt);
         rt = (jl_value_t*)jl_apply_type1((jl_value_t*)jl_pointer_type, rt);
     }
-    else {
-        rt = (jl_value_t*)jl_voidpointer_type;
+    if (nargs == 3) {
+        jl_value_t *j_use_jlplt = static_eval(ctx, args[3]);
+        if (j_use_jlplt == NULL || !jl_is_bool(j_use_jlplt)) {
+            JL_GC_POP();
+            jl_cgval_t argv[3] = {jl_cgval_t(), jl_cgval_t(), jl_cgval_t()};
+            argv[0] = emit_expr(ctx, args[1]);
+            argv[1] = emit_expr(ctx, args[2]);
+            argv[2] = emit_expr(ctx, args[3]);
+            return emit_runtime_call(ctx, JL_I::cglobal, argv, nargs);
+        }
+        use_jlplt = jl_unbox_bool(j_use_jlplt);
     }
+
     Type *lrt = ctx.types().T_size;
     assert(lrt == julia_type_to_llvm(ctx, rt));
 
@@ -714,6 +726,17 @@ static jl_cgval_t emit_cglobal(jl_codectx_t &ctx, jl_value_t **args, size_t narg
         if (ctx.emission_context.imaging_mode)
             jl_printf(JL_STDERR,"WARNING: literal address used in cglobal for %s; code cannot be statically compiled\n", sym.f_name);
     }
+    else if (!use_jlplt) {
+        if ((sym.f_lib && !((sym.f_lib == JL_EXE_LIBNAME) ||
+              (sym.f_lib == JL_LIBJULIA_INTERNAL_DL_LIBNAME) ||
+              (sym.f_lib == JL_LIBJULIA_DL_LIBNAME))) || sym.lib_expr) {
+            jl_printf(JL_STDERR,"WARNING: Attempted to use library expression for symbol %s while disabling jlplt. Library expression was ignored.\n", sym.f_name);
+        }
+        GlobalVariable *GV = new GlobalVariable(*jl_Module, lrt, true,
+            GlobalVariable::ExternalLinkage,
+            nullptr, sym.f_name);
+        res = ctx.builder.CreatePtrToInt(GV, lrt);
+    }
     else {
         if (sym.lib_expr) {
             res = runtime_sym_lookup(ctx, cast<PointerType>(getInt8PtrTy(ctx.builder.getContext())), NULL, sym.lib_expr, sym.f_name, ctx.f);

src/intrinsics.cpp

@@ -1181,16 +1181,21 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
 {
     auto &DL = ctx.emission_context.DL;
     assert(f < num_intrinsics);
-    if (f == cglobal && nargs == 1)
-        f = cglobal_auto;
+    if (f == cglobal) {
+        if (nargs == 1)
+            f = cglobal_auto;
+        else if (nargs == 3)
+            f = cglobal_pltarg;
+    }
+
     unsigned expected_nargs = jl_intrinsic_nargs((int)f);
     if (expected_nargs && expected_nargs != nargs) {
         jl_errorf("intrinsic #%d %s: wrong number of arguments", f, jl_intrinsic_name((int)f));
     }
 
     if (f == llvmcall)
         return emit_llvmcall(ctx, args, nargs);
-    if (f == cglobal_auto || f == cglobal)
+    if (f == cglobal_auto || f == cglobal || f == cglobal_pltarg)
         return emit_cglobal(ctx, args, nargs);
 
     SmallVector<jl_cgval_t> argv(nargs);

src/intrinsics.h

@@ -104,7 +104,8 @@
     /*  cpu feature tests */ \
     ADD_I(have_fma, 1) \
     /*  hidden intrinsics */ \
-    ADD_HIDDEN(cglobal_auto, 1)
+    ADD_HIDDEN(cglobal_auto, 1) \
+    ADD_HIDDEN(cglobal_pltarg, 3)
 
 enum intrinsic {
 #define ADD_I(func, nargs) func,

src/jitlayers.cpp

@@ -2053,14 +2053,18 @@ void jl_merge_module(orc::ThreadSafeModule &destTSM, orc::ThreadSafeModule srcTS
             assert(dest.getTargetTriple() == src.getTargetTriple() && "Cannot merge modules with different target triples!");
 
             for (auto &SG : make_early_inc_range(src.globals())) {
-                GlobalVariable *dG = cast_or_null<GlobalVariable>(dest.getNamedValue(SG.getName()));
+                GlobalValue *dG = cast_or_null<GlobalValue>(dest.getNamedValue(SG.getName()));
                 if (SG.hasLocalLinkage()) {
                     dG = nullptr;
                 }
                 // Replace a declaration with the definition:
                 if (dG && !dG->hasLocalLinkage()) {
                     if (SG.isDeclaration()) {
-                        SG.replaceAllUsesWith(dG);
+                        Constant *repl = dG;
+                        if (SG.getType() != repl->getType()) {
+                            repl = ConstantExpr::getBitCast(repl, SG.getType());
+                        }
+                        SG.replaceAllUsesWith(repl);
                         SG.eraseFromParent();
                         continue;
                     }

src/jl_exported_funcs.inc

@@ -91,6 +91,7 @@
     XX(jl_ceil_llvm_withtype) \
     XX(jl_cglobal) \
     XX(jl_cglobal_auto) \
+    XX(jl_cglobal_pltarg) \
     XX(jl_checked_assignment) \
     XX(jl_clear_implicit_imports) \
     XX(jl_close_uv) \

src/julia_internal.h

@@ -1298,6 +1298,7 @@ JL_DLLEXPORT jl_value_t *jl_atomic_pointermodify(jl_value_t *p, jl_value_t *f, j
 JL_DLLEXPORT jl_value_t *jl_atomic_pointerreplace(jl_value_t *p, jl_value_t *x, jl_value_t *expected, jl_value_t *success_order, jl_value_t *failure_order);
 JL_DLLEXPORT jl_value_t *jl_cglobal(jl_value_t *v, jl_value_t *ty);
 JL_DLLEXPORT jl_value_t *jl_cglobal_auto(jl_value_t *v);
+JL_DLLEXPORT jl_value_t *jl_cglobal_pltarg(jl_value_t *v, jl_value_t *ty, jl_value_t *usejlplt);
 
 JL_DLLEXPORT jl_value_t *jl_neg_int(jl_value_t *a);
 JL_DLLEXPORT jl_value_t *jl_add_int(jl_value_t *a, jl_value_t *b);

src/runtime_intrinsics.c

@@ -524,6 +524,10 @@ JL_DLLEXPORT jl_value_t *jl_cglobal_auto(jl_value_t *v) {
     return jl_cglobal(v, (jl_value_t*)jl_nothing_type);
 }
 
+JL_DLLEXPORT jl_value_t *jl_cglobal_pltarg(jl_value_t *v, jl_value_t *ty, jl_value_t *useplt) {
+    return jl_cglobal(v, ty);
+}
+
 static inline char signbitbyte(void *a, unsigned bytes) JL_NOTSAFEPOINT
 {
     // sign bit of an signed number of n bytes, as a byte