Merge branch 'master' into lapack_lacpy

Make.inc

@@ -599,10 +599,13 @@ CPP_STDOUT := $(CPP) -P
 # file extensions
 ifeq ($(OS), WINNT)
  SHLIB_EXT := dll
+ PATHSEP := ;
 else ifeq ($(OS), Darwin)
  SHLIB_EXT := dylib
+ PATHSEP := :
 else
  SHLIB_EXT := so
+ PATHSEP := :
 endif
 
 ifeq ($(OS),WINNT)

NEWS.md

@@ -19,6 +19,15 @@ New language features
 
 Language changes
 ----------------
+* During precompilation, the `atexit` hooks now run before saving the output file. This
+ allows users to safely tear down background state (such as closing Timers and sending
+ disconnect notifications to heartbeat tasks) and cleanup other resources when the program
+ wants to begin exiting.
+* Code coverage and malloc tracking is no longer generated during the package precompilation stage.
+ Further, during these modes pkgimage caches are now used for packages that are not being tracked.
+ Meaning that coverage testing (the default for `julia-actions/julia-runtest`) will by default use
+ pkgimage caches for all other packages than the package being tested, likely meaning faster test
+ execution. ([#52123])
 
 Compiler/Runtime improvements
 -----------------------------
@@ -54,6 +63,9 @@ New library functions
 
 New library features
 --------------------
+
+* `invmod(n, T)` where `T` is a native integer type now computes the modular inverse of `n` in the modular integer ring that `T` defines ([#52180]).
+* `invmod(n)` is an abbreviation for `invmod(n, typeof(n))` for native integer types ([#52180]).
 * `replace(string, pattern...)` now supports an optional `IO` argument to
  write the output to a stream rather than returning a string ([#48625]).
 * `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).

README.md

@@ -93,7 +93,7 @@ and then use the command prompt to change into the resulting julia directory. By
 Julia. However, most users should use the [most recent stable version](https://github.com/JuliaLang/julia/releases)
 of Julia. You can get this version by running:
 
- git checkout v1.9.3
+ git checkout v1.9.4
 
 To build the `julia` executable, run `make` from within the julia directory.
 

base/Base.jl

@@ -481,6 +481,7 @@ include("summarysize.jl")
 include("errorshow.jl")
 
 include("initdefs.jl")
+Filesystem.__postinit__()
 
 # worker threads
 include("threadcall.jl")
@@ -594,14 +595,12 @@ if is_primary_base_module
 # Profiling helper
 # triggers printing the report and (optionally) saving a heap snapshot after a SIGINFO/SIGUSR1 profile request
 # Needs to be in Base because Profile is no longer loaded on boot
-const PROFILE_PRINT_COND = Ref{Base.AsyncCondition}()
-function profile_printing_listener()
+function profile_printing_listener(cond::Base.AsyncCondition)
  profile = nothing
  try
- while true
- wait(PROFILE_PRINT_COND[])
- profile = @something(profile, require(PkgId(UUID("9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"), "Profile")))
-
+ while _trywait(cond)
+ # this call to require is mostly legal, only because Profile has no dependencies and is usually in LOAD_PATH
+ profile = @something(profile, require(PkgId(UUID("9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"), "Profile")))::Module
  invokelatest(profile.peek_report[])
  if Base.get_bool_env("JULIA_PROFILE_PEEK_HEAP_SNAPSHOT", false) === true
  println(stderr, "Saving heap snapshot...")
@@ -614,10 +613,13 @@ function profile_printing_listener()
  @error "Profile printing listener crashed" exception=ex,catch_backtrace()
  end
  end
+ nothing
 end
 
 function __init__()
  # Base library init
+ global _atexit_hooks_finished = false
+ Filesystem.__postinit__()
  reinit_stdio()
  Multimedia.reinit_displays() # since Multimedia.displays uses stdout as fallback
  # initialize loading
@@ -633,9 +635,20 @@ function __init__()
  # triggering a profile via signals is not implemented on windows
  cond = Base.AsyncCondition()
  Base.uv_unref(cond.handle)
- PROFILE_PRINT_COND[] = cond
- ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), PROFILE_PRINT_COND[].handle)
- errormonitor(Threads.@spawn(profile_printing_listener()))
+ t = errormonitor(Threads.@spawn(profile_printing_listener(cond)))
+ atexit() do
+ # destroy this callback when exiting
+ ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), C_NULL)
+ # this will prompt any ongoing or pending event to flush also
+ close(cond)
+ # error-propagation is not needed, since the errormonitor will handle printing that better
+ _wait(t)
+ end
+ finalizer(cond) do c
+ # if something goes south, still make sure we aren't keeping a reference in C to this
+ ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), C_NULL)
+ end
+ ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), cond.handle)
  end
  _require_world_age[] = get_world_counter()
  # Prevent spawned Julia process from getting stuck waiting on Tracy to connect.

base/array.jl

@@ -124,8 +124,8 @@ const DenseVecOrMat{T} = Union{DenseVector{T}, DenseMatrix{T}}
  @_safeindex
 
 This internal macro converts:
-- `getindex(xs::Tuple, )` -> `__inbounds_getindex(args...)`
-- `setindex!(xs::Vector, args...)` -> `__inbounds_setindex!(xs, args...)`
+- `getindex(xs::Tuple, i::Int)` -> `__safe_getindex(xs, i)`
+- `setindex!(xs::Vector{T}, x, i::Int)` -> `__safe_setindex!(xs, x, i)`
 to tell the compiler that indexing operations within the applied expression are always
 inbounds and do not need to taint `:consistent` and `:nothrow`.
 """
@@ -143,10 +143,10 @@ function _safeindex(__module__, ex)
  for i = 2:length(lhs.args)
  args[i-1] = _safeindex(__module__, lhs.args[i])
  end
- return Expr(:call, GlobalRef(__module__, :__inbounds_setindex!), xs, _safeindex(__module__, rhs), args...)
+ return Expr(:call, GlobalRef(__module__, :__safe_setindex!), xs, _safeindex(__module__, rhs), args...)
  end
  elseif ex.head === :ref # xs[i]
- return Expr(:call, GlobalRef(__module__, :__inbounds_getindex), ex.args...)
+ return Expr(:call, GlobalRef(__module__, :__safe_getindex), ex.args...)
  end
  args = Vector{Any}(undef, length(ex.args))
  for i = 1:length(ex.args)
@@ -236,13 +236,15 @@ sizeof(a::Array) = length(a) * elsize(typeof(a)) # n.b. this ignores bitsunion b
 
 function isassigned(a::Array, i::Int...)
  @inline
+ @_noub_if_noinbounds_meta
  @boundscheck checkbounds(Bool, a, i...) || return false
  ii = _sub2ind(size(a), i...)
  return @inbounds isassigned(memoryref(a.ref, ii, false))
 end
 
 function isassigned(a::Vector, i::Int) # slight compiler simplification for the most common case
  @inline
+ @_noub_if_noinbounds_meta
  @boundscheck checkbounds(Bool, a, i) || return false
  return @inbounds isassigned(memoryref(a.ref, i, false))
 end
@@ -962,29 +964,23 @@ Dict{String, Int64} with 2 entries:
 function setindex! end
 
 function setindex!(A::Array{T}, x, i::Int) where {T}
+ @_noub_if_noinbounds_meta
  @boundscheck (i - 1)%UInt < length(A)%UInt || throw_boundserror(A, (i,))
  memoryrefset!(memoryref(A.ref, i, false), x isa T ? x : convert(T,x)::T, :not_atomic, false)
  return A
 end
 function setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T}
  @inline
+ @_noub_if_noinbounds_meta
  @boundscheck checkbounds(A, i1, i2, I...) # generally _to_linear_index requires bounds checking
  memoryrefset!(memoryref(A.ref, _to_linear_index(A, i1, i2, I...), false), x isa T ? x : convert(T,x)::T, :not_atomic, false)
  return A
 end
 
-function __inbounds_setindex!(A::Array{T}, x, i::Int) where {T}
- @inline
- val = x isa T ? x : convert(T,x)::T
- memoryrefset!(memoryref(A.ref, i, false), val, :not_atomic, false)
- return A
-end
-function __inbounds_setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T}
- @inline
- val = x isa T ? x : convert(T,x)::T
- memoryrefset!(memoryref(A.ref, _to_linear_index(A, i1, i2, I...), false), val, :not_atomic, false)
- return A
-end
+__safe_setindex!(A::Vector{T}, x::T, i::Int) where {T} = (@inline; @_nothrow_noub_meta;
+ memoryrefset!(memoryref(A.ref, i, false), x, :not_atomic, false); return A)
+__safe_setindex!(A::Vector{T}, x, i::Int) where {T} = (@inline;
+ __safe_setindex!(A, convert(T, x)::T, i))
 
 # This is redundant with the abstract fallbacks but needed and helpful for bootstrap
 function setindex!(A::Array, X::AbstractArray, I::AbstractVector{Int})

base/boot.jl

@@ -281,7 +281,8 @@ macro _foldable_meta()
  #=:terminates_locally=#false,
  #=:notaskstate=#true,
  #=:inaccessiblememonly=#true,
- #=:noub=#true))
+ #=:noub=#true,
+ #=:noub_if_noinbounds=#false))
 end
 
 macro inline() Expr(:meta, :inline) end
@@ -342,6 +343,9 @@ end
 struct ConcurrencyViolationError <: Exception
  msg::AbstractString
 end
+struct MissingCodeError <: Exception
+ mi::MethodInstance
+end
 struct InterruptException <: Exception end
 struct DomainError <: Exception
  val
@@ -477,12 +481,12 @@ end)
 function CodeInstance(
  mi::MethodInstance, @nospecialize(rettype), @nospecialize(inferred_const),
  @nospecialize(inferred), const_flags::Int32, min_world::UInt, max_world::UInt,
- ipo_effects::UInt32, effects::UInt32, @nospecialize(argescapes#=::Union{Nothing,Vector{ArgEscapeInfo}}=#),
+ ipo_effects::UInt32, effects::UInt32, @nospecialize(analysis_results),
  relocatability::UInt8)
  return ccall(:jl_new_codeinst, Ref{CodeInstance},
  (Any, Any, Any, Any, Int32, UInt, UInt, UInt32, UInt32, Any, UInt8),
  mi, rettype, inferred_const, inferred, const_flags, min_world, max_world,
- ipo_effects, effects, argescapes,
+ ipo_effects, effects, analysis_results,
  relocatability)
 end
 GlobalRef(m::Module, s::Symbol) = ccall(:jl_module_globalref, Ref{GlobalRef}, (Any, Any), m, s)

base/c.jl

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