Revision history - refs/heads/sb/sigfpe2 - origin: https://github.com/JuliaLang/julia

visit type:

Newer
Older

Revision	Author	Date	Message	Commit Date
808d7ac	Shuhei Kadowaki	20 November 2023, 09:17:13 UTC	inference: fix exception type of `typename` call	21 November 2023, 09:51:17 UTC
da1258c	Shuhei Kadowaki	20 November 2023, 09:16:44 UTC	`typeinf_local`: factor into `update_cycle_worklists!` utility	21 November 2023, 09:51:17 UTC
15ab026	Shuhei Kadowaki	20 November 2023, 17:59:58 UTC	inference: add reflection utility for exception type analysis This commit defines functions that mirror our tools for analyzing return types and computational effects. The key point to discuss is that this commit introduces two functions: `Base.exception_types` and `Base.exception_type`. `Base.exception_types` acts like `Base.return_types`, giving a list of exception types for each method that matches with the given call signature. On the other hand, `Base.exception_type` is akin to `Base.infer_effects`, returning a single exception type that covers all potential outcomes entailed by the given call signature. I personally lean towards the latter for its utility, particularly in testing scenarios, but I included `exception_types` too for consistency with `return_types`. I'd welcome any feedback on this approach.	21 November 2023, 09:15:27 UTC
65090d1	Kristoffer Carlsson	21 November 2023, 02:08:45 UTC	tweak the error printed for `PrecompileError` to indicate that it doesn't have to be due to `__precompile__(false)` (#51367)	21 November 2023, 02:08:45 UTC
67161a3	Mosè Giordano	20 November 2023, 17:10:15 UTC	Silence noisy test in `test/cmdlineargs.jl` (#52225) This is spamming ([example](https://buildkite.com/julialang/julia-master/builds/30247#018be235-0cd3-43bb-ba43-cc378ac0d682/792-1056)) ``` From worker 12: ERROR: LoadError: UndefVarError: `@which` not defined in `Main` From worker 12: Stacktrace: From worker 12: [1] top-level scope From worker 12: @ :0 From worker 12: [2] lower From worker 12: @ ./meta.jl:163 [inlined] From worker 12: [3] eval_user_input(errio::IOContext{Base.PipeEndpoint}, ast::Any, show_value::Bool) From worker 12: @ Base ./client.jl:141 From worker 12: [4] run_main_repl(interactive::Bool, quiet::Bool, banner::Symbol, history_file::Bool, color_set::Bool) From worker 12: @ Base ./client.jl:477 From worker 12: [5] repl_main From worker 12: @ Base ./client.jl:561 [inlined] From worker 12: [6] _start() From worker 12: @ Base ./client.jl:535 From worker 12: in expression starting at none:1 ``` in all jobs	20 November 2023, 17:10:15 UTC
5cb0e51	Tim Besard	20 November 2023, 15:45:21 UTC	build: ASAN fixes for glibc (#51755) For the `sigsetjmp` bypass; looks like glibc removed the `__libc_siglongjmp` symbol in glibc 2.34, so change to using the approach taking by our `dlopen` wrapper instead. Adopts topolarity's fixes from #50170 Resolves #47698 Co-authored-by: Jameson Nash <vtjnash@gmail.com>	20 November 2023, 15:45:21 UTC
7327a8f	Shuhei Kadowaki	20 November 2023, 13:23:39 UTC	effects: add some more test cases for `Base.@propagate_inbounds` (#52236)	20 November 2023, 13:23:39 UTC
72cd63c	Jameson Nash	20 November 2023, 03:03:15 UTC	jitlayers: reduce excess alignment of #52182 (#52210)	20 November 2023, 03:03:15 UTC
c8ca350	Keno Fischer	19 November 2023, 22:11:17 UTC	inference: Model type propagation through exceptions (#51754) Currently the type of a caught exception is always modeled as `Any`. This isn't a huge problem, because control flow in Julia is generally assumed to be somewhat slow, so the extra type imprecision of not knowing the return type does not matter all that much. However, there are a few situations where it matters. For example: ``` maybe_getindex(A, i) = try; A[i]; catch e; isa(e, BoundsError) && return nothing; rethrow(); end ``` At present, we cannot infer :nothrow for this method, even if that is the only error type that `A[i]` can throw. This is particularly noticable, since we can now optimize away `:nothrow` exception frames entirely (#51674). Note that this PR still does not make the above example particularly efficient (at least interprocedurally), though specialized codegen could be added on top of this to make that happen. It does however improve the inference result. A second major motivation of this change is that reasoning about exception types is likely to be a major aspect of any future work on interface checking (since interfaces imply the absence of MethodErrors), so this PR lays the groundwork for appropriate modeling of these error paths. Note that this PR adds all the required plumbing, but does not yet have a particularly precise model of error types for our builtins, bailing to `Any` for any builtin not known to be `:nothrow`. This can be improved in follow up PRs as required.	19 November 2023, 22:11:17 UTC
f5d189f	Shuhei Kadowaki	19 November 2023, 15:50:33 UTC	effects: don't taint `:noub` for `:new` allocations (#52222) After #52169, the UB previously associated with allocations with uninitialized fields has been addressed, so there's no longer a need to taint `:noub` for `:new` allocations during abstract interpretation. I believe, even without #52169, uninitialized field does not inherently leads to UB, but just causes inconsistency of the program, since what actually causes UB is `getfield` that accesses into whatever object, but not the allocation itself.	19 November 2023, 15:50:33 UTC
c07893d	Jishnu Bhattacharya	19 November 2023, 10:09:19 UTC	Cartesian indexing for SubArrays with non-integer AbstractRanges (#52094) With #50457 now merged, an `AbstractRange` of `CartesianIndex`es should use `CartesianIndexing` in constructing a `SubArray`. I've limited the method to integer ranges, as this is the case where we know for sure that the indexing may be linear. Fixes ```julia julia> view(1:2, StepRangeLen(CartesianIndex(1), CartesianIndex(1), 0)) 0-element view(::UnitRange{Int64}, StepRangeLen(CartesianIndex(1,), CartesianIndex(1,), 0)) with eltype Int64 ``` --------- Co-authored-by: N5N3 <2642243996@qq.com>	19 November 2023, 10:09:19 UTC
ec3911c	Daniel Karrasch	19 November 2023, 08:36:43 UTC	Add `lmul!` and `rmul!` for `Bidiagonal` (#51777)	19 November 2023, 08:36:43 UTC
19ca07d	Keno Fischer	19 November 2023, 08:29:29 UTC	cfg_simplify: Fix phi node renaming corner case bug (#52224) Depending on the order of basic block, cfg_simplify! could occasionally forget to renumber a phinode edge, causing at best a downstream assertion and at worst a miscompile. The root of this issue is that ordinarily, we detect whether a phinode edge requires later renaming by looking at the last inserted index, and since we process all indices by order, detecting whether we have already inserted a certain value is a simple comparison. However, cfg_simplify! re-arranges the order of basic blocks, so this check no longer works. Instead, we check whether the incoming edge has already been scheduled. This is slightly less precise (because it is possible for the edge itself to not have been scheduled, even though the value has been), but correct and a slight imprecision here at worst causes a negligible compile-time increase.	19 November 2023, 08:29:29 UTC
41a6f26	Keno Fischer	19 November 2023, 08:29:15 UTC	Thread lattice through escape analysis (#52223) As of #51494 is used in the base pipeline, so external abstract interpreters inherit it by default. To avoid breaking them, make sure we properly pass down the lattice.	19 November 2023, 08:29:15 UTC
e75dd47	Mosè Giordano	18 November 2023, 11:32:51 UTC	[nghttp2_jll] Upgrade to v1.58.0 (#52218) Usual memo to self: * update version in `stdlib/nghttp2_jll/Project.toml` and `deps/nghttp2.version` * update test in `stdlib/nghttp2_jll/test/runtests.jl` * refresh checksums with `make -f contrib/refresh_checksums.mk -j nghttp2`	18 November 2023, 11:32:51 UTC
959b474	Frank Ebel	18 November 2023, 10:43:17 UTC	docs: update latest stable version (#52215)	18 November 2023, 10:43:17 UTC
e754f20	Lars Göttgens	18 November 2023, 06:30:38 UTC	Add missing type annotation reported by JET (#52207) We already know from https://github.com/lgoettgens/julia/blob/d0a3edddda407302930f3b2a742a7c8ebbcafb5b/base/loading.jl#L1212 that the value is not `nothing`. However, type inference does not know that as the check lives in a different function.	18 November 2023, 06:30:38 UTC
81afdbc	Jameson Nash	17 November 2023, 23:44:45 UTC	codegen: remove UB from uninitialized bitstypes in new (#52169) In the time since the creation of issue #26764, there _is_ now 'a way to say to llvm "I don't care what this value is, but it always has to be the same"' using the `freeze` instruction, so we can use that to instruct LLVM to not give us undefined behavior when users are using uninitialized memory. There should not be an impact if users were already avoiding this paradigm and are fully initializing their structs. Fixes #26764	17 November 2023, 23:44:45 UTC
625bbde	Jameson Nash	17 November 2023, 23:43:52 UTC	build: disable DT_TEXTREL warning for i686 (#52211) This warning was distracting and annoying me, so I looked into whether it was a bug. Turns out the warning is harmless (loading the object just will make a copy of the ~2kb text field into memory). So add the code to disable it, either with different assembly or different linker flags. Default to continuing to use the same assembly.	17 November 2023, 23:43:52 UTC
20440fd	Lilith Orion Hafner	17 November 2023, 19:46:52 UTC	Move "Creating Packages" from Pkg.jl docs (#52102)	17 November 2023, 19:46:52 UTC
9aa7980	Jameson Nash	17 November 2023, 18:58:01 UTC	codegen: ensure i1 bool is widened to i8 before storing (#52189) Teach value_to_pointer to convert primitive types to their stored representation first, to avoid exposing undef bits later (via memcpy). Take this opportunity to also generalizes the support for zext Bool to anywhere inside any struct for changing any bitwidth to a multiple of 8 bytes. This would change a vector like <2 x i4> from occupying i8 to i16 (c.f. LLVM's LangRef), if such an operation were expressible in Julia today. And take this opportunity to do a bit of code cleanup, now that codegen is better and using helpers from LLVM. Fixes #52127	17 November 2023, 18:58:01 UTC
045b6f9	Stefan Karpinski	17 November 2023, 16:46:13 UTC	invmod(n::BitInteger): efficient native modular inverses (#52180) Implement algorithm described in https://arxiv.org/pdf/2204.04342.pdf. The algorithm is pleasingly simple and efficient and the generic Julia implementation is also really enjoyable.	17 November 2023, 16:46:13 UTC
234a758	Shuhei Kadowaki	17 November 2023, 16:25:51 UTC	post-opt-analysis: use EA to refine `:effect_free` (#51494) This commit is aiming to integrate EA into the Base compiler pipeline by using it during the post-opt analysis to refine `:effect_free` information. In doing so, this also generalizes `argescapes` field of `Union{InferenceResult,CodeInstance}` to `analysis_results::AnalysisResults` so that it can hold results of multiple post-optimization analyses, where `AnalysisResults` is designed to be linked-list like data structure. This is because an external `AbstractInterpreter`, like `EscapeAnalyzer`, might perform several post-optimization analyses. Honestly speaking, however, I’m not completely satisfied with this solution yet. It might make more sense to require a single post-optimization analysis for every `AbstractInterpreter` always, as like what we do for the other fields like `rettype`. Co-authored-by: Keno Fischer <keno@juliacomputing.com>	17 November 2023, 16:25:51 UTC
1134315	Shuhei Kadowaki	17 November 2023, 16:21:29 UTC	effects: taint :noub for memory operations (#52186) Currently our effects system does not track `:noub` about memory operations. While this sounds unsafe, it's actually not problematic in most contexts. We restrict concrete-evaluation for anything involing memory operations anyway, as mutable values aren't propagated as compile-time constants (except `Symbol`s). However, it turns out that this is actually causing very dangerous situations in REPL completion context, where `REPLInterpreter` enables aggressive concrete-evaluation that propagates mutable values as constants and ignores the `:consisten`-cy requirement that is usually tainted by memory operations. This commit addresses this issue by tainting `:noub` for memory operations. This commit ends up being somewhat extensive because it would cause significant regression in REPL completions if we make memory ops naively taint `:noub`. Complicating this further is the Base's uses of `boundscheck=false` for peak performance of core memory operations, where bounds checking is conducted separately before performing actual memory operations, e.g.: > essentials.jl ```julia function getindex(A::Array, i::Int) @boundscheck ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A))) \|\| throw_boundserror(A, (i,)) memoryrefget(memoryref(getfield(A, :ref), i, false), :not_atomic, false) end ``` Here `boundscheck=false` should generally taint `:noub` immediately, but in this kind of case `:noub` can actually be `NOUB_IF_NOINBOUNDS` since it has `@boundscheck` that asserts safety of the memory ops. Note that we could employ a similar technique to `getfield` if we change the above implementation to something like: ```julia function getindex(A::Array, i::Int) memoryrefget(memoryref(getfield(A, :ref), i, @_boundscheck), :not_atomic, @_boundscheck) end ``` although this would end up being slower (check the difference at the code LLVM emits on each implementation if interested). To this end, this commit also introduces new `:noub_if_noinbounds` setting to `@assume_effects` and use it within the base implementation. Now `UInt8` is not enough to represent `EffectsOverride` information, the bit is enlarged to `UInt16`. While this approach might not be ideal, I don't think there is a better way to do this. An alternative I tried before making this commit was to introduce new semantics for `Expr(:boundscheck, ...)` where `Expr(:boundscheck, nothing)` will be constant folded to `false` during codegen while during inference time it does not taint `:noub`. I felt this further complicates the already complex complext `:boundscheck` situation, so I decided to go with the approach to expand the settings set of `@assume_effects`.	17 November 2023, 16:21:29 UTC
03bbf91	Shuhei Kadowaki	17 November 2023, 15:00:13 UTC	remove `switch_[to\|from]_irinterp` mechanism (#52204) This seems to cause (probably not very profitable) union-splitting all over the place and complicate code generation. Let's just remove it. As a result, this would slightly reduce image sizes too.	17 November 2023, 15:00:13 UTC
8af47bd	Shuhei Kadowaki	17 November 2023, 14:58:49 UTC	irinterp: check if `IRCode` has been compacted (#52203) Adds assertion that checks if `IRCode` passed to irinterp or post-opt analysis has been compacted. And using the invariant from the assertion, this commit also propagates `inst::Instruction` for `scan!` callbacks instead of `stmt` and removes `idx::Int` argument since it is redundant with `inst.idx`.	17 November 2023, 14:58:49 UTC
f1f84a2	Mosè Giordano	17 November 2023, 14:23:49 UTC	[OpenBLAS_jll] Upgrade to v0.3.25 (#52178) See the [release notes of v0.3.25](https://github.com/OpenMathLib/OpenBLAS/releases/tag/v0.3.25). Usual memo to self for the upgrade: * update version number in `stdlib/OpenBLAS_jll/Project.toml` * run `make -f contrib/refresh_checksums.mk -j openblas` to update the checksums * update version number and commit hash in `deps/openblas.version`	17 November 2023, 14:23:49 UTC
29be3ef	Valentin Churavy	17 November 2023, 13:21:50 UTC	Move heap_size batching code into pair of functions (#51611) Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com>	17 November 2023, 13:21:50 UTC
a65bc9a	Jameson Nash	17 November 2023, 02:55:10 UTC	jitlayers: replace sharedbytes intern pool with one that respects alignment (#52182) The llvm optimizations may increase alignment beyond the initial MAX_ALIGN. This pool's alignment was previously only `sizeof(struct { atomic<int> RefCount; size_t Length; char Data[]; })` however, potentially resulting in segfaults at runtime. Fixes #52118. Should make CI much happier.	17 November 2023, 02:55:10 UTC
1cb85ad	Kristoffer Carlsson	17 November 2023, 02:41:28 UTC	Revert "Support sorting iterators (#46104)" (#52010) Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>	17 November 2023, 02:41:28 UTC
f26947b	Diogo Netto	17 November 2023, 02:09:09 UTC	cap the number of GC threads to number of cpu cores (#52192)	17 November 2023, 02:09:09 UTC
b1c8e12	Ian Butterworth	16 November 2023, 19:51:25 UTC	Use pkgimages for coverage & malloc tracking by ignoring native code in tracked packages (#52123)	16 November 2023, 19:51:25 UTC
40e56a5	Diogo Netto	16 November 2023, 19:15:03 UTC	add some instrumentation to measure page utilization per size class (#52164) One of the limitations is that it's only accurate right after the GC. Still might be helpful for observability purposes.	16 November 2023, 19:15:03 UTC
7f18f76	Shuhei Kadowaki	16 November 2023, 16:51:06 UTC	inference: enhance memoryop tfunc robustness (#52185) Make them able to handle potential `Vararg` argument. Also adds plenty of tests.	16 November 2023, 16:51:06 UTC
4689850	Jishnu Bhattacharya	16 November 2023, 16:14:45 UTC	Compatible parent index when displaying dots in SubArrays (#52097) Fix #52095 by passing the `reindex`ed indices through `to_indices` to convert them to `Integer`s. This should strip `CartesianIndex`es in particular, which resolves the issue. Fixes: ```julia julia> view(1:2, [CartesianIndex(2)]) 1-element view(::UnitRange{Int64}, CartesianIndex{1}[CartesianIndex(2,)]) with eltype Int64: 2 ```	16 November 2023, 16:14:45 UTC
2fb06a7	Shuhei Kadowaki	16 November 2023, 07:19:22 UTC	inference: streamline `builtin_effects` (#52177) Composed of the following two commits: --- > stop passing `arginfo` to `builtin_effects` (e758d079d7f1aa185f2e90273be0340d669dfa3e) `builtin_effects` no longer requires the `arginfo` parameter, as `getfield_effects` doesn't depend on analyzing `fargs` for `:boundscheck` information anymore. The equivalent analysis is now done as the post-opt analysis. Given that `:boundscheck` expressions are now lowered to an independent statement, even if we need to analyze `fargs` within `builtin_effects`, we would likely need to pass `sv::AbsIntState` too in order to allow it to use `ssa_def_slot`. For now, it's more efficient to just eliminate the passing of `arginfo` since it is not necessary. --- > exclude the first builtin function from `argtypes` of `builtin_effects` (90c7477223f72839a2927a1ef6b3d293fde6a945) Streamlined the `builtin_effects` function to accept `argtypes` without including the builtin function itself. The first argument in the previous implementation of `argtypes` was just redundant. This change might reduce unnecessary allocations. ---	16 November 2023, 07:19:22 UTC
574c5d1	Shuhei Kadowaki	15 November 2023, 13:40:54 UTC	exclude the first builtin function from `argtypes` of `builtin_effects` Streamlined the `builtin_effects` function to accept `argtypes` without including the builtin function itself. The first argument in the previous implementation of `argtypes` was just redundant. This change might reduce unnecessary allocations.	16 November 2023, 05:29:13 UTC
3c82403	Shuhei Kadowaki	15 November 2023, 13:28:46 UTC	stop passing `arginfo` to `builtin_effects` `builtin_effects` no longer requires the `arginfo` parameter, as `getfield_effects` doesn't depend on analyzing `fargs` for `:boundscheck` information anymore. The equivalent analysis is now done as the post-opt analysis. Given that `:boundscheck` expressions are now lowered to an independent statement, even if we need to analyze `fargs` within `builtin_effects`, we would likely need to pass `sv::AbsIntState` too in order to allow it to use `ssa_def_slot`. For now, it's more efficient to just eliminate the passing of `arginfo` since it is not necessary.	16 November 2023, 05:29:13 UTC
253cddc	Shuhei Kadowaki	16 November 2023, 05:27:32 UTC	enhance maintainability of `jl_ir_` accessors (#52167) By allowing us to change data size at one place when we make a change to the layout of compressed IR.	16 November 2023, 05:27:32 UTC
aa00204	DilumAluthgeBot	16 November 2023, 00:54:28 UTC	🤖 [master] Bump the SparseArrays stdlib from 7786a73 to f154de2 (#52183) Co-authored-by: Dilum Aluthge <dilum@aluthge.com>	16 November 2023, 00:54:28 UTC