update to root.

.travis.yml

@@ -145,6 +145,9 @@ script:
     # restore initial state and prepare for travis caching
     - mv julia2 julia &&
         rm -f julia/deps/scratch/libgit2-*/CMakeFiles/CMakeOutput.log
+    # run the LLVM tests on Linux
+    - if [ `uname` = "Linux" ]; then
+        pushd julia && make -C test/llvmpasses && popd; fi
     # run the doctests on Linux 64-bit
     - if [ `uname` = "Linux" ] && [ $ARCH = "x86_64" ]; then
         pushd julia && make -C doc doctest=true && popd; fi

HISTORY.md

@@ -625,7 +625,7 @@ Library improvements
   * The `crc32c` function for CRC-32c checksums is now exported ([#22274]).
 
   * `eye(::Type{Diagonal{T}}, m::Integer)` has been deprecated in favor of
-    `Diagonal{T}(I, m)` ([#24413]).
+    `Diagonal{T}(I, m)` ([#24415]).
 
   * The output of `versioninfo` is now controlled with keyword arguments ([#21974]).
 
@@ -1247,7 +1247,7 @@ Deprecated or removed
   * `search(buf::IOBuffer, delim::UInt8)` has been deprecated in favor of either `occursin(delim, buf)`
     (to test containment) or `readuntil(buf, delim)` (to read data up to `delim`) ([#26600]).
 
-  * `ismatch(regex, str)` has been deprecated in favor of `contains(str, regex)` ([#24673]).
+  * `ismatch(regex, str)` has been deprecated in favor of `occursin(regex, str)` ([#26283]).
 
   * `matchall` has been deprecated in favor of `collect(m.match for m in eachmatch(r, s))` ([#26071]).
 
@@ -1575,6 +1575,7 @@ Command-line option changes
 [#24404]: https://github.com/JuliaLang/julia/issues/24404
 [#24413]: https://github.com/JuliaLang/julia/issues/24413
 [#24414]: https://github.com/JuliaLang/julia/issues/24414
+[#24415]: https://github.com/JuliaLang/julia/issues/24415
 [#24438]: https://github.com/JuliaLang/julia/issues/24438
 [#24445]: https://github.com/JuliaLang/julia/issues/24445
 [#24452]: https://github.com/JuliaLang/julia/issues/24452

Makefile

@@ -9,7 +9,7 @@ all: debug release
 # sort is used to remove potential duplicates
 DIRS := $(sort $(build_bindir) $(build_depsbindir) $(build_libdir) $(build_private_libdir) $(build_libexecdir) $(build_includedir) $(build_includedir)/julia $(build_sysconfdir)/julia $(build_datarootdir)/julia $(build_datarootdir)/julia/stdlib $(build_man1dir))
 ifneq ($(BUILDROOT),$(JULIAHOME))
-BUILDDIRS := $(BUILDROOT) $(addprefix $(BUILDROOT)/,base src ui doc deps test test/embedding)
+BUILDDIRS := $(BUILDROOT) $(addprefix $(BUILDROOT)/,base src ui doc deps test test/embedding test/llvmpasses)
 BUILDDIRMAKE := $(addsuffix /Makefile,$(BUILDDIRS))
 DIRS := $(DIRS) $(BUILDDIRS)
 $(BUILDDIRMAKE): | $(BUILDDIRS)
@@ -206,7 +206,7 @@ define sysimg_builder
 $$(build_private_libdir)/sys$1-o.a $$(build_private_libdir)/sys$1-bc.a : $$(build_private_libdir)/sys$1-%.a : $$(build_private_libdir)/sys.ji
 	@$$(call PRINT_JULIA, cd $$(JULIAHOME)/base && \
 	if ! $$(call spawn,$3) $2 -C "$$(JULIA_CPU_TARGET)" --output-$$* $$(call cygpath_w,$$@).tmp $$(JULIA_SYSIMG_BUILD_FLAGS) \
-		--startup-file=no --warn-overwrite=yes --sysimage $$(call cygpath_w,$$<) $$(call cygpath_w,$$(JULIAHOME)/contrib/generate_precompile.jl) $$(call cygpath_w,$$<); then \
+		--startup-file=no --warn-overwrite=yes --sysimage $$(call cygpath_w,$$<) $$(call cygpath_w,$$(JULIAHOME)/contrib/generate_precompile.jl); then \
 		echo '*** This error is usually fixed by running `make clean`. If the error persists$$(COMMA) try `make cleanall`. ***'; \
 		false; \
 	fi )

NEWS.md

@@ -11,11 +11,21 @@ Refer to the [Release Notes for
 v0.7](https://github.com/JuliaLang/julia/blob/master/HISTORY.md) for a
 detailed list of changes from Julia v0.6.
 
+Standard Library Changes
+------------------------
+
+* The `Libdl` module's methods `dlopen()` and `dlsym()` have gained a
+  `throw_error` keyword argument, replacing the now-deprecated `dlopen_e()`
+  and `dlsym_e()` methods.  When `throw_error` is `false`, failure to locate
+  a shared library or symbol will return `nothing` rather than `C_NULL`.
+  ([#28888])
+
 Deprecated or removed
 ---------------------
 
-The old package manager (now called `OldPkg`) has been moved to a
-separate repository at https://github.com/JuliaArchive/OldPkg.jl ([#27930])
+* The old package manager (now called `OldPkg`) has been moved to a
+  separate repository at https://github.com/JuliaArchive/OldPkg.jl ([#27930])
 
 <!--- generated by NEWS-update.jl: -->
 [#27930]: https://github.com/JuliaLang/julia/issues/27930
+[#28888]: https://github.com/JuliaLang/julia/issues/28888

README.md

@@ -66,7 +66,7 @@ Julia is built and tested regularly on the following platforms:
 | FreeBSD 11.0+    | x86-64 (64-bit)  | ✓  |          | Community     |
 
 All systems marked with ✓ for CI are tested using continuous integration for every commit.
-Systems with ✓ for binaries have official binaries available on the [downloads](https://julialang.org/downloads) page and are tested regularly. The PTX backend needs a source build and the [CUDAnative.jl](https://github.com/JuliaGPU/CUDAnative.jl) package.
+Systems with ✓ for binaries have official binaries available on the [downloads](https://julialang.org/downloads) page and are tested regularly. The PTX backend needs the [CUDAnative.jl](https://github.com/JuliaGPU/CUDAnative.jl) package.
 The systems listed here with neither CI nor official binaries are known to build and work, but ongoing support for those platforms is dependent on community efforts.
 It is possible that Julia will build and work on other platforms too, and we're always looking to better our platform coverage.
 If you're using Julia on a platform not listed here, let us know!

base/Enums.jl

@@ -103,7 +103,7 @@ macro enum(T, syms...)
                length(s.args) == 2 && isa(s.args[1], Symbol)
             i = Core.eval(__module__, s.args[2]) # allow exprs, e.g. uint128"1"
             if !isa(i, Integer)
-                throw(ArgumentError("invalid value for Enum $typename, $s=$i; values must be integers"))
+                throw(ArgumentError("invalid value for Enum $typename, $s; values must be integers"))
             end
             i = convert(basetype, i)
             s = s.args[1]
@@ -154,7 +154,8 @@ macro enum(T, syms...)
             else
                 print(io, x, "::")
                 show(IOContext(io, :compact => true), typeof(x))
-                print(io, " = ", $basetype(x))
+                print(io, " = ")
+                show(io, $basetype(x))
             end
         end
         function Base.show(io::IO, t::Type{$(esc(typename))})

base/accumulate.jl

@@ -191,7 +191,7 @@ cumprod(x::AbstractVector) = cumprod(x, dims=1)
     accumulate(op, A; dims::Integer, [init])
 
 Cumulative operation `op` along the dimension `dims` of `A` (providing `dims` is optional
-for vectors). An inital value `init` may optionally be provided by a keyword argument. See
+for vectors). An initial value `init` may optionally be provided by a keyword argument. See
 also [`accumulate!`](@ref) to use a preallocated output array, both for performance and
 to control the precision of the output (e.g. to avoid overflow). For common operations
 there are specialized variants of `accumulate`, see: [`cumsum`](@ref), [`cumprod`](@ref)

base/compiler/abstractinterpretation.jl

@@ -55,12 +55,15 @@ function abstract_call_gf_by_type(@nospecialize(f), argtypes::Vector{Any}, @nosp
     rettype = Bottom
     edgecycle = false
     edges = Any[]
+    nonbot = 0  # the index of the only non-Bottom inference result if > 0
+    seen = 0    # number of signatures actually inferred
     for i in 1:napplicable
         match = applicable[i]::SimpleVector
         method = match[3]::Method
         sig = match[1]
         sigtuple = unwrap_unionall(sig)::DataType
         splitunions = false
+        this_rt = Bottom
         # TODO: splitunions = 1 < countunionsplit(sigtuple.parameters) * napplicable <= sv.params.MAX_UNION_SPLITTING
         # currently this triggers a bug in inference recursion detection
         if splitunions
@@ -71,24 +74,32 @@ function abstract_call_gf_by_type(@nospecialize(f), argtypes::Vector{Any}, @nosp
                     push!(edges, edge)
                 end
                 edgecycle |= edgecycle1::Bool
-                rettype = tmerge(rettype, rt)
-                rettype === Any && break
+                this_rt = tmerge(this_rt, rt)
+                this_rt === Any && break
             end
-            rettype === Any && break
         else
-            rt, edgecycle, edge = abstract_call_method(method, sig, match[2]::SimpleVector, sv)
+            this_rt, edgecycle, edge = abstract_call_method(method, sig, match[2]::SimpleVector, sv)
             if edge !== nothing
                 push!(edges, edge)
             end
-            rettype = tmerge(rettype, rt)
-            rettype === Any && break
         end
+        if this_rt !== Bottom
+            if nonbot === 0
+                nonbot = i
+            else
+                nonbot = -1
+            end
+        end
+        seen += 1
+        rettype = tmerge(rettype, this_rt)
+        rettype === Any && break
     end
-    if napplicable == 1 && !edgecycle && isa(rettype, Type) && sv.params.ipo_constant_propagation
+    # try constant propagation if only 1 method is inferred to non-Bottom
+    if nonbot > 0 && seen == napplicable && !edgecycle && isa(rettype, Type) && sv.params.ipo_constant_propagation
         # if there's a possibility we could constant-propagate a better result
         # (hopefully without doing too much work), try to do that now
         # TODO: it feels like this could be better integrated into abstract_call_method / typeinf_edge
-        const_rettype = abstract_call_method_with_const_args(f, argtypes, applicable[1]::SimpleVector, sv)
+        const_rettype = abstract_call_method_with_const_args(f, argtypes, applicable[nonbot]::SimpleVector, sv)
         if const_rettype ⊑ rettype
             # use the better result, if it's a refinement of rettype
             rettype = const_rettype
@@ -704,7 +715,7 @@ function abstract_call(@nospecialize(f), fargs::Union{Tuple{},Vector{Any}}, argt
             return ret
         end
         return Any
-    elseif f === return_type
+    elseif is_return_type(f)
         rt_rt = return_type_tfunc(argtypes, vtypes, sv)
         if rt_rt !== NOT_FOUND
             return rt_rt
@@ -755,7 +766,7 @@ function abstract_call(@nospecialize(f), fargs::Union{Tuple{},Vector{Any}}, argt
     t = pure_eval_call(f, argtypes, atype, sv)
     t !== false && return t
 
-    if istopfunction(f, :typejoin) || f === return_type
+    if istopfunction(f, :typejoin) || is_return_type(f)
         return Type # don't try to infer these function edges directly -- it won't actually come up with anything useful
     end
 

base/compiler/compiler.jl

@@ -32,6 +32,7 @@ include("options.jl")
 
 # core operations & types
 function return_type end # promotion.jl expects this to exist
+is_return_type(@Core.nospecialize(f)) = f === return_type
 include("promotion.jl")
 include("tuple.jl")
 include("pair.jl")

base/compiler/optimize.jl

@@ -89,7 +89,7 @@ const _PURE_BUILTINS = Any[tuple, svec, ===, typeof, nfields]
 const _PURE_OR_ERROR_BUILTINS = [
     fieldtype, apply_type, isa, UnionAll,
     getfield, arrayref, isdefined, Core.sizeof,
-    Core.kwfunc
+    Core.kwfunc, ifelse
 ]
 
 const TOP_TUPLE = GlobalRef(Core, :tuple)

base/compiler/ssair/driver.jl

@@ -117,9 +117,9 @@ function run_passes(ci::CodeInfo, nargs::Int, sv::OptimizationState)
     @timeit "compact 1" ir = compact!(ir)
     @timeit "Inlining" ir = ssa_inlining_pass!(ir, ir.linetable, sv)
     #@timeit "verify 2" verify_ir(ir)
-    @timeit "domtree 2" domtree = construct_domtree(ir.cfg)
     ir = compact!(ir)
     #@Base.show ("before_sroa", ir)
+    @timeit "domtree 2" domtree = construct_domtree(ir.cfg)
     @timeit "SROA" ir = getfield_elim_pass!(ir, domtree)
     #@Base.show ir.new_nodes
     #@Base.show ("after_sroa", ir)

base/compiler/ssair/inlining.jl

@@ -70,6 +70,7 @@ mutable struct CFGInliningState
     todo_bbs::Vector{Tuple{Int, Int}}
     first_bb::Int
     bb_rename::Vector{Int}
+    dead_blocks::Vector{Int}
     split_targets::BitSet
     merged_orig_blocks::BitSet
     cfg::CFG
@@ -82,6 +83,7 @@ function CFGInliningState(ir::IRCode)
         Tuple{Int, Int}[],
         0,
         zeros(Int, length(ir.cfg.blocks)),
+        Vector{Int}(),
         BitSet(),
         BitSet(),
         ir.cfg
@@ -172,18 +174,24 @@ function cfg_inline_item!(item::InliningTodo, state::CFGInliningState, from_unio
         push!(state.new_cfg_blocks[first(bb_rename_range)].preds, first(bb_rename_range)-1)
     end
 
+    any_edges = false
     for (old_block, new_block) in enumerate(bb_rename_range)
         if (length(state.new_cfg_blocks[new_block].succs) == 0)
             terminator_idx = last(inlinee_cfg.blocks[old_block].stmts)
             terminator = item.ir[SSAValue(terminator_idx)]
             if isa(terminator, ReturnNode) && isdefined(terminator, :val)
+                any_edges = true
                 push!(state.new_cfg_blocks[new_block].succs, post_bb_id)
                 if need_split
                     push!(state.new_cfg_blocks[post_bb_id].preds, new_block)
                 end
             end
         end
     end
+
+    if !any_edges
+        push!(state.dead_blocks, post_bb_id)
+    end
 end
 
 function cfg_inline_unionsplit!(item::UnionSplit, state::CFGInliningState)
@@ -263,6 +271,13 @@ function finish_cfg_inline!(state::CFGInliningState)
             return succ_bb < 0 ? state.bb_rename[-succ_bb] : succ_bb
         end
     end
+
+    # Kill dead blocks
+    for block in state.dead_blocks
+        for succ in state.new_cfg_blocks[block].succs
+            kill_edge!(state.new_cfg_blocks, block, succ)
+        end
+    end
 end
 
 function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector{Any},
@@ -322,7 +337,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
         # This implements the need_split_before flag above
         need_split_before = !isempty(item.ir.cfg.blocks[1].preds)
         if need_split_before
-            finish_current_bb!(compact)
+            finish_current_bb!(compact, 0)
         end
         pn = PhiNode()
         #compact[idx] = nothing
@@ -413,7 +428,7 @@ function ir_inline_unionsplit!(compact::IncrementalCompact, idx::Int,
         end
         insert_node_here!(compact, GotoIfNot(cond, next_cond_bb), Union{}, line)
         bb = next_cond_bb - 1
-        finish_current_bb!(compact)
+        finish_current_bb!(compact, 0)
         argexprs′ = argexprs
         if !isa(case, ConstantCase)
             argexprs′ = copy(argexprs)
@@ -434,24 +449,28 @@ function ir_inline_unionsplit!(compact::IncrementalCompact, idx::Int,
             case = case::ConstantCase
             val = case.val
         end
-        push!(pn.edges, bb)
-        push!(pn.values, val)
-        insert_node_here!(compact, GotoNode(join_bb), Union{}, line)
-        finish_current_bb!(compact)
+        if !isempty(compact.result_bbs[bb].preds)
+            push!(pn.edges, bb)
+            push!(pn.values, val)
+            insert_node_here!(compact, GotoNode(join_bb), Union{}, line)
+        else
+            insert_node_here!(compact, ReturnNode(), Union{}, line)
+        end
+        finish_current_bb!(compact, 0)
     end
     bb += 1
     # We're now in the fall through block, decide what to do
     if item.fully_covered
         e = Expr(:call, GlobalRef(Core, :throw), fatal_type_bound_error)
         insert_node_here!(compact, e, Union{}, line)
         insert_node_here!(compact, ReturnNode(), Union{}, line)
-        finish_current_bb!(compact)
+        finish_current_bb!(compact, 0)
     else
         ssa = insert_node_here!(compact, stmt, typ, line)
         push!(pn.edges, bb)
         push!(pn.values, ssa)
         insert_node_here!(compact, GotoNode(join_bb), Union{}, line)
-        finish_current_bb!(compact)
+        finish_current_bb!(compact, 0)
     end
 
     # We're now in the join block.
@@ -479,7 +498,7 @@ function batch_inline!(todo::Vector{Any}, ir::IRCode, linetable::Vector{LineInfo
         boundscheck = :propagate
     end
 
-    let compact = IncrementalCompact(ir)
+    let compact = IncrementalCompact(ir, false)
         compact.result_bbs = state.new_cfg_blocks
         # This needs to be a minimum and is more of a size hint
         nn = 0
@@ -517,7 +536,7 @@ function batch_inline!(todo::Vector{Any}, ir::IRCode, linetable::Vector{LineInfo
                     ir_inline_unionsplit!(compact, idx, argexprs, linetable, item, boundscheck, state.todo_bbs)
                 end
                 compact[idx] = nothing
-                refinish && finish_current_bb!(compact)
+                refinish && finish_current_bb!(compact, 0)
                 if !isempty(todo)
                     item = popfirst!(todo)
                     inline_idx = item.idx
@@ -847,7 +866,7 @@ function assemble_inline_todo!(ir::IRCode, linetable::Vector{LineInfoNode}, sv::
         sv.params.inlining || continue
 
         # Special case inliners for regular functions
-        if late_inline_special_case!(ir, idx, stmt, atypes, f, ft) || f === return_type
+        if late_inline_special_case!(ir, idx, stmt, atypes, f, ft) || is_return_type(f)
             continue
         end
 
@@ -1061,7 +1080,7 @@ function late_inline_special_case!(ir::IRCode, idx::Int, stmt::Expr, atypes::Vec
         subtype_call = Expr(:call, GlobalRef(Core, :(<:)), stmt.args[3], stmt.args[2])
         ir[SSAValue(idx)] = subtype_call
         return true
-    elseif f === return_type
+    elseif is_return_type(f)
         if isconstType(typ)
             ir[SSAValue(idx)] = quoted(typ.parameters[1])
             return true