Merge branch 'master' into llvm-20-initial

Zentrik · web-flow · commit 81383ed0dd26 · 2025-02-10T23:17:26.000Z
diff --git a/Compiler/src/tfuncs.jl b/Compiler/src/tfuncs.jl
@@ -1073,17 +1073,15 @@ end
 end
 
 @nospecs function getfield_tfunc(𝕃::AbstractLattice, s00, name, boundscheck_or_order)
-    t = isvarargtype(boundscheck_or_order) ? unwrapva(boundscheck_or_order) :
-        widenconst(boundscheck_or_order)
-    hasintersect(t, Symbol) || hasintersect(t, Bool) || return Bottom
+    if !isvarargtype(boundscheck_or_order)
+        t = widenconst(boundscheck_or_order)
+        hasintersect(t, Symbol) || hasintersect(t, Bool) || return Bottom
+    end
     return getfield_tfunc(𝕃, s00, name)
 end
 @nospecs function getfield_tfunc(𝕃::AbstractLattice, s00, name, order, boundscheck)
     hasintersect(widenconst(order), Symbol) || return Bottom
-    if isvarargtype(boundscheck)
-        t = unwrapva(boundscheck)
-        hasintersect(t, Symbol) || hasintersect(t, Bool) || return Bottom
-    else
+    if !isvarargtype(boundscheck)
         hasintersect(widenconst(boundscheck), Bool) || return Bottom
     end
     return getfield_tfunc(𝕃, s00, name)
diff --git a/Compiler/test/inference.jl b/Compiler/test/inference.jl
@@ -6188,3 +6188,9 @@ end == Union{Float64,DomainError}
 @test Compiler.argtypes_to_type(Any[ Int, UnitRange{Int}, Vararg{Pair{Any, Union{}}}, Float64 ]) === Tuple{Int, UnitRange{Int}, Float64}
 @test Compiler.argtypes_to_type(Any[ Int, UnitRange{Int}, Vararg{Pair{Any, Union{}}}, Float64, Memory{2} ]) === Union{}
 @test Base.return_types(Tuple{Tuple{Int, Vararg{Pair{Any, Union{}}}}},) do x; Returns(true)(x...); end |> only === Bool
+
+# issue #57292
+f57292(xs::Union{Tuple{String}, Int}...) = getfield(xs...)
+g57292(xs::String...) = getfield(("abc",), 1, :not_atomic, xs...)
+@test Base.infer_return_type(f57292) == String
+@test Base.infer_return_type(g57292) == String
diff --git a/base/lock.jl b/base/lock.jl
@@ -693,7 +693,7 @@ julia> procstate === fetch(@async global_state())
 true
 ```
 """
-mutable struct OncePerProcess{T, F}
+mutable struct OncePerProcess{T, F} <: Function
     value::Union{Nothing,T}
     @atomic state::UInt8 # 0=initial, 1=hasrun, 2=error
     @atomic allow_compile_time::Bool
@@ -801,7 +801,7 @@ julia> threadvec === thread_state[Threads.threadid()]
 true
 ```
 """
-mutable struct OncePerThread{T, F}
+mutable struct OncePerThread{T, F} <: Function
     @atomic xs::AtomicMemory{T} # values
     @atomic ss::AtomicMemory{UInt8} # states: 0=initial, 1=hasrun, 2=error, 3==concurrent
     const initializer::F
@@ -926,7 +926,7 @@ Making lazy task value...done.
 false
 ```
 """
-mutable struct OncePerTask{T, F}
+mutable struct OncePerTask{T, F} <: Function
     const initializer::F
 
     OncePerTask{T}(initializer::F) where {T, F} = new{T,F}(initializer)
diff --git a/deps/patches/llvm7-symver-jlprefix.patch b/deps/patches/llvm7-symver-jlprefix.patch
diff --git a/doc/src/devdocs/build/build.md b/doc/src/devdocs/build/build.md
@@ -250,7 +250,6 @@ For packaging Julia with LLVM, we recommend either:
  - bundling a Julia-only LLVM library inside the Julia package, or
  - adding the patches to the LLVM package of the distribution.
    * A complete list of patches is available in on [Github](https://github.com/JuliaLang/llvm-project) see the `julia-release/18.x` branch.
-   * The only Julia-specific patch is the lib renaming (`llvm7-symver-jlprefix.patch`), which should _not_ be applied to a system LLVM.
    * The remaining patches are all upstream bug fixes, and have been contributed into upstream LLVM.
 
 Using an unpatched or different version of LLVM will result in errors and/or poor performance.
diff --git a/src/codegen.cpp b/src/codegen.cpp
@@ -1006,7 +1006,7 @@ static const auto jlgenericfunction_func = new JuliaFunction<>{
         auto T_jlvalue = JuliaType::get_jlvalue_ty(C);
         auto T_pjlvalue = PointerType::get(T_jlvalue, 0);
         auto T_prjlvalue = PointerType::get(T_jlvalue, AddressSpace::Tracked);
-        return FunctionType::get(T_prjlvalue, {T_pjlvalue, T_pjlvalue, T_pjlvalue}, false);
+        return FunctionType::get(T_prjlvalue, {T_pjlvalue, T_pjlvalue}, false);
     },
     nullptr,
 };
@@ -6866,8 +6866,6 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
             jl_value_t *mn = args[0];
             assert(jl_is_symbol(mn) || jl_is_slotnumber(mn) || jl_is_globalref(mn));
 
-            Value *bp = NULL, *name;
-            jl_binding_t *bnd = NULL;
             bool issym = jl_is_symbol(mn);
             bool isglobalref = !issym && jl_is_globalref(mn);
             jl_module_t *mod = ctx.module;
@@ -6876,26 +6874,11 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
                     mod = jl_globalref_mod(mn);
                     mn = (jl_value_t*)jl_globalref_name(mn);
                 }
-                JL_TRY {
-                    if (jl_symbol_name((jl_sym_t*)mn)[0] == '@')
-                        jl_errorf("macro definition not allowed inside a local scope");
-                    name = literal_pointer_val(ctx, mn);
-                    bnd = jl_get_binding_for_method_def(mod, (jl_sym_t*)mn);
-                }
-                JL_CATCH {
-                    jl_value_t *e = jl_current_exception(jl_current_task);
-                    // errors. boo. :(
-                    JL_GC_PUSH1(&e);
-                    e = jl_as_global_root(e, 1);
-                    JL_GC_POP();
-                    raise_exception(ctx, literal_pointer_val(ctx, e));
-                    return ghostValue(ctx, jl_nothing_type);
-                }
-                bp = julia_binding_gv(ctx, bnd);
                 jl_cgval_t gf = mark_julia_type(
                         ctx,
-                        ctx.builder.CreateCall(prepare_call(jlgenericfunction_func), { bp,
-                            literal_pointer_val(ctx, (jl_value_t*)mod), name
+                        ctx.builder.CreateCall(prepare_call(jlgenericfunction_func), {
+                            literal_pointer_val(ctx, (jl_value_t*)mod),
+                            literal_pointer_val(ctx, (jl_value_t*)mn)
                         }),
                         true,
                         jl_function_type);
diff --git a/src/interpreter.c b/src/interpreter.c
@@ -93,8 +93,7 @@ static jl_value_t *eval_methoddef(jl_expr_t *ex, interpreter_state *s)
         if (!jl_is_symbol(fname)) {
             jl_error("method: invalid declaration");
         }
-        jl_binding_t *b = jl_get_binding_for_method_def(modu, fname);
-        return jl_declare_const_gf(b, modu, fname);
+        return jl_declare_const_gf(modu, fname);
     }
 
     jl_value_t *atypes = NULL, *meth = NULL, *fname = NULL;
diff --git a/src/julia.h b/src/julia.h
@@ -1475,6 +1475,13 @@ STATIC_INLINE char *jl_symbol_name_(jl_sym_t *s) JL_NOTSAFEPOINT
 }
 #define jl_symbol_name(s) jl_symbol_name_(s)
 
+STATIC_INLINE const char *jl_module_debug_name(jl_module_t *mod) JL_NOTSAFEPOINT
+{
+    if (!mod)
+        return "<null>";
+    return jl_symbol_name(mod->name);
+}
+
 static inline uint32_t jl_fielddesc_size(int8_t fielddesc_type) JL_NOTSAFEPOINT
 {
     assert(fielddesc_type >= 0 && fielddesc_type <= 2);
@@ -1901,7 +1908,7 @@ JL_DLLEXPORT jl_value_t *jl_get_binding_value(jl_binding_t *b JL_PROPAGATES_ROOT
 JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_const(jl_binding_t *b JL_PROPAGATES_ROOT);
 JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_resolved(jl_binding_t *b JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_resolved_and_const(jl_binding_t *b JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
-JL_DLLEXPORT jl_value_t *jl_declare_const_gf(jl_binding_t *b, jl_module_t *mod, jl_sym_t *name);
+JL_DLLEXPORT jl_value_t *jl_declare_const_gf(jl_module_t *mod, jl_sym_t *name);
 JL_DLLEXPORT jl_method_t *jl_method_def(jl_svec_t *argdata, jl_methtable_t *mt, jl_code_info_t *f, jl_module_t *module);
 JL_DLLEXPORT jl_code_info_t *jl_code_for_staged(jl_method_instance_t *linfo, size_t world, jl_code_instance_t **cache);
 JL_DLLEXPORT jl_code_info_t *jl_copy_code_info(jl_code_info_t *src);
@@ -2051,7 +2058,7 @@ JL_DLLEXPORT jl_value_t *jl_get_binding_type(jl_module_t *m, jl_sym_t *var);
 // get binding for assignment
 JL_DLLEXPORT void jl_check_binding_currently_writable(jl_binding_t *b, jl_module_t *m, jl_sym_t *s);
 JL_DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *var);
-JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *var);
+JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *var, size_t new_world);
 JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var, int allow_import);
 JL_DLLEXPORT int jl_defines_or_exports_p(jl_module_t *m, jl_sym_t *var);
 JL_DLLEXPORT int jl_is_const(jl_module_t *m, jl_sym_t *var);
diff --git a/src/julia_internal.h b/src/julia_internal.h
@@ -876,6 +876,7 @@ STATIC_INLINE size_t module_usings_max(jl_module_t *m) JL_NOTSAFEPOINT {
     return m->usings.max/3;
 }
 
+JL_DLLEXPORT jl_sym_t *jl_module_name(jl_module_t *m) JL_NOTSAFEPOINT;
 jl_value_t *jl_eval_global_var(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *e);
 jl_value_t *jl_interpret_opaque_closure(jl_opaque_closure_t *clos, jl_value_t **args, size_t nargs);
 jl_value_t *jl_interpret_toplevel_thunk(jl_module_t *m, jl_code_info_t *src);
diff --git a/src/method.c b/src/method.c
@@ -1050,10 +1050,11 @@ JL_DLLEXPORT void jl_check_gf(jl_value_t *gf, jl_sym_t *name)
         jl_errorf("cannot define function %s; it already has a value", jl_symbol_name(name));
 }
 
-JL_DLLEXPORT jl_value_t *jl_declare_const_gf(jl_binding_t *b, jl_module_t *mod, jl_sym_t *name)
+JL_DLLEXPORT jl_value_t *jl_declare_const_gf(jl_module_t *mod, jl_sym_t *name)
 {
     JL_LOCK(&world_counter_lock);
     size_t new_world = jl_atomic_load_relaxed(&jl_world_counter) + 1;
+    jl_binding_t *b = jl_get_binding_for_method_def(mod, name, new_world);
     jl_binding_partition_t *bpart = jl_get_binding_partition(b, new_world);
     jl_ptr_kind_union_t pku = jl_atomic_load_relaxed(&bpart->restriction);
     jl_value_t *gf = NULL;
diff --git a/src/module.c b/src/module.c
@@ -588,10 +588,10 @@ JL_DLLEXPORT jl_value_t *jl_reresolve_binding_value_seqcst(jl_binding_t *b)
 
 // get binding for adding a method
 // like jl_get_binding_wr, but has different error paths and messages
-JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_t *var, size_t new_world)
 {
     jl_binding_t *b = jl_get_module_binding(m, var, 1);
-    jl_binding_partition_t *bpart = jl_get_binding_partition(b, jl_current_task->world_age);
+    jl_binding_partition_t *bpart = jl_get_binding_partition(b, new_world);
     jl_ptr_kind_union_t pku = jl_atomic_load_relaxed(&bpart->restriction);
     enum jl_partition_kind kind = decode_restriction_kind(pku);
     if (kind == BINDING_KIND_GLOBAL || kind == BINDING_KIND_DECLARED || jl_bkind_is_some_constant(decode_restriction_kind(pku)))
@@ -601,7 +601,7 @@ JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_
         return b;
     }
     jl_binding_t *ownerb = b;
-    pku = jl_walk_binding_inplace(&ownerb, &bpart, jl_current_task->world_age);
+    pku = jl_walk_binding_inplace(&ownerb, &bpart, new_world);
     jl_value_t *f = NULL;
     if (jl_bkind_is_some_constant(decode_restriction_kind(pku)))
         f = decode_restriction_value(pku);
@@ -613,7 +613,7 @@ JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_
         jl_module_t *from = jl_binding_dbgmodule(b, m, var);
         // we must have implicitly imported this with using, so call jl_binding_dbgmodule to try to get the name of the module we got this from
         jl_errorf("invalid method definition in %s: exported function %s.%s does not exist",
-                    jl_symbol_name(m->name), from ? jl_symbol_name(from->name) : "<null>", jl_symbol_name(var));
+                    jl_module_debug_name(m), jl_module_debug_name(from), jl_symbol_name(var));
     }
     int istype = f && jl_is_type(f);
     if (!istype) {
@@ -626,13 +626,25 @@ JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_
             //       or we might want to drop this error entirely
             jl_module_t *from = jl_binding_dbgmodule(b, m, var);
             jl_errorf("invalid method definition in %s: function %s.%s must be explicitly imported to be extended",
-                        jl_symbol_name(m->name), from ? jl_symbol_name(from->name) : "<null>", jl_symbol_name(var));
+                        jl_module_debug_name(m), jl_module_debug_name(from), jl_symbol_name(var));
         }
     }
-    else if (strcmp(jl_symbol_name(var), "=>") == 0 && (kind == BINDING_KIND_IMPLICIT || kind == BINDING_KIND_EXPLICIT)) {
+    else if (kind != BINDING_KIND_IMPORTED) {
+        int should_error = strcmp(jl_symbol_name(var), "=>") == 0;
         jl_module_t *from = jl_binding_dbgmodule(b, m, var);
-        jl_errorf("invalid method definition in %s: function %s.%s must be explicitly imported to be extended",
-                    jl_symbol_name(m->name), from ? jl_symbol_name(from->name) : "<null>", jl_symbol_name(var));
+        if (should_error)
+            jl_errorf("invalid method definition in %s: function %s.%s must be explicitly imported to be extended",
+                        jl_module_debug_name(m), jl_module_debug_name(from), jl_symbol_name(var));
+        else
+            jl_printf(JL_STDERR, "WARNING: Constructor for type \"%s\" was extended in `%s` without explicit qualification or import.\n"
+                                 "  NOTE: Assumed \"%s\" refers to `%s.%s`. This behavior is deprecated and may differ in future versions.`\n"
+                                 "  NOTE: This behavior may have differed in Julia versions prior to 1.12.\n"
+                                 "  Hint: If you intended to create a new generic function of the same name, use `function %s end`.\n"
+                                 "  Hint: To silence the warning, qualify `%s` as `%s.%s` or explicitly `import %s: %s`\n",
+                jl_symbol_name(var), jl_module_debug_name(m),
+                jl_symbol_name(var), jl_module_debug_name(from), jl_symbol_name(var),
+                jl_symbol_name(var), jl_symbol_name(var), jl_module_debug_name(from), jl_symbol_name(var),
+                jl_module_debug_name(from), jl_symbol_name(var));
     }
     return ownerb;
 }
diff --git a/src/threading.c b/src/threading.c
@@ -336,7 +336,17 @@ jl_ptls_t jl_init_threadtls(int16_t tid)
 #endif
     if (jl_get_pgcstack() != NULL)
         abort();
-    jl_ptls_t ptls = (jl_ptls_t)calloc(1, sizeof(jl_tls_states_t));
+    jl_ptls_t ptls;
+#if defined(_OS_WINDOWS_)
+    ptls = _aligned_malloc(sizeof(jl_tls_states_t), alignof(jl_tls_states_t));
+    if (ptls == NULL)
+        abort();
+#else
+    if (posix_memalign((void**)&ptls, alignof(jl_tls_states_t), sizeof(jl_tls_states_t)))
+        abort();
+#endif
+    memset(ptls, 0, sizeof(jl_tls_states_t));
+
 #ifndef _OS_WINDOWS_
     pthread_setspecific(jl_task_exit_key, (void*)ptls);
 #endif
diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
@@ -980,13 +980,14 @@ mutable struct StackFrameTree{T} # where T <: Union{UInt64, StackFrame}
     flat_count::Int     # number of times this frame was in the flattened representation (unlike count, this'll sum to 100% of parent)
     max_recur::Int      # maximum number of times this frame was the *top* of the recursion in the stack
     count_recur::Int    # sum of the number of times this frame was the *top* of the recursion in a stack (divide by count to get an average)
+    sleeping::Bool      # whether this frame was in a sleeping state
     down::Dict{T, StackFrameTree{T}}
     # construction workers:
     recur::Int
     builder_key::Vector{UInt64}
     builder_value::Vector{StackFrameTree{T}}
     up::StackFrameTree{T}
-    StackFrameTree{T}() where {T} = new(UNKNOWN, 0, 0, 0, 0, 0, Dict{T, StackFrameTree{T}}(), 0, UInt64[], StackFrameTree{T}[])
+    StackFrameTree{T}() where {T} = new(UNKNOWN, 0, 0, 0, 0, 0, true, Dict{T, StackFrameTree{T}}(), 0, UInt64[], StackFrameTree{T}[])
 end
 
 
@@ -1027,6 +1028,10 @@ function tree_format(frames::Vector{<:StackFrameTree}, level::Int, cols::Int, ma
             base = string(base, "+", nextra, " ")
         end
         strcount = rpad(string(frame.count), ndigcounts, " ")
+        if frame.sleeping
+            stroverhead = styled"{gray:$(stroverhead)}"
+            strcount = styled"{gray:$(strcount)}"
+        end
         if li != UNKNOWN
             if li.line == li.pointer
                 strs[i] = string(stroverhead, "╎", base, strcount, " ",
@@ -1039,6 +1044,7 @@ function tree_format(frames::Vector{<:StackFrameTree}, level::Int, cols::Int, ma
                 else
                     fname = string(li.func)
                 end
+                frame.sleeping && (fname = styled"{gray:$(fname)}")
                 path, pkgname, filename = short_path(li.file, filenamemap)
                 if showpointer
                     fname = string(
@@ -1082,15 +1088,15 @@ function tree!(root::StackFrameTree{T}, all::Vector{UInt64}, lidict::Union{LineI
     skip = false
     nsleeping = 0
     is_task_profile = false
+    is_sleeping = true
     for i in startframe:-1:1
         (startframe - 1) >= i >= (startframe - (nmeta + 1)) && continue # skip metadata (it's read ahead below) and extra block end NULL IP
         ip = all[i]
         if is_block_end(all, i)
             # read metadata
             thread_sleeping_state = all[i - META_OFFSET_SLEEPSTATE] - 1 # subtract 1 as state is incremented to avoid being equal to 0
-            if thread_sleeping_state == 2
-                is_task_profile = true
-            end
+            is_sleeping = thread_sleeping_state == 1
+            is_task_profile = thread_sleeping_state == 2
             # cpu_cycle_clock = all[i - META_OFFSET_CPUCYCLECLOCK]
             taskid = all[i - META_OFFSET_TASKID]
             threadid = all[i - META_OFFSET_THREADID]
@@ -1145,6 +1151,7 @@ function tree!(root::StackFrameTree{T}, all::Vector{UInt64}, lidict::Union{LineI
                         parent = build[j]
                         parent.recur += 1
                         parent.count_recur += 1
+                        parent.sleeping &= is_sleeping
                         found = true
                         break
                     end
@@ -1164,6 +1171,7 @@ function tree!(root::StackFrameTree{T}, all::Vector{UInt64}, lidict::Union{LineI
                     while this !== parent && (recur === :off || this.recur == 0)
                         this.count += 1
                         this.recur = 1
+                        this.sleeping &= is_sleeping
                         this = this.up
                     end
                 end
@@ -1185,6 +1193,7 @@ function tree!(root::StackFrameTree{T}, all::Vector{UInt64}, lidict::Union{LineI
                     this.up = parent
                     this.count += 1
                     this.recur = 1
+                    this.sleeping &= is_sleeping
                 end
                 parent = this
             end
diff --git a/stdlib/Random/src/XoshiroSimd.jl b/stdlib/Random/src/XoshiroSimd.jl
@@ -46,7 +46,7 @@ simdThreshold(::Type{Bool}) = 640
     ui = (x>>>32) % UInt32
     li = x % UInt32
     u = _uint2float(ui, Float32)
-    l = _uint2float(ui, Float32)
+    l = _uint2float(li, Float32)
     (UInt64(reinterpret(UInt32, u)) << 32) | UInt64(reinterpret(UInt32, l))
 end
 @inline function _bits2float(x::UInt64, ::Type{Float16})
diff --git a/stdlib/Random/test/runtests.jl b/stdlib/Random/test/runtests.jl
@@ -1250,6 +1250,16 @@ end
     @test length(xs) == 3
 end
 
+@testset "Float32 RNG typo" begin
+    for T in (Float16, Float32, Float64)
+        # Make sure generated numbers are sufficiently diverse
+        # for both SIMD and non-SIMD RNG code paths for all types.
+        @test length(unique!(rand(T, 7))) > 3
+        @test length(unique!(rand(T, 14))) > 10
+        @test length(unique!(rand(T, 34))) > 20
+    end
+end
+
 @testset "Docstrings" begin
     @test isempty(Docs.undocumented_names(Random))
 end
diff --git a/stdlib/SharedArrays/src/SharedArrays.jl b/stdlib/SharedArrays/src/SharedArrays.jl
diff --git a/test/arrayops.jl b/test/arrayops.jl
diff --git a/test/errorshow.jl b/test/errorshow.jl
diff --git a/test/intrinsics.jl b/test/intrinsics.jl

Original file line number	Diff line number	Diff line change
`@@ -93,8 +93,7 @@ static jl_value_t eval_methoddef(jl_expr_t ex, interpreter_state *s)`
`93`	`93`	`if (!jl_is_symbol(fname)) {`
`94`	`94`	`jl_error("method: invalid declaration");`
`95`	`95`	`}`
`96`		`- jl_binding_t *b = jl_get_binding_for_method_def(modu, fname);`
`97`		`- return jl_declare_const_gf(b, modu, fname);`
	`96`	`+ return jl_declare_const_gf(modu, fname);`
`98`	`97`	`}`
`99`	`98`
`100`	`99`	`jl_value_t atypes = NULL, meth = NULL, *fname = NULL;`
Original file line number	Diff line number	Diff line change
`@@ -876,6 +876,7 @@ STATIC_INLINE size_t module_usings_max(jl_module_t *m) JL_NOTSAFEPOINT {`
`876`	`876`	`return m->usings.max/3;`
`877`	`877`	`}`
`878`	`878`
	`879`	`+JL_DLLEXPORT jl_sym_t jl_module_name(jl_module_t m) JL_NOTSAFEPOINT;`
`879`	`880`	`jl_value_t jl_eval_global_var(jl_module_t m JL_PROPAGATES_ROOT, jl_sym_t *e);`
`880`	`881`	`jl_value_t jl_interpret_opaque_closure(jl_opaque_closure_t clos, jl_value_t **args, size_t nargs);`
`881`	`882`	`jl_value_t jl_interpret_toplevel_thunk(jl_module_t m, jl_code_info_t *src);`
Original file line number	Diff line number	Diff line change
`@@ -1050,10 +1050,11 @@ JL_DLLEXPORT void jl_check_gf(jl_value_t gf, jl_sym_t name)`
`1050`	`1050`	`jl_errorf("cannot define function %s; it already has a value", jl_symbol_name(name));`
`1051`	`1051`	`}`
`1052`	`1052`
`1053`		`-JL_DLLEXPORT jl_value_t jl_declare_const_gf(jl_binding_t b, jl_module_t mod, jl_sym_t name)`
	`1053`	`+JL_DLLEXPORT jl_value_t jl_declare_const_gf(jl_module_t mod, jl_sym_t *name)`
`1054`	`1054`	`{`
`1055`	`1055`	`JL_LOCK(&world_counter_lock);`
`1056`	`1056`	`size_t new_world = jl_atomic_load_relaxed(&jl_world_counter) + 1;`
	`1057`	`+ jl_binding_t *b = jl_get_binding_for_method_def(mod, name, new_world);`
`1057`	`1058`	`jl_binding_partition_t *bpart = jl_get_binding_partition(b, new_world);`
`1058`	`1059`	`jl_ptr_kind_union_t pku = jl_atomic_load_relaxed(&bpart->restriction);`
`1059`	`1060`	`jl_value_t *gf = NULL;`