Push fixes + assume effects

Author: gbaraldi

base/c.jl

@@ -409,6 +409,6 @@ macro ccall(expr)
     return ccall_macro_lower(:ccall, ccall_macro_parse(expr)...)
 end
 
-macro ccall_effects(effects::UInt16, expr)
-    return ccall_macro_lower((:ccall, effects, false), ccall_macro_parse(expr)...)
+macro ccall_effects(effects::UInt16, gc_safe::Bool, expr)
+    return ccall_macro_lower((:ccall, effects, gc_safe), ccall_macro_parse(expr)...)
 end

base/expr.jl

@@ -516,7 +516,7 @@ The following `setting`s are supported.
 - `:foldable`
 - `:removable`
 - `:total`
-
+- `:gc_safe`
 # Extended help
 
 ---
@@ -750,6 +750,13 @@ the following other `setting`s:
     number of effect overrides apply to a set of functions, a custom macro is
     recommended over the use of `:total`.
 
+---
+## `:gc_safe`
+
+This `setting` can only be applied to `@ccall` expressions. It asserts that the
+`@ccall` is safe to execute concurrently with the garbage collector. This means that it must not
+call into the julia runtime.
+
 ---
 ## Negated effects
 
@@ -759,12 +766,13 @@ the call is generally total, it may however throw.
 """
 macro assume_effects(args...)
     lastex = args[end]
-    override = compute_assumed_settings(args[begin:end-1])
+    override, gc_safe = compute_assumed_settings(args[begin:end-1])
     if is_function_def(unwrap_macrocalls(lastex))
         return esc(pushmeta!(lastex::Expr, form_purity_expr(override)))
     elseif isexpr(lastex, :macrocall) && lastex.args[1] === Symbol("@ccall")
         lastex.args[1] = GlobalRef(Base, Symbol("@ccall_effects"))
         insert!(lastex.args, 3, encode_effects_override(override))
+        insert!(lastex.args, 4, gc_safe)
         return esc(lastex)
     end
     override′ = compute_assumed_setting(override, lastex)
@@ -783,12 +791,19 @@ end
 
 function compute_assumed_settings(settings)
     override = EffectsOverride()
+    gc_safe = false
     for setting in settings
+        # This way of parsing is slightly annoying, but it's to avoid extra complexity for EffectOverride
+        gc_safe2, found = compute_gc_safe(setting)
+        if found
+            gc_safe = gc_safe2
+            continue
+        end
         override = compute_assumed_setting(override, setting)
         override === nothing &&
             throw(ArgumentError("`@assume_effects $setting` not supported"))
     end
-    return override
+    return override, gc_safe
 end
 
 struct EffectsOverride
@@ -835,6 +850,18 @@ end
 
 const NUM_EFFECTS_OVERRIDES = 11 # sync with julia.h
 
+function compute_gc_safe(setting)
+    if setting === :gc_safe
+        return (gc_safe=true, found=true)
+    elseif isexpr(setting, :call) && setting.args[1] === :(!)
+        gc_safe2, found2 = compute_gc_safe(setting.args[2])
+        return (gc_safe=(!gc_safe2), found=found2)
+    elseif isa(setting, QuoteNode)
+        return compute_gc_safe(setting.value)
+    end
+    return (gc_safe=false, found=false)
+end
+
 function compute_assumed_setting(override::EffectsOverride, @nospecialize(setting), val::Bool=true)
     if isexpr(setting, :call) && setting.args[1] === :(!)
         return compute_assumed_setting(override, setting.args[2], !val)

src/ccall.cpp

@@ -3,6 +3,7 @@
 // --- the ccall, cglobal, and llvm intrinsics ---
 
 // Mark our stats as being from ccall
+#include "julia.h"
 #undef DEBUG_TYPE
 #define DEBUG_TYPE "julia_irgen_ccall"
 
@@ -1431,13 +1432,12 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
     // TODO: Can we introduce a intrinisc token = @julia.gc_safe_begin()
     //       and "grow" gc safe regions so that we minimize the overhead?
     bool gc_safe = false;
-    assert(jl_is_symbol(cc_sym));
     if (jl_is_symbol(jlcc)) {
         cc_sym = (jl_sym_t*)jlcc;
     }
     else if (jl_is_tuple(jlcc)) {
         cc_sym = (jl_sym_t*)jl_get_nth_field_noalloc(jlcc, 0);
-        gc_safe = jl_unbox_bool(jl_get_nth_field_noalloc(jlcc, 2));
+        gc_safe = jl_unbox_bool(jl_get_nth_field_checked(jlcc, 2));
     }
     assert(jl_is_symbol(cc_sym));
     native_sym_arg_t symarg = {};

test/strings/basic.jl

@@ -1249,8 +1249,8 @@ end
         @test !Core.Compiler.is_removable_if_unused(e) || (f, Ts)
     end
     @test_throws ArgumentError Symbol("a\0a")
-
-    @test Base._string_n_override == Base.encode_effects_override(Base.compute_assumed_settings((:total, :(!:consistent))))
+    override, _ = Base.compute_assumed_settings((:total, :(!:consistent)))
+    @test Base._string_n_override == Base.encode_effects_override(override)
 end
 
 @testset "Ensure UTF-8 DFA can never leave invalid state" begin