JuliaLang · KristofferC · Jul 3, 2025 · Jul 8, 2025 · May 22, 2024 · Jun 18, 2024
diff --git a/.buildkite-external-version b/.buildkite-external-version
@@ -1 +1 @@
-main
+release-julia-1.10
diff --git a/base/client.jl b/base/client.jl
@@ -31,9 +31,6 @@ stackframe_lineinfo_color() = repl_color("JULIA_STACKFRAME_LINEINFO_COLOR", :bol
 stackframe_function_color() = repl_color("JULIA_STACKFRAME_FUNCTION_COLOR", :bold)
 
 function repl_cmd(cmd, out)
-    shell = shell_split(get(ENV, "JULIA_SHELL", get(ENV, "SHELL", "/bin/sh")))
-    shell_name = Base.basename(shell[1])
-
     # Immediately expand all arguments, so that typing e.g. ~/bin/foo works.
     cmd.exec .= expanduser.(cmd.exec)
 
@@ -63,19 +60,15 @@ function repl_cmd(cmd, out)
         cd(dir)
         println(out, pwd())
     else
-        @static if !Sys.iswindows()
-            if shell_name == "fish"
-                shell_escape_cmd = "begin; $(shell_escape_posixly(cmd)); and true; end"
-            else
-                shell_escape_cmd = "($(shell_escape_posixly(cmd))) && true"
-            end
+        if !Sys.iswindows()
+            shell = shell_split(get(ENV, "JULIA_SHELL", get(ENV, "SHELL", "/bin/sh")))
+            shell_escape_cmd = shell_escape_posixly(cmd)
             cmd = `$shell -c $shell_escape_cmd`
         end
         try
             run(ignorestatus(cmd))
         catch
-            # Windows doesn't shell out right now (complex issue), so Julia tries to run the program itself
-            # Julia throws an exception if it can't find the program, but the stack trace isn't useful
+            # Julia throws an exception if it can't find the cmd (which may be the shell itself), but the stack trace isn't useful
             lasterr = current_exceptions()
             lasterr = ExceptionStack([(exception = e[1], backtrace = [] ) for e in lasterr])
             invokelatest(display_error, lasterr)

diff --git a/base/options.jl b/base/options.jl
@@ -9,7 +9,7 @@ struct JLOptions
     commands::Ptr{Ptr{UInt8}} # (e)eval, (E)print, (L)load
     image_file::Ptr{UInt8}
     cpu_target::Ptr{UInt8}
-    nthreadpools::Int16
+    nthreadpools::Int8
     nthreads::Int16
     nmarkthreads::Int16
     nsweepthreads::Int8

diff --git a/base/strings/basic.jl b/base/strings/basic.jl
@@ -795,6 +795,8 @@ write(io::IO, s::CodeUnits) = write(io, s.s)
 unsafe_convert(::Type{Ptr{T}},    s::CodeUnits{T}) where {T} = unsafe_convert(Ptr{T}, s.s)
 unsafe_convert(::Type{Ptr{Int8}}, s::CodeUnits{UInt8}) = unsafe_convert(Ptr{Int8}, s.s)
 
+similar(::Type{<:CodeUnits{T}}, dims::Dims) where {T} = similar(Array{T}, dims)
+
 """
     codeunits(s::AbstractString)
 

diff --git a/base/strings/string.jl b/base/strings/string.jl
@@ -7,9 +7,9 @@ An error occurred when trying to access `str` at index `i` that is not valid.
 """
 struct StringIndexError <: Exception
     string::AbstractString
-    index::Integer
+    index::Int
 end
-@noinline string_index_err(s::AbstractString, i::Integer) =
+@noinline string_index_err((@nospecialize s::AbstractString), i::Integer) =
     throw(StringIndexError(s, Int(i)))
 function Base.showerror(io::IO, exc::StringIndexError)
     s = exc.string

diff --git a/base/strings/unicode.jl b/base/strings/unicode.jl
@@ -725,7 +725,7 @@ isgraphemebreak(c1::AbstractChar, c2::AbstractChar) =
 # Stateful grapheme break required by Unicode-9 rules: the string
 # must be processed in sequence, with state initialized to Ref{Int32}(0).
 # Requires utf8proc v2.0 or later.
-function isgraphemebreak!(state::Ref{Int32}, c1::AbstractChar, c2::AbstractChar)
+@inline function isgraphemebreak!(state::Ref{Int32}, c1::AbstractChar, c2::AbstractChar)
     if ismalformed(c1) || ismalformed(c2)
         state[] = 0
         return true

diff --git a/deps/checksums/openblas b/deps/checksums/openblas
diff --git a/deps/openblas.mk b/deps/openblas.mk
@@ -105,7 +105,17 @@ $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-m1-4003.patch-applied: $(BUILDDIR)/$(OP
 		patch -p1 -f < $(SRCDIR)/patches/openblas-m1-4003.patch
 	echo 1 > $@
 
-$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-m1-4003.patch-applied
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-asum-avx512.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-m1-4003.patch-applied
+	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && \                             
+		patch -p1 -f < $(SRCDIR)/patches/openblas-asum-avx512.patch 
+	echo 1 > $@
+
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-casum-fallback-fix.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-asum-avx512.patch-applied
+	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && \
+		patch -p1 -f < $(SRCDIR)/patches/openblas-casum-fallback-fix.patch
+	echo 1 > $@
+
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-casum-fallback-fix.patch-applied
 	echo 1 > $@
 
 $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-compiled: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured

diff --git a/deps/patches/openblas-asum-avx512.patch b/deps/patches/openblas-asum-avx512.patch
@@ -0,0 +1,68 @@
+From 9019bc494514a74c2042152cdca0a36adea7b42f Mon Sep 17 00:00:00 2001
+From: Martin Kroeker <[email protected]>
+Date: Sat, 4 Nov 2023 22:10:06 +0100
+Subject: [PATCH] Use SkylakeX ?ASUM microkernel for Cooperlake/Sapphirerapids
+ as well
+
+---
+ kernel/x86_64/casum.c | 2 +-
+ kernel/x86_64/dasum.c | 2 +-
+ kernel/x86_64/sasum.c | 2 +-
+ kernel/x86_64/zasum.c | 2 +-
+ 4 files changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/kernel/x86_64/casum.c b/kernel/x86_64/casum.c
+index 60feec0ce..e4d054311 100644
+--- a/kernel/x86_64/casum.c
++++ b/kernel/x86_64/casum.c
+@@ -4,7 +4,7 @@
+ #define ABS_K(a) ((a) > 0 ? (a) : (-(a)))
+ #endif
+
+-#if defined(SKYLAKEX)
++#if defined(SKYLAKEX) || defined(COOPERLAKE) || defined(SAPPHIRERAPIDS)
+ #include "casum_microk_skylakex-2.c"
+ #endif
+
+diff --git a/kernel/x86_64/dasum.c b/kernel/x86_64/dasum.c
+index a9c40f38f..0147c6978 100644
+--- a/kernel/x86_64/dasum.c
++++ b/kernel/x86_64/dasum.c
+@@ -4,7 +4,7 @@
+ #define ABS_K(a) ((a) > 0 ? (a) : (-(a)))
+ #endif
+
+-#if defined(SKYLAKEX)
++#if defined(SKYLAKEX) || defined(COOPERLAKE) || defined(SAPPHIRERAPIDS)
+ #include "dasum_microk_skylakex-2.c"
+ #elif defined(HASWELL) || defined(ZEN)
+ #include "dasum_microk_haswell-2.c"
+diff --git a/kernel/x86_64/sasum.c b/kernel/x86_64/sasum.c
+index 37a92468f..3f22cb97a 100644
+--- a/kernel/x86_64/sasum.c
++++ b/kernel/x86_64/sasum.c
+@@ -9,7 +9,7 @@
+
+ #endif
+
+-#if defined(SKYLAKEX)
++#if defined(SKYLAKEX) || defined(COOPERLAKE) || defined(SAPPHIRERAPIDS)
+ #include "sasum_microk_skylakex-2.c"
+ #elif defined(HASWELL) || defined(ZEN)
+ #include "sasum_microk_haswell-2.c"
+diff --git a/kernel/x86_64/zasum.c b/kernel/x86_64/zasum.c
+index 80e95a2c8..3f17ab1cf 100644
+--- a/kernel/x86_64/zasum.c
++++ b/kernel/x86_64/zasum.c
+@@ -4,7 +4,7 @@
+ #define ABS_K(a) ((a) > 0 ? (a) : (-(a)))
+ #endif
+
+-#if defined(SKYLAKEX)
++#if defined(SKYLAKEX) || defined(COOPERLAKE) || defined(SAPPHIRERAPIDS)
+ #include "zasum_microk_skylakex-2.c"
+ #endif
+
+-- 
+2.50.1
+
diff --git a/deps/patches/openblas-casum-fallback-fix.patch b/deps/patches/openblas-casum-fallback-fix.patch
@@ -0,0 +1,79 @@
+From f8ad5344c210960fc399ca5b0ad8559ab5ca253e Mon Sep 17 00:00:00 2001
+From: Bart Oldeman <[email protected]>
+Date: Fri, 17 Nov 2023 23:49:34 +0000
+Subject: [PATCH] Fix casum fallback kernel.
+
+This kernel is only used on Skylake+ if the kernel with AVX512
+intrinsics can't be used, but used the variable x1 incorrectly
+in the tail end of the loop, as it is still at the initial
+value instead of where x points to.
+
+This caused 55 "other error"s in the LAPACK tests
+(https://github.com/OpenMathLib/OpenBLAS/issues/4282)
+
+This change makes casum.c as similar as possible as zasum.c,
+because zasum.c does this correctly.
+---
+ kernel/x86_64/casum.c | 24 ++++++++++++------------
+ 1 file changed, 12 insertions(+), 12 deletions(-)
+
+diff --git a/kernel/x86_64/casum.c b/kernel/x86_64/casum.c
+index e4d054311..28d78d279 100644
+--- a/kernel/x86_64/casum.c
++++ b/kernel/x86_64/casum.c
+@@ -9,12 +9,12 @@
+ #endif
+
+ #ifndef HAVE_CASUM_KERNEL
+-static FLOAT casum_kernel(BLASLONG n, FLOAT *x1)
++static FLOAT casum_kernel(BLASLONG n, FLOAT *x)
+ {
+
+     BLASLONG i=0;
+     BLASLONG n_8 = n & -8;
+-    FLOAT *x = x1;
++    FLOAT *x1 = x;
+     FLOAT temp0, temp1, temp2, temp3;
+     FLOAT temp4, temp5, temp6, temp7;
+     FLOAT sum0 = 0.0;
+@@ -24,14 +24,14 @@ static FLOAT casum_kernel(BLASLONG n, FLOAT *x1)
+     FLOAT sum4 = 0.0;
+
+     while (i < n_8) {
+-        temp0 = ABS_K(x[0]);
+-        temp1 = ABS_K(x[1]);
+-        temp2 = ABS_K(x[2]);
+-        temp3 = ABS_K(x[3]);
+-        temp4 = ABS_K(x[4]);
+-        temp5 = ABS_K(x[5]);
+-        temp6 = ABS_K(x[6]);
+-        temp7 = ABS_K(x[7]);
++        temp0 = ABS_K(x1[0]);
++        temp1 = ABS_K(x1[1]);
++        temp2 = ABS_K(x1[2]);
++        temp3 = ABS_K(x1[3]);
++        temp4 = ABS_K(x1[4]);
++        temp5 = ABS_K(x1[5]);
++        temp6 = ABS_K(x1[6]);
++        temp7 = ABS_K(x1[7]);
+
+         sum0 += temp0;
+         sum1 += temp1;
+@@ -43,12 +43,12 @@ static FLOAT casum_kernel(BLASLONG n, FLOAT *x1)
+         sum2 += temp6;
+         sum3 += temp7;
+
+-        x+=8;
++        x1+=8;
+         i+=4;
+     }
+
+      while (i < n) {
+-        sum4 += (ABS_K(x1[0]) + ABS_K(x1[1]));
++        sum4 += ABS_K(x1[0]) + ABS_K(x1[1]);
+         x1 += 2;
+         i++;
+      }
+-- 
+2.50.1
+
diff --git a/doc/src/devdocs/eval.md b/doc/src/devdocs/eval.md
@@ -62,25 +62,11 @@ The 10,000 foot view of the whole process is as follows:
 
 ## [Parsing](@id dev-parsing)
 
-The Julia parser is a small lisp program written in femtolisp, the source-code for which is distributed
-inside Julia in [src/flisp](https://github.com/JuliaLang/julia/tree/master/src/flisp).
-
-The interface functions for this are primarily defined in [`jlfrontend.scm`](https://github.com/JuliaLang/julia/blob/master/src/jlfrontend.scm).
-The code in [`ast.c`](https://github.com/JuliaLang/julia/blob/master/src/ast.c) handles this handoff
-on the Julia side.
-
-The other relevant files at this stage are [`julia-parser.scm`](https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm),
-which handles tokenizing Julia code and turning it into an AST, and [`julia-syntax.scm`](https://github.com/JuliaLang/julia/blob/master/src/julia-syntax.scm),
-which handles transforming complex AST representations into simpler, "lowered" AST representations
-which are more suitable for analysis and execution.
-
-If you want to test the parser without re-building Julia in its entirety, you can run the frontend
-on its own as follows:
-
-    $ cd src
-    $ flisp/flisp
-    > (load "jlfrontend.scm")
-    > (jl-parse-file "<filename>")
+By default, Julia uses [JuliaSyntax.jl](https://github.com/JuliaLang/JuliaSyntax.jl) to produce the
+AST. Historically, it used a small lisp program written in femtolisp, the source-code for which is
+distributed inside Julia in [src/flisp](https://github.com/JuliaLang/julia/tree/master/src/flisp).
+If the `JULIA_USE_FLISP_PARSER` environment variable is set to `1`, the old parser will be used
+instead.
 
 ## [Macro Expansion](@id dev-macro-expansion)
 

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
@@ -638,13 +638,13 @@ static Value *emit_struct_gep(jl_codectx_t &ctx, Type *lty, Value *base, unsigne
 
 static Type *_julia_struct_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt, jl_value_t *jt, bool *isboxed, bool llvmcall=false);
 
-static Type *_julia_type_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt, jl_value_t *jt, bool *isboxed)
+static Type *_julia_type_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt, jl_value_t *jt, bool *isboxed, bool no_boxing)
 {
     // this function converts a Julia Type into the equivalent LLVM type
     if (isboxed) *isboxed = false;
     if (jt == (jl_value_t*)jl_bottom_type)
         return getVoidTy(ctxt);
-    if (jl_is_concrete_immutable(jt)) {
+    if (jl_is_concrete_immutable(jt) || no_boxing) {
         if (jl_datatype_nbits(jt) == 0)
             return getVoidTy(ctxt);
         Type *t = _julia_struct_to_llvm(ctx, ctxt, jt, isboxed);
@@ -657,13 +657,20 @@ static Type *_julia_type_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt, jl
 
 static Type *julia_type_to_llvm(jl_codectx_t &ctx, jl_value_t *jt, bool *isboxed)
 {
-    return _julia_type_to_llvm(&ctx.emission_context, ctx.builder.getContext(), jt, isboxed);
+    return _julia_type_to_llvm(&ctx.emission_context, ctx.builder.getContext(), jt, isboxed, false);
 }
 
 extern "C" JL_DLLEXPORT_CODEGEN
 Type *jl_type_to_llvm_impl(jl_value_t *jt, LLVMContextRef ctxt, bool *isboxed)
 {
-    return _julia_type_to_llvm(NULL, *unwrap(ctxt), jt, isboxed);
+    return _julia_type_to_llvm(NULL, *unwrap(ctxt), jt, isboxed, false);
+}
+
+
+extern "C" JL_DLLEXPORT_CODEGEN
+Type *jl_struct_to_llvm_impl(jl_value_t *jt, LLVMContextRef ctxt, bool *isboxed)
+{
+    return _julia_type_to_llvm(NULL, *unwrap(ctxt), jt, isboxed, true);
 }
 
 
@@ -3086,6 +3093,7 @@ static void init_bits_value(jl_codectx_t &ctx, Value *newv, Value *v, MDNode *tb
 static void init_bits_cgval(jl_codectx_t &ctx, Value *newv, const jl_cgval_t& v, MDNode *tbaa)
 {
     // newv should already be tagged
+    newv = maybe_decay_tracked(ctx, newv);
     if (v.ispointer()) {
         emit_memcpy(ctx, newv, jl_aliasinfo_t::fromTBAA(ctx, tbaa), v, jl_datatype_size(v.typ), sizeof(void*));
     }

diff --git a/src/codegen-stubs.c b/src/codegen-stubs.c
@@ -97,6 +97,8 @@ JL_DLLEXPORT LLVMOrcThreadSafeModuleRef jl_get_llvm_module_fallback(void *native
 
 JL_DLLEXPORT void *jl_type_to_llvm_fallback(jl_value_t *jt, LLVMContextRef llvmctxt, bool_t *isboxed) UNAVAILABLE
 
+JL_DLLEXPORT void *jl_struct_to_llvm_fallback(jl_value_t *jt, LLVMContextRef llvmctxt, bool_t *isboxed) UNAVAILABLE
+
 JL_DLLEXPORT jl_value_t *jl_get_libllvm_fallback(void) JL_NOTSAFEPOINT
 {
     return jl_nothing;

diff --git a/src/codegen.cpp b/src/codegen.cpp
@@ -6553,8 +6553,11 @@ static Function* gen_cfun_wrapper(
     ctx.builder.ClearInsertionPoint();
 
     if (aliasname) {
-        GlobalAlias::create(cw->getValueType(), cw->getType()->getAddressSpace(),
+         auto alias = GlobalAlias::create(cw->getValueType(), cw->getType()->getAddressSpace(),
                             GlobalValue::ExternalLinkage, aliasname, cw, M);
+        if(ctx.emission_context.TargetTriple.isOSBinFormatCOFF()) {
+            alias->setDLLStorageClass(GlobalValue::DLLStorageClassTypes::DLLExportStorageClass);
+        }
     }
 
     if (nest) {

diff --git a/src/gf.c b/src/gf.c
@@ -112,7 +112,7 @@ static int8_t jl_cachearg_offset(jl_methtable_t *mt)
 
 static uint_t speccache_hash(size_t idx, jl_svec_t *data)
 {
-    jl_method_instance_t *ml = (jl_method_instance_t*)jl_svecref(data, idx);
+    jl_method_instance_t *ml = (jl_method_instance_t*)jl_svecref(data, idx); // This must always happen inside the lock
     jl_value_t *sig = ml->specTypes;
     if (jl_is_unionall(sig))
         sig = jl_unwrap_unionall(sig);
@@ -121,6 +121,8 @@ static uint_t speccache_hash(size_t idx, jl_svec_t *data)
 
 static int speccache_eq(size_t idx, const void *ty, jl_svec_t *data, uint_t hv)
 {
+    if (idx >= jl_svec_len(data))
+        return 0; // We got a OOB access, probably due to a data race
     jl_method_instance_t *ml = (jl_method_instance_t*)jl_svecref(data, idx);
     jl_value_t *sig = ml->specTypes;
     if (ty == sig)

diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
@@ -558,6 +558,7 @@
     YY(jl_dump_llvm_opt) \
     YY(jl_dump_fptr_asm) \
     YY(jl_get_function_id) \
+    YY(jl_struct_to_llvm) \
     YY(jl_type_to_llvm) \
     YY(jl_getUnwindInfo) \
     YY(jl_get_libllvm) \

diff --git a/src/llvm-multiversioning.cpp b/src/llvm-multiversioning.cpp
@@ -674,6 +674,7 @@ void CloneCtx::rewrite_alias(GlobalAlias *alias, Function *F)
     trampoline->removeFnAttr("julia.mv.reloc");
     trampoline->removeFnAttr("julia.mv.clones");
     trampoline->addFnAttr("julia.mv.alias");
+    trampoline->setDLLStorageClass(alias->getDLLStorageClass());
     alias->eraseFromParent();
 
     uint32_t id;