From ef96e02a11f399b68a9e732a26a243f0d9cff347 Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Thu, 17 Jun 2021 22:33:07 -0700
Subject: [PATCH 01/44] [buildkite] Implement secrets encryption and sandboxing
 (#41256)

This adds a proof-of-concept demonstration of two new buildkite plugins:

* `cryptic` adds secrets management to privileged pipelines.  These
pipelines cannot be freely modified; their integrity is verified against
a signature maintained by committers with a secret key.  This allows
certain portions of the CI configuration (which are privileged and can
decrypt encrypted files/environment variables) to remain public, but
read-only to the general populace.

*  `sandbox` adds a generic sandboxing mechanism that allows CI steps to
be run within user-provided rootfs images.  We're using these here to
provide compiler toolchains for the `llvm-passes` CI steps, and the plan
is to eventually provide _all_ compiler toolchains through such rootfs
images.

(cherry picked from commit 61ae86da895ff0be8a2cd051277a05ad48f91b4a)
---
 .buildkite/0_webui.yml                        |  24 ++++
 .buildkite/cryptic_repo_keys/README.md        |   6 +
 .../cryptic_repo_keys/repo_key.2297e5e7       | Bin 0 -> 256 bytes
 .buildkite/llvm_passes.yml                    |  40 ++++++
 .buildkite/pipeline.yml                       |  43 +++---
 .buildkite/rootfs_images/Manifest.toml        | 134 ++++++++++++++++++
 .buildkite/rootfs_images/Project.toml         |   5 +
 .buildkite/rootfs_images/README.md            |   5 +
 .buildkite/rootfs_images/llvm-passes.jl       |  27 ++++
 .buildkite/rootfs_images/rootfs_utils.jl      |  92 ++++++++++++
 .buildkite/signed_pipeline_test.yml           |  17 +++
 11 files changed, 367 insertions(+), 26 deletions(-)
 create mode 100644 .buildkite/0_webui.yml
 create mode 100644 .buildkite/cryptic_repo_keys/README.md
 create mode 100644 .buildkite/cryptic_repo_keys/repo_key.2297e5e7
 create mode 100644 .buildkite/llvm_passes.yml
 create mode 100644 .buildkite/rootfs_images/Manifest.toml
 create mode 100644 .buildkite/rootfs_images/Project.toml
 create mode 100644 .buildkite/rootfs_images/README.md
 create mode 100755 .buildkite/rootfs_images/llvm-passes.jl
 create mode 100644 .buildkite/rootfs_images/rootfs_utils.jl
 create mode 100644 .buildkite/signed_pipeline_test.yml

diff --git a/.buildkite/0_webui.yml b/.buildkite/0_webui.yml
new file mode 100644
index 0000000000000..d5ba4e0ea7cf9
--- /dev/null
+++ b/.buildkite/0_webui.yml
@@ -0,0 +1,24 @@
+# This file represents what is put into the webUI.
+# It is purely for keeping track of the changes we make to the webUI configuration; modifying this file has no effect.
+# We use the `cryptic` buildkite plugin to provide secrets management, which requires some integration into the WebUI's steps.
+agents:
+  queue: "julia"
+  sandbox.jl: "true"
+
+steps:
+  - label: ":unlock: Unlock secrets, launch pipelines"
+    plugins:
+      - staticfloat/cryptic:
+          # Our list of pipelines that should be launched (but don't require a signature)
+          # These pipelines can be modified by any contributor and CI will still run.
+          # Build secrets will not be available in these pipelines (or their children)
+          # but some of our signed pipelines can wait upon the completion of these unsigned
+          # pipelines.
+          unsigned_pipelines:
+            - .buildkite/pipeline.yml
+
+          # Our signed pipelines must have a `signature` or `signature_file` parameter that
+          # verifies the treehash of the pipeline itself and the inputs listed in `inputs`
+          signed_pipelines:
+            - pipeline: .buildkite/signed_pipeline_test.yml
+              signature: "U2FsdGVkX18aZgryp6AJTArgD2uOnVWyFFGVOP5qsY4WbGQ/LVAcYiMEp9cweV+2iht+vmEF949CuuGTeQPA1fKlhPwkG3nZ688752DUB6en9oM2nuL31NoDKWHhpygZ"
diff --git a/.buildkite/cryptic_repo_keys/README.md b/.buildkite/cryptic_repo_keys/README.md
new file mode 100644
index 0000000000000..93ed17ce4757b
--- /dev/null
+++ b/.buildkite/cryptic_repo_keys/README.md
@@ -0,0 +1,6 @@
+## Cryptic repository keys
+
+This folder contains RSA-encrypted symmetric AES keys.
+These are used by buildkite agents to decrypt the secrets embedded within this repository.
+Each buildkite agent contains an RSA secret key that is used to unlock the symmetric AES key that was used to encrypt the secrets within this repository.
+For more information, see the [`cryptic` buildkite plugin repository](https://github.com/staticfloat/cryptic-buildkite-plugin).
diff --git a/.buildkite/cryptic_repo_keys/repo_key.2297e5e7 b/.buildkite/cryptic_repo_keys/repo_key.2297e5e7
new file mode 100644
index 0000000000000000000000000000000000000000..2ab9198b4ce2d7c7a9327935e18aaef5943629d2
GIT binary patch
literal 256
zcmV+b0ssE4{g>pIb#Eq&=vC$Qr^8S_O6!cOYE`=}q%}#an@eaJd$RWGY{B`_JI5h4
zkH`Ok?yS%>4AD6gqiiL&E|`(uBGp1*D8z1}bTOSJGyXKmUCrMUN%Q;gJ{M_gVt6DF
z#aRD2;iY!|^9jgEcBXhT=jxw2yplIkGkb~?zh)kpuL|wT!R7{E{^jQhsqTt2Woi5X
z6&zlfSSPoyKVU`TIJAL8I6(F*9}>v<(M$c2U_*AHb;CSzxbLIaZK0;0gYIZ?hzwB#
zq^tZ&SA{ud8h!8dRd!Rzp7pWdE3F(RM#CkMHZoXOfk*SkHmzrDCiOUb@l`xQjdi^f
GB)!2VDuP}B

literal 0
HcmV?d00001

diff --git a/.buildkite/llvm_passes.yml b/.buildkite/llvm_passes.yml
new file mode 100644
index 0000000000000..862f748c18499
--- /dev/null
+++ b/.buildkite/llvm_passes.yml
@@ -0,0 +1,40 @@
+# These steps should only run on `sandbox.jl` machines, not `docker`-isolated ones
+# since we need nestable sandboxing.  The rootfs images being used here are built from
+# the `.buildkite/rootfs_images/llvm-passes.jl` file.
+agents:
+  queue: "julia"
+  # Only run on `sandbox.jl` machines (not `docker`-isolated ones) since we need nestable sandboxing
+  sandbox.jl: "true"
+  os: "linux"
+
+steps:
+  - label: "analyzegc"
+    plugins:
+      - JuliaCI/julia#v1:
+          version: 1.6
+      - staticfloat/sandbox#v1:
+          rootfs_url: https://github.com/JuliaCI/rootfs-images/releases/download/v1/llvm-passes.tar.gz
+          rootfs_treehash: "f3ed53f159e8f13edfba8b20ebdb8ece73c1b8a8"
+    commands: |
+      echo "--- Install in-tree LLVM dependencies"
+      make -j 6 -C deps install-llvm install-clang install-llvm-tools install-libuv install-utf8proc install-unwind
+      echo "+++ run clangsa/analyzegc"
+      make -j 6 -C test/clangsa
+      make -j 6 -C src analyzegc
+    timeout_in_minutes: 60
+
+  - label: "llvmpasses"
+    plugins:
+      - JuliaCI/julia#v1:
+          version: 1.6
+      - staticfloat/sandbox#v1:
+          rootfs_url: https://github.com/JuliaCI/rootfs-images/releases/download/v1/llvm-passes.tar.gz
+          rootfs_treehash: "f3ed53f159e8f13edfba8b20ebdb8ece73c1b8a8"
+          uid: 1000
+          gid: 1000
+    commands: |
+      echo "+++ run llvmpasses"
+      make -j 6 release
+      make -j 6 -C src install-analysis-deps
+      make -j 6 -C test/llvmpasses
+    timeout_in_minutes: 60
diff --git a/.buildkite/pipeline.yml b/.buildkite/pipeline.yml
index e63431649f897..d76f3fd77bd4f 100644
--- a/.buildkite/pipeline.yml
+++ b/.buildkite/pipeline.yml
@@ -1,28 +1,19 @@
+# This file launches all the build jobs that _don't_ require secrets access.
+# These jobs can pass their output off to jobs that do require secrets access,
+# but those privileged steps require signing before they can be run.
+#
+# Yes, this is creating another layer of indirection; the flow now looks like:
+#
+#   [webui] -> pipeline.yml -> llvm_passes.yml
+#
+# when we could theoretically just have the `webui` launch `llvm_passes.yml`,
+# however this raises the bar for contributors to add new (unsigned) steps to
+# our CI configuration, so I'd rather live with an extra layer of indirection
+# and only need to touch the webui configuration when we need to alter
+# something about the privileged steps.
 steps:
-  - label: "analyzegc"
-    commands:
-      - echo "--- Install apt-get pre-reqs"
-      - apt-get update
-      - apt-get install -y build-essential libatomic1 python python3 gfortran perl wget m4 cmake pkg-config curl
-      - echo "--- Install in-tree LLVM dependencies"
-      - make -j 6 -C deps install-llvm install-clang install-llvm-tools install-libuv install-utf8proc install-unwind
-      - echo "+++ run clangsa/analyzegc"
-      - make -j 6 -C test/clangsa
-      - make -j 6 -C src analyzegc
+  - label: ":buildkite: Launch unsigned pipelines"
+    commands: |
+      buildkite-agent pipeline upload .buildkite/llvm_passes.yml
     agents:
-      queue: "juliacpu" # this should be julia -- also in pipeline settings
-      # os: linux # tag missing for juliacpu queue
-    timeout_in_minutes: 60
-  - label: "llvmpasses"
-    commands:
-      - echo "--- Install apt-get pre-reqs"
-      - apt-get update
-      - apt-get install -y build-essential libatomic1 python python3 gfortran perl wget m4 cmake pkg-config curl
-      - echo "+++ run llvmpasses"
-      - make -j 6 release
-      - make -j 6 -C src install-analysis-deps
-      - make -j 6 -C test/llvmpasses
-    agents:
-      queue: "juliacpu" # this should be julia -- also in pipeline settings
-      # os: linux # tag missing for juliacpu queue
-    timeout_in_minutes: 60
+      queue: julia
diff --git a/.buildkite/rootfs_images/Manifest.toml b/.buildkite/rootfs_images/Manifest.toml
new file mode 100644
index 0000000000000..d24e9a4ee166e
--- /dev/null
+++ b/.buildkite/rootfs_images/Manifest.toml
@@ -0,0 +1,134 @@
+# This file is machine-generated - editing it directly is not advised
+
+[[ArgTools]]
+uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"
+
+[[Artifacts]]
+uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
+
+[[Base64]]
+uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+
+[[Dates]]
+deps = ["Printf"]
+uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
+
+[[Downloads]]
+deps = ["ArgTools", "LibCURL", "NetworkOptions"]
+uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
+
+[[InteractiveUtils]]
+deps = ["Markdown"]
+uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+
+[[JLLWrappers]]
+deps = ["Preferences"]
+git-tree-sha1 = "642a199af8b68253517b80bd3bfd17eb4e84df6e"
+uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
+version = "1.3.0"
+
+[[LibCURL]]
+deps = ["LibCURL_jll", "MozillaCACerts_jll"]
+uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"
+
+[[LibCURL_jll]]
+deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
+uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"
+
+[[LibGit2]]
+deps = ["Base64", "NetworkOptions", "Printf", "SHA"]
+uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
+
+[[LibSSH2_jll]]
+deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
+uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"
+
+[[Libdl]]
+uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+
+[[Logging]]
+uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
+
+[[Markdown]]
+deps = ["Base64"]
+uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
+
+[[MbedTLS_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"
+
+[[MozillaCACerts_jll]]
+uuid = "14a3606d-f60d-562e-9121-12d972cd8159"
+
+[[NetworkOptions]]
+uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"
+
+[[Pkg]]
+deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
+uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+
+[[Preferences]]
+deps = ["TOML"]
+git-tree-sha1 = "00cfd92944ca9c760982747e9a1d0d5d86ab1e5a"
+uuid = "21216c6a-2e73-6563-6e65-726566657250"
+version = "1.2.2"
+
+[[Printf]]
+deps = ["Unicode"]
+uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+
+[[REPL]]
+deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
+uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+
+[[Random]]
+deps = ["Serialization"]
+uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+
+[[SHA]]
+uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"
+
+[[Scratch]]
+deps = ["Dates"]
+git-tree-sha1 = "0b4b7f1393cff97c33891da2a0bf69c6ed241fda"
+uuid = "6c6a2e73-6563-6170-7368-637461726353"
+version = "1.1.0"
+
+[[Serialization]]
+uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+
+[[Sockets]]
+uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
+
+[[TOML]]
+deps = ["Dates"]
+uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
+
+[[Tar]]
+deps = ["ArgTools", "SHA"]
+uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"
+
+[[UUIDs]]
+deps = ["Random", "SHA"]
+uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+
+[[Unicode]]
+uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
+
+[[Zlib_jll]]
+deps = ["Libdl"]
+uuid = "83775a58-1f1d-513f-b197-d71354ab007a"
+
+[[ghr_jll]]
+deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
+git-tree-sha1 = "f5c8cb306d4fe2d1fff90443a088fc5ba536c134"
+uuid = "07c12ed4-43bc-5495-8a2a-d5838ef8d533"
+version = "0.13.0+1"
+
+[[nghttp2_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
+
+[[p7zip_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"
diff --git a/.buildkite/rootfs_images/Project.toml b/.buildkite/rootfs_images/Project.toml
new file mode 100644
index 0000000000000..1dbde5ed9df66
--- /dev/null
+++ b/.buildkite/rootfs_images/Project.toml
@@ -0,0 +1,5 @@
+[deps]
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce"
+Scratch = "6c6a2e73-6563-6170-7368-637461726353"
+ghr_jll = "07c12ed4-43bc-5495-8a2a-d5838ef8d533"
diff --git a/.buildkite/rootfs_images/README.md b/.buildkite/rootfs_images/README.md
new file mode 100644
index 0000000000000..1d3962c2bee3e
--- /dev/null
+++ b/.buildkite/rootfs_images/README.md
@@ -0,0 +1,5 @@
+## Rootfs images
+
+Our CI setup makes use of rootfs images that contain our build tools.
+These rootfs images are built using the fairly simple scripts held within this directory.
+Most images are based on Debian, making use of `debootstrap` to provide a quick and easy rootfs with packages installed through an initial `apt` invocation.
diff --git a/.buildkite/rootfs_images/llvm-passes.jl b/.buildkite/rootfs_images/llvm-passes.jl
new file mode 100755
index 0000000000000..17c9588f75c9e
--- /dev/null
+++ b/.buildkite/rootfs_images/llvm-passes.jl
@@ -0,0 +1,27 @@
+#!/usr/bin/env julia
+
+## This rootfs includes enough of a host toolchain to build the LLVM passes.
+## Eventually, this image will probably be replaced with the actual builder image,
+## as that will have the necessary toolchains as well, but that image is not built yet.
+
+include("rootfs_utils.jl")
+
+# Build debian-based image with the following extra packages:
+packages = [
+    "build-essential",
+    "libatomic1",
+    "python",
+    "python3",
+    "gfortran",
+    "perl",
+    "wget",
+    "m4",
+    "cmake",
+    "pkg-config",
+    "curl",
+    "git",
+]
+tarball_path = debootstrap("llvm-passes"; packages)
+
+# Upload it
+upload_rootfs_image(tarball_path)
diff --git a/.buildkite/rootfs_images/rootfs_utils.jl b/.buildkite/rootfs_images/rootfs_utils.jl
new file mode 100644
index 0000000000000..7df224a31f740
--- /dev/null
+++ b/.buildkite/rootfs_images/rootfs_utils.jl
@@ -0,0 +1,92 @@
+#!/usr/bin/env julia
+
+# This is an example invocation of `debootstrap` to generate a Debian/Ubuntu-based rootfs
+using Scratch, Pkg, Pkg.Artifacts, ghr_jll, SHA, Dates
+
+# Utility functions
+getuid() = ccall(:getuid, Cint, ())
+getgid() = ccall(:getgid, Cint, ())
+
+function debootstrap(name::String; release::String="buster", variant::String="minbase",
+                     packages::Vector{String}=String[], force::Bool=false)
+    if Sys.which("debootstrap") === nothing
+        error("Must install `debootstrap`!")
+    end
+
+    tarball_path = joinpath(@get_scratch!("rootfs-images"), "$(name).tar.gz")
+    if !force && isfile(tarball_path)
+        @error("Refusing to overwrite tarball without `force` set", tarball_path)
+        error()
+    end
+
+    artifact_hash = create_artifact() do rootfs
+        packages_string = join(push!(packages, "locales"), ",")
+        @info("Running debootstrap", release, variant, packages)
+        run(`sudo debootstrap --variant=$(variant) --include=$(packages_string) $(release) "$(rootfs)"`)
+
+        # Remove special `dev` files
+        @info("Cleaning up `/dev`")
+        for f in readdir(joinpath(rootfs, "dev"); join=true)
+            # Keep the symlinks around (such as `/dev/fd`), as they're useful
+            if !islink(f)
+                run(`sudo rm -rf "$(f)"`)
+            end
+        end
+
+        # take ownership of the entire rootfs
+        @info("Chown'ing rootfs")
+        run(`sudo chown $(getuid()):$(getgid()) -R "$(rootfs)"`)
+
+        # Write out rootfs-info to contain a minimally-identifying string
+        open(joinpath(rootfs, "etc", "rootfs-info"), write=true) do io
+            write(io, """
+            rootfs_type=debootstrap
+            release=$(release)
+            variant=$(variant)
+            packages=$(packages_string)
+            build_date=$(Dates.now())
+            """)
+        end
+
+        # Write out a reasonable default resolv.conf
+        open(joinpath(rootfs, "etc", "resolv.conf"), write=true) do io
+            write(io, """
+            nameserver 1.1.1.1
+            nameserver 8.8.8.8
+            """)
+        end
+
+        # Remove `_apt` user so that `apt` doesn't try to `setgroups()`
+        @info("Removing `_apt` user")
+        open(joinpath(rootfs, "etc", "passwd"), write=true, read=true) do io
+            filtered_lines = filter(l -> !startswith(l, "_apt:"), readlines(io))
+            truncate(io, 0)
+            seek(io, 0)
+            for l in filtered_lines
+                println(io, l)
+            end
+        end
+
+        # Set up the one true locale
+        @info("Setting up UTF-8 locale")
+        open(joinpath(rootfs, "etc", "locale.gen"), "a") do io
+            println(io, "en_US.UTF-8 UTF-8")
+        end
+        run(`sudo chroot --userspec=$(getuid()):$(getgid()) $(rootfs) locale-gen`)
+    end
+
+    # Archive it into a `.tar.gz` file
+    @info("Archiving", tarball_path, artifact_hash)
+    archive_artifact(artifact_hash, tarball_path)
+
+    return tarball_path
+end
+
+function upload_rootfs_image(tarball_path::String; github_repo::String="JuliaCI/rootfs-images")
+    # Upload it to `github_repo`
+    tag_name = "v1"
+    tarball_url = "https://github.com/$(github_repo)/releases/download/$(tag_name)/$(basename(tarball_path))"
+    @info("Uploading to $(github_repo)@$(tag_name)", tarball_url)
+    run(`$(ghr_jll.ghr()) -u $(dirname(github_repo)) -r $(basename(github_repo)) -replace $(tag_name) $(tarball_path)`)
+    return tarball_url
+end
diff --git a/.buildkite/signed_pipeline_test.yml b/.buildkite/signed_pipeline_test.yml
new file mode 100644
index 0000000000000..fb13ac15a8d65
--- /dev/null
+++ b/.buildkite/signed_pipeline_test.yml
@@ -0,0 +1,17 @@
+agents:
+  queue: "julia"
+  os: "linux"
+
+## pipeline that showcases decryption of environment variable
+steps:
+  - label: ":lock: :rocket: Signed pipeline test"
+    plugins:
+      - staticfloat/cryptic#v1:
+          variables:
+            - SECRET_KEY="U2FsdGVkX18tb7st0SuQAvh4Yv4xENxOAu8q9XkmOeDVKBNY4FngEwK3xmiKUqaS"
+    commands: |
+      echo "SECRET_KEY: $${SECRET_KEY}"
+
+# We must accept the signed job id secret in order to propagate secrets
+env:
+  BUILDKITE_PLUGIN_CRYPTIC_BASE64_SIGNED_JOB_ID_SECRET: ${BUILDKITE_PLUGIN_CRYPTIC_BASE64_SIGNED_JOB_ID_SECRET?}

From 226514a0612b80d5d39f9ce84b880e29aab84de2 Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Fri, 18 Jun 2021 10:10:06 +0200
Subject: [PATCH 02/44] make `statement_costs!` accept IRCode (#41257)

I want to use this in Cthulhu, which uses `IRCode` for optimized code
instead of `CodeInfo`.

(cherry picked from commit 083272b933c783c1d039ee800572c5d153416c38)
---
 base/compiler/optimize.jl | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 353a9ab5b3391..2d4f0d022fd6d 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -565,12 +565,14 @@ function inline_worthy(ir::IRCode,
     return true
 end
 
-function statement_costs!(cost::Vector{Int}, body::Vector{Any}, src::CodeInfo, sptypes::Vector{Any}, unionpenalties::Bool, params::OptimizationParams)
+function statement_costs!(cost::Vector{Int}, body::Vector{Any}, src::Union{CodeInfo, IRCode}, sptypes::Vector{Any}, unionpenalties::Bool, params::OptimizationParams)
     throw_blocks = params.unoptimize_throw_blocks ? find_throw_blocks(body) : nothing
     maxcost = 0
     for line = 1:length(body)
         stmt = body[line]
-        thiscost = statement_or_branch_cost(stmt, line, src, sptypes, src.slottypes, unionpenalties, params, throw_blocks)
+        thiscost = statement_or_branch_cost(stmt, line, src, sptypes,
+                                            src isa CodeInfo ? src.slottypes : src.argtypes,
+                                            unionpenalties, params, throw_blocks)
         cost[line] = thiscost
         if thiscost > maxcost
             maxcost = thiscost

From 277162752103b59c72905ad5b3b413b6f4578380 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 18 Jun 2021 11:31:36 -0400
Subject: [PATCH 03/44] fix emit_f_is to be safepoint-free, like jl_egal
 (#41255)

(cherry picked from commit 8739df2c03187b0faf503acc29b2bf6fdda19913)
---
 src/builtins.c                |  6 +++
 src/cgutils.cpp               | 16 +++---
 src/codegen.cpp               | 96 ++++++++++++++++++++++-------------
 src/julia.h                   | 18 ++++---
 src/llvm-late-gc-lowering.cpp |  2 +-
 5 files changed, 90 insertions(+), 48 deletions(-)

diff --git a/src/builtins.c b/src/builtins.c
index 1c4a257a13137..b5b4bb4069773 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -198,6 +198,12 @@ JL_DLLEXPORT int (jl_egal)(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value
     return jl_egal(a, b);
 }
 
+JL_DLLEXPORT int jl_egal__unboxed(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t *b JL_MAYBE_UNROOTED, jl_datatype_t *dt) JL_NOTSAFEPOINT
+{
+    // warning: a,b may NOT have been gc-rooted by the caller
+    return jl_egal__unboxed_(a, b, dt);
+}
+
 int jl_egal__special(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t *b JL_MAYBE_UNROOTED, jl_datatype_t *dt) JL_NOTSAFEPOINT
 {
     if (dt == jl_simplevector_type)
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index bb9b3d63f91fb..c5e25466110d0 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -1120,6 +1120,15 @@ static bool can_optimize_isa_union(jl_uniontype_t *type)
     return (_can_optimize_isa(type->a, counter) && _can_optimize_isa(type->b, counter));
 }
 
+// a simple case of emit_isa that is obvious not to include a safe-point
+static Value *emit_exactly_isa(jl_codectx_t &ctx, const jl_cgval_t &arg, jl_value_t *dt)
+{
+    assert(jl_is_concrete_type(dt));
+    return ctx.builder.CreateICmpEQ(
+            emit_typeof_boxed(ctx, arg),
+            track_pjlvalue(ctx, literal_pointer_val(ctx, dt)));
+}
+
 static std::pair<Value*, bool> emit_isa(jl_codectx_t &ctx, const jl_cgval_t &x,
                                         jl_value_t *type, const std::string *msg);
 
@@ -1217,12 +1226,7 @@ static std::pair<Value*, bool> emit_isa(jl_codectx_t &ctx, const jl_cgval_t &x,
                 return std::make_pair(ConstantInt::get(T_int1, 0), false);
             }
         }
-        if (auto val = ((jl_datatype_t*)intersected_type)->instance) {
-            auto ptr = track_pjlvalue(ctx, literal_pointer_val(ctx, val));
-            return {ctx.builder.CreateICmpEQ(boxed(ctx, x), ptr), false};
-        }
-        return std::make_pair(ctx.builder.CreateICmpEQ(emit_typeof_boxed(ctx, x),
-            track_pjlvalue(ctx, literal_pointer_val(ctx, intersected_type))), false);
+        return std::make_pair(emit_exactly_isa(ctx, x, intersected_type), false);
     }
     jl_datatype_t *dt = (jl_datatype_t*)jl_unwrap_unionall(intersected_type);
     if (jl_is_datatype(dt) && !dt->name->abstract && jl_subtype(dt->name->wrapper, type)) {
diff --git a/src/codegen.cpp b/src/codegen.cpp
index f7ac3e45271d8..cba7d1d2d3080 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -628,11 +628,11 @@ static const auto jl_excstack_state_func = new JuliaFunction{
     [](LLVMContext &C) { return FunctionType::get(T_size, false); },
     nullptr,
 };
-static const auto jlegal_func = new JuliaFunction{
-    "jl_egal",
+static const auto jlegalx_func = new JuliaFunction{
+    "jl_egal__unboxed",
     [](LLVMContext &C) {
-        Type *T = PointerType::get(T_jlvalue, AddressSpace::CalleeRooted);
-        return FunctionType::get(T_int32, {T, T}, false); },
+        Type *T = PointerType::get(T_jlvalue, AddressSpace::Derived);
+        return FunctionType::get(T_int32, {T, T, T_prjlvalue}, false); },
     [](LLVMContext &C) { return AttributeList::get(C,
             Attributes(C, {Attribute::ReadOnly, Attribute::NoUnwind, Attribute::ArgMemOnly}),
             AttributeSet(),
@@ -2411,10 +2411,10 @@ static Value *emit_box_compare(jl_codectx_t &ctx, const jl_cgval_t &arg1, const
                                Value *nullcheck1, Value *nullcheck2)
 {
     if (jl_pointer_egal(arg1.typ) || jl_pointer_egal(arg2.typ)) {
+        assert((arg1.isboxed || arg1.constant) && (arg2.isboxed || arg2.constant) &&
+                "Expected unboxed cases to be handled earlier");
         Value *varg1 = arg1.constant ? literal_pointer_val(ctx, arg1.constant) : arg1.V;
         Value *varg2 = arg2.constant ? literal_pointer_val(ctx, arg2.constant) : arg2.V;
-        assert(varg1 && varg2 && (arg1.isboxed || arg1.TIndex) && (arg2.isboxed || arg2.TIndex) &&
-                "Only boxed types are valid for pointer comparison.");
         varg1 = maybe_decay_tracked(ctx, varg1);
         varg2 = maybe_decay_tracked(ctx, varg2);
         if (cast<PointerType>(varg1->getType())->getAddressSpace() != cast<PointerType>(varg2->getType())->getAddressSpace()) {
@@ -2426,10 +2426,19 @@ static Value *emit_box_compare(jl_codectx_t &ctx, const jl_cgval_t &arg1, const
     }
 
     return emit_nullcheck_guard2(ctx, nullcheck1, nullcheck2, [&] {
-        Value *varg1 = mark_callee_rooted(ctx, boxed(ctx, arg1));
-        Value *varg2 = mark_callee_rooted(ctx, boxed(ctx, arg2));
-        return ctx.builder.CreateTrunc(ctx.builder.CreateCall(prepare_call(jlegal_func),
-                                                              {varg1, varg2}), T_int1);
+        Value *varg1 = arg1.constant ? literal_pointer_val(ctx, arg1.constant) : maybe_bitcast(ctx, value_to_pointer(ctx, arg1).V, T_pjlvalue);
+        Value *varg2 = arg2.constant ? literal_pointer_val(ctx, arg2.constant) : maybe_bitcast(ctx, value_to_pointer(ctx, arg2).V, T_pjlvalue);
+        varg1 = decay_derived(ctx, varg1);
+        varg2 = decay_derived(ctx, varg2);
+        Value *neq = ctx.builder.CreateICmpNE(varg1, varg2);
+        return emit_guarded_test(ctx, neq, true, [&] {
+            Value *dtarg = emit_typeof_boxed(ctx, arg1);
+            Value *dt_eq = ctx.builder.CreateICmpEQ(dtarg, emit_typeof_boxed(ctx, arg2));
+            return emit_guarded_test(ctx, dt_eq, false, [&] {
+                return ctx.builder.CreateTrunc(ctx.builder.CreateCall(prepare_call(jlegalx_func),
+                                                                      {varg1, varg2, dtarg}), T_int1);
+            });
+        });
     });
 }
 
@@ -2583,6 +2592,7 @@ static Value *emit_bits_compare(jl_codectx_t &ctx, jl_cgval_t arg1, jl_cgval_t a
 // representing the undef-ness of `arg1` and `arg2`.
 // This can only happen when comparing two fields of the same time and the result should be
 // true if both are NULL
+// Like the runtime counterpart, this is codegen guaranteed to be non-allocating and to exclude safepoints
 static Value *emit_f_is(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgval_t &arg2,
                         Value *nullcheck1, Value *nullcheck2)
 {
@@ -2603,46 +2613,45 @@ static Value *emit_f_is(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgva
         // since it is normalized to `::Type{Union{}}` instead...
         if (arg1.TIndex)
             return emit_nullcheck_guard(ctx, nullcheck1, [&] {
-                return emit_isa(ctx, arg1, rt2, NULL).first; // rt2 is a singleton type
+                return emit_exactly_isa(ctx, arg1, rt2); // rt2 is a singleton type
             });
         if (arg2.TIndex)
             return emit_nullcheck_guard(ctx, nullcheck2, [&] {
-                return emit_isa(ctx, arg2, rt1, NULL).first; // rt1 is a singleton type
+                return emit_exactly_isa(ctx, arg2, rt1); // rt1 is a singleton type
             });
+        if (!(arg1.isboxed || arg1.constant) || !(arg2.isboxed || arg2.constant))
+            // not TIndex && not boxed implies it is an unboxed value of a different type from this singleton
+            // (which was probably caught above, but just to be safe, we repeat it here explicitly)
+            return ConstantInt::get(T_int1, 0);
+        Value *varg1 = arg1.constant ? literal_pointer_val(ctx, arg1.constant) : maybe_bitcast(ctx, arg1.Vboxed, T_pjlvalue);
+        Value *varg2 = arg2.constant ? literal_pointer_val(ctx, arg2.constant) : maybe_bitcast(ctx, arg2.Vboxed, T_pjlvalue);
         // rooting these values isn't needed since we won't load this pointer
         // and we know at least one of them is a unique Singleton
         // which is already enough to ensure pointer uniqueness for this test
         // even if the other pointer managed to get garbage collected
-        return ctx.builder.CreateICmpEQ(
-            mark_callee_rooted(ctx, boxed(ctx, arg1)),
-            mark_callee_rooted(ctx, boxed(ctx, arg2)));
+        // TODO: use emit_pointer_from_objref instead, per comment above
+        return ctx.builder.CreateICmpEQ(decay_derived(ctx, varg1), decay_derived(ctx, varg2));
     }
 
     if (jl_type_intersection(rt1, rt2) == (jl_value_t*)jl_bottom_type) // types are disjoint (exhaustive test)
         return ConstantInt::get(T_int1, 0);
 
-    // If both sides are boxed or can be trivially boxed,
-    // we'll prefer to do a pointer check.
-    // At this point, we know that at least one of the arguments isn't a constant
-    // so a runtime content check will involve at least one load from the
-    // pointer (and likely a type check)
-    // so a pointer comparison should be no worse than that even in imaging mode
-    // when the constant pointer has to be loaded.
-    if ((arg1.V || arg1.constant) && (arg2.V || arg2.constant) &&
-        (jl_pointer_egal(rt1) || jl_pointer_egal(rt2)) &&
-        // jl_pointer_egal returns true for Bool, which is not helpful here
-        (rt1 != (jl_value_t*)jl_bool_type || rt2 != (jl_value_t*)jl_bool_type))
-        return ctx.builder.CreateICmpEQ(boxed(ctx, arg1), boxed(ctx, arg2));
-
     bool justbits1 = jl_is_concrete_immutable(rt1);
     bool justbits2 = jl_is_concrete_immutable(rt2);
     if (justbits1 || justbits2) { // whether this type is unique'd by value
         return emit_nullcheck_guard2(ctx, nullcheck1, nullcheck2, [&] () -> Value* {
             jl_value_t *typ = justbits1 ? rt1 : rt2;
+            if (typ == (jl_value_t*)jl_bool_type) { // aka jl_pointer_egal
+                // some optimizations for bool, since pointer comparison may be better
+                if ((arg1.isboxed || arg1.constant) && (arg2.isboxed || arg2.constant)) { // aka have-fast-pointer
+                    Value *varg1 = arg1.constant ? literal_pointer_val(ctx, arg1.constant) : maybe_bitcast(ctx, arg1.Vboxed, T_pjlvalue);
+                    Value *varg2 = arg2.constant ? literal_pointer_val(ctx, arg2.constant) : maybe_bitcast(ctx, arg2.Vboxed, T_pjlvalue);
+                    return ctx.builder.CreateICmpEQ(decay_derived(ctx, varg1), decay_derived(ctx, varg2));
+                }
+            }
             if (rt1 == rt2)
                 return emit_bits_compare(ctx, arg1, arg2);
-            Value *same_type = (typ == rt2) ? emit_isa(ctx, arg1, typ, NULL).first :
-                emit_isa(ctx, arg2, typ, NULL).first;
+            Value *same_type = emit_exactly_isa(ctx, (typ == rt2 ? arg1 : arg2), typ);
             BasicBlock *currBB = ctx.builder.GetInsertBlock();
             BasicBlock *isaBB = BasicBlock::Create(jl_LLVMContext, "is", ctx.f);
             BasicBlock *postBB = BasicBlock::Create(jl_LLVMContext, "post_is", ctx.f);
@@ -2660,6 +2669,25 @@ static Value *emit_f_is(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgva
         });
     }
 
+    // If either sides is boxed or can be trivially boxed,
+    // we'll prefer to do a pointer check.
+    // At this point, we know that at least one of the arguments isn't a constant
+    // so a runtime content check will involve at least one load from the
+    // pointer (and likely a type check)
+    // so a pointer comparison should be no worse than that even in imaging mode
+    // when the constant pointer has to be loaded.
+    // Note that we ignore nullcheck, since in the case where it may be set, we
+    // also knew the types of both fields must be the same so there cannot be
+    // any unboxed values on either side.
+    if (jl_pointer_egal(rt1) || jl_pointer_egal(rt2)) {
+        // n.b. Vboxed == isboxed || Tindex
+        if (!(arg1.Vboxed || arg1.constant) || !(arg2.Vboxed || arg2.constant))
+            return ConstantInt::get(T_int1, 0);
+        Value *varg1 = arg1.constant ? literal_pointer_val(ctx, arg1.constant) : maybe_bitcast(ctx, arg1.Vboxed, T_pjlvalue);
+        Value *varg2 = arg2.constant ? literal_pointer_val(ctx, arg2.constant) : maybe_bitcast(ctx, arg2.Vboxed, T_pjlvalue);
+        return ctx.builder.CreateICmpEQ(decay_derived(ctx, varg1), decay_derived(ctx, varg2));
+    }
+
     // TODO: handle the case where arg1.typ != arg2.typ, or when one of these isn't union,
     //       or when the union can be pointer
     if (arg1.TIndex && arg2.TIndex && jl_egal(arg1.typ, arg2.typ) &&
@@ -3498,8 +3526,7 @@ static jl_cgval_t emit_call_specfun_other(jl_codectx_t &ctx, jl_method_instance_
             argvals[idx] = boxed(ctx, arg);
         }
         else if (et->isAggregateType()) {
-            if (!arg.ispointer())
-                arg = value_to_pointer(ctx, arg);
+            arg = value_to_pointer(ctx, arg);
             // can lazy load on demand, no copy needed
             assert(at == PointerType::get(et, AddressSpace::Derived));
             argvals[idx] = decay_derived(ctx, maybe_bitcast(ctx,
@@ -5437,8 +5464,7 @@ static Function* gen_cfun_wrapper(
             }
             else if (T->isAggregateType()) {
                 // aggregate types are passed by pointer
-                if (!inputarg.ispointer())
-                    inputarg = value_to_pointer(ctx, inputarg);
+                inputarg = value_to_pointer(ctx, inputarg);
                 arg = maybe_bitcast(ctx, decay_derived(ctx, data_pointer(ctx, inputarg)),
                     T->getPointerTo());
             }
@@ -7977,7 +8003,7 @@ static void init_jit_functions(void)
     add_named_global(jlleave_func, &jl_pop_handler);
     add_named_global(jl_restore_excstack_func, &jl_restore_excstack);
     add_named_global(jl_excstack_state_func, &jl_excstack_state);
-    add_named_global(jlegal_func, &jl_egal);
+    add_named_global(jlegalx_func, &jl_egal__unboxed);
     add_named_global(jlisa_func, &jl_isa);
     add_named_global(jlsubtype_func, &jl_subtype);
     add_named_global(jltypeassert_func, &jl_typeassert);
diff --git a/src/julia.h b/src/julia.h
index 93bd64bc996bc..faa738913af18 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1320,15 +1320,11 @@ STATIC_INLINE int jl_is_array_zeroinit(jl_array_t *a) JL_NOTSAFEPOINT
 JL_DLLEXPORT int jl_egal(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t *b JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT;
 JL_DLLEXPORT int jl_egal__bits(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t *b JL_MAYBE_UNROOTED, jl_datatype_t *dt) JL_NOTSAFEPOINT;
 JL_DLLEXPORT int jl_egal__special(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t *b JL_MAYBE_UNROOTED, jl_datatype_t *dt) JL_NOTSAFEPOINT;
+JL_DLLEXPORT int jl_egal__unboxed(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t *b JL_MAYBE_UNROOTED, jl_datatype_t *dt) JL_NOTSAFEPOINT;
 JL_DLLEXPORT uintptr_t jl_object_id(jl_value_t *v) JL_NOTSAFEPOINT;
 
-STATIC_INLINE int jl_egal_(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t *b JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT
+STATIC_INLINE int jl_egal__unboxed_(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t *b JL_MAYBE_UNROOTED, jl_datatype_t *dt) JL_NOTSAFEPOINT
 {
-    if (a == b)
-        return 1;
-    jl_datatype_t *dt = (jl_datatype_t*)jl_typeof(a);
-    if (dt != (jl_datatype_t*)jl_typeof(b))
-        return 0;
     if (dt->name->mutabl) {
         if (dt == jl_simplevector_type || dt == jl_string_type || dt == jl_datatype_type)
             return jl_egal__special(a, b, dt);
@@ -1336,6 +1332,16 @@ STATIC_INLINE int jl_egal_(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value
     }
     return jl_egal__bits(a, b, dt);
 }
+
+STATIC_INLINE int jl_egal_(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t *b JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT
+{
+    if (a == b)
+        return 1;
+    jl_datatype_t *dt = (jl_datatype_t*)jl_typeof(a);
+    if (dt != (jl_datatype_t*)jl_typeof(b))
+        return 0;
+    return jl_egal__unboxed_(a, b, dt);
+}
 #define jl_egal(a, b) jl_egal_((a), (b))
 
 // type predicates and basic operations
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index 50015045151bc..ca066319d9c33 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -1514,7 +1514,7 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                     // Known functions emitted in codegen that are not safepoints
                     if (callee == pointer_from_objref_func || callee == gc_preserve_begin_func ||
                         callee == gc_preserve_end_func || callee == typeof_func ||
-                        callee == pgcstack_getter ||
+                        callee == pgcstack_getter || callee->getName() == "jl_egal__unboxed" ||
                         callee->getName() == "jl_lock_value" || callee->getName() == "jl_unlock_value" ||
                         callee == write_barrier_func || callee->getName() == "memcmp") {
                         continue;

From 6dcb5790389bc82dd03c0c858a19b9dfa5575896 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Fri, 18 Jun 2021 14:18:45 -0400
Subject: [PATCH 04/44] fix #41253, parse error in `function (::T{})` (#41259)

(cherry picked from commit dc2befcffc7412768097c2a2a6819724a4745aeb)
---
 src/julia-parser.scm | 7 +++++--
 test/syntax.jl       | 3 +++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index 70912c4272c8c..3a5dfad9293bd 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -1329,7 +1329,8 @@
 (define (valid-1arg-func-sig? sig)
   (or (symbol? sig)
       (and (pair? sig) (eq? (car sig) '|::|)
-           (symbol? (cadr sig)))))
+           (or (symbol? (cadr sig))
+               (length= sig 2)))))
 
 (define (unwrap-where x)
   (if (and (pair? x) (eq? (car x) 'where))
@@ -1469,7 +1470,9 @@
                                    ;; function foo  =>  syntax error
                                    (error (string "expected \"(\" in " word " definition")))
                                (if (not (valid-func-sig? paren sig))
-                                   (error (string "expected \"(\" in " word " definition"))
+                                   (if paren
+                                       (error (string "ambiguous signature in " word " definition. Try adding a comma if this is a 1-argument anonymous function."))
+                                       (error (string "expected \"(\" in " word " definition")))
                                    sig)))
                      (body (parse-block s)))
                 (expect-end s word)
diff --git a/test/syntax.jl b/test/syntax.jl
index 7cee3c0755f65..6e3ec82ca3e81 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -2927,3 +2927,6 @@ b'` == `$("a\\\nb")`
           \\
           ``` == `'\'`
 end
+
+# issue #41253
+@test (function (::Dict{}); end)(Dict()) === nothing

From 7d75619faeb91e6af5bd2235d2a467b6a7629ab2 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 18 Jun 2021 20:04:53 -0400
Subject: [PATCH 05/44] fix handling of MethodTable in precompile files
 (#41277)

This was not an external method table, it is just a normal variable
binding. This was causing the precompile files to be corrupted, since we
use normal variables that look like this one at
https://github.com/JuliaLang/julia/blob/dc2befcffc7412768097c2a2a6819724a4745aeb/base/compiler/utilities.jl#L139-L140

Fixes #41156

(cherry picked from commit e3197af4f34b170a0a1a203c731c711162cd08ca)
---
 src/dump.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/dump.c b/src/dump.c
index fff5e78b45cd6..49fa6efa431cd 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -981,9 +981,15 @@ static void jl_collect_lambdas_from_mod(jl_array_t *s, jl_module_t *m) JL_GC_DIS
                         jl_collect_lambdas_from_mod(s, (jl_module_t*)b->value);
                     }
                 }
-                else if (jl_is_mtable(bv)) {
-                    // a module containing an external method table
-                    jl_collect_methtable_from_mod(s, (jl_methtable_t*)bv);
+                else if (jl_is_mtable(b->value)) {
+                    jl_methtable_t *mt = (jl_methtable_t*)b->value;
+                    if (mt->module == m && mt->name == b->name) {
+                        // this is probably an external method table, so let's assume so
+                        // as there is no way to precisely distinguish them,
+                        // and the rest of this serializer does not bother
+                        // to handle any method tables specially
+                        jl_collect_methtable_from_mod(s, (jl_methtable_t*)bv);
+                    }
                 }
             }
         }

From 751871588ee7f3a0ad19a386516c27b2341e82b3 Mon Sep 17 00:00:00 2001
From: Julian Samaroo <jpsamaroo@jpsamaroo.me>
Date: Sun, 20 Jun 2021 08:25:31 -0500
Subject: [PATCH 06/44] Remove cmp argument from replacefield! docstring
 (#41282)

(cherry picked from commit 153f908f147ad1ccf87fdc20b4f2cdd7b2b30461)
---
 base/docs/basedocs.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 35e19e3742cf4..35cf88e269c51 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -2005,7 +2005,7 @@ optimized to the appropriate hardware instruction, otherwise it'll use a loop.
 modifyfield!
 
 """
-    replacefield!(value, name::Symbol, cmp, expected, desired,
+    replacefield!(value, name::Symbol, expected, desired,
         [success_order::Symbol, [fail_order::Symbol=success_order]) =>
         (old, Bool)
 
@@ -2013,14 +2013,14 @@ These atomically perform the operations to get and conditionally set a field to
 a given value.
 
     y = getfield!(value, name, fail_order)
-    ok = cmp(y, expected)
+    ok = y === expected
     if ok
         setfield!(value, name, desired, success_order)
     end
     return y, ok
 
-If the operation is `===` on a supported type, we'll use the relevant processor
-instructions, otherwise it'll use a loop.
+If supported by the hardware, this may be optimized to the appropriate hardware
+instruction, otherwise it'll use a loop.
 """
 replacefield!
 

From 5957ef3d1a48e3b887bbcf0be5bd4645ac58f079 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Mon, 21 Jun 2021 18:04:58 +0100
Subject: [PATCH 07/44] [CompilerSupportLibraries_jll] Update to v0.5.0
 (#41292)

This includes libraries from GCC 11.

(cherry picked from commit d68e570f19fac4ea3841b97cfb87096f796ec518)
---
 deps/checksums/compilersupportlibraries       | 184 +++++++++---------
 .../CompilerSupportLibraries_jll/Project.toml |   2 +-
 2 files changed, 93 insertions(+), 93 deletions(-)

diff --git a/deps/checksums/compilersupportlibraries b/deps/checksums/compilersupportlibraries
index deacc52a102a3..e351d100cb481 100644
--- a/deps/checksums/compilersupportlibraries
+++ b/deps/checksums/compilersupportlibraries
@@ -1,92 +1,92 @@
-CompilerSupportLibraries.v0.4.3+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/36348c1087386681380589f7fdbd383a
-CompilerSupportLibraries.v0.4.3+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/e3dd3c93a855a85f02190659fdc9f41e96332b74577c67a149f78c35ebc2bb193bb4c156104d4bf24ca278f5b8621e944807a554153721bb5d0f22b8e9069fc1
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/b9d432c6639d30f1c63e9a234c1f10b7
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/f208fb24fb34e82a60fc37ae3acfca6a1cac7201b8b8daf29c3ac98e607d9eb94a51fe92c54fde287359a7398b4646e8df98bf359f7acd1eacf25b1b5ea16456
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/37ccf8848bdee5445d002b889e54bca5
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/0b29ef79bf8b238d9778d72f0e404145536933d9f9185f2cc1e917b3ec7cb8cfaa33ff664837e9e8e6ec28a3612ebd9cb226c0938954594849b4267514b27be3
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/bde8da82e00ed6375716bbcba6b04c3b
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/7d50d91d4b6430154ae037fe54eb8b321e57c4ef1f7740ce0633416d8e39e133d3049a36481fba8ea689fdbf8ee8750c99578f7ef287736476bd39e5b05793e9
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/b58108feab2a1d546fc2c3184233da69
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/4079e9a5548426863bf610a1287f4e0c41fb701af95be66db12a805686cc89b6d3baf9ab203dd6ac7429bff8d1352bcd80dde7adf22bfae20688fd8a17dfe457
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/00ab7379109240a211f492dbae4d31c8
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/d2d5e7165566fcaf38f97fedd78cb7c6df475a01dec262643c79a0d310ebde4b64f670ad92104ae5e7bb8b1004d211c8f7d2bd4df05b87ddd188db62b11325c4
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/ee7881127866d50c9d1fc76ef0ac50be
-CompilerSupportLibraries.v0.4.3+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/8f622cbac6777cf14d98a6cfcea38d42296f9f93b7202eee501c9fcf02f112ca2833dc9c034beb0b79aacc85bef9d57a26ee672716ca50b8353e3d17da298ecb
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/fe4c403eedb9dca880961501834bdc8f
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/de829db62f7e28b425ac04d883db62e45f346e2e115d364a6f9ace29681a73422109bab7239014b51e6174cbd6141902ee65868a5cd2c6836d2db43b07c7ec3f
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/670dbd3088ccb46830d80edd4c64143e
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/43a419548597d2624c68504c405da1104007b80f49189dddef5f2abb0a7cbe404af80172d69d7b8b2dea516fa4bf429a73068de2959266f1bc796868ac926682
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/00a9ea852c32c503e405389cb322827b
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/741c34b253f4c785b1092333d9060aea71b73879bed96da0f964dda1d1367032f133abde335cc7917c2e04c8cae4c3e110a249518d5305d8a4752cdea7d3aada
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/7b4528e842d27c849b6bc0443255f974
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/8dc362faaded886ca1bf7c48f43847cdc4f6685e29b0468809d254ff44121061c49d962a33e37acde9ab00b258636a77213ded1f8570ad2543dfb0097f3a7cc7
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/a8d66ecf146c17a5af2f7a6c4c75dc9c
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/4fc7590050d18a3cff6cad29bdaed3ae1aad72a7bed3e69a14b726309cdd5631ba903998ae042a488c815f9668567cbbb2e779eb44c13fca1aee47f93bbaaad0
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/4405f621357e9bc3178ceb24337385b6
-CompilerSupportLibraries.v0.4.3+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/0c8eeda7d94c551e90cefc6ef5c41fa1d79776abd87f1e739e17b8507ae966c0a6aed10bf466f37c34e29e38fe5bd25d542829e25269adf971c0e8a9d640dfb0
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/2a37fb150af0438cbe768e8c479ff893
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/d0f577f4bfa76c349f188e4573644a82a749f9e5c3293246de0347fda866c9a1610fe9f3383ef54ac1bcee774f2a557aa1c67cbfe76580313cd5f9a231df05fd
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/f7bc21abc374654421385f27d653f3e6
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/fe55de45a99817cbd7a4ac69b87744acd9804d159b9b9144ce24d401742c87b9621a388614da32dac00f6b5e78037cef88d37c2b14308b6c94f951aacb176e94
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/022cb4d36156bf257fc57a50124cdfcd
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/f12af33831b91fff66e5ab2964aa4fe520e3063e148a794d9840ed4f526e6741555350e5d6dffe7857c733d2f405e1db81949d1e24a42425c521b1dd71539ec3
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/b99d07c03c91c9d2186999bc924eb4d3
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/6ded3253561e5fa0c93712a2a86efbc5b1bbdca26f2170876e855400978674910c43dba6dfe992537ce90db66e40b618a7fdc3753abae67940ac46175bbbf9b7
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/c1d701eee76fd974ece928cb3e1a85f2
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/ad338863ddbe47ec579636dc6ce155b47b701b9d47c8f0bca93918af18e8df6da6ddf65a2e2042fb79b335d1df07549addb2e794cf1e8f41d6fb518259a6dcd9
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/0fa43aa26c3f5a717945659ad00ad96a
-CompilerSupportLibraries.v0.4.3+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/387a676e4e79a5f783c3797dab0ab4a9ba3b469b66d008bbe3262751e94316b0f7ae6987db212f763be47e9cb5202b1a6740b3f419818b30c2f1251bf0b305fa
-CompilerSupportLibraries.v0.4.3+0.i686-linux-gnu-libgfortran3.tar.gz/md5/e8360ca87e6f9d7e512d20fd0669ea70
-CompilerSupportLibraries.v0.4.3+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/6441bfbd93ae4edad1cc1e7d8adedeff85bc7749bf68b802f4316117e81938fdec35620264627fca367ff2182b503dd97235f7871dc79e70cdb0b86712d570e8
-CompilerSupportLibraries.v0.4.3+0.i686-linux-gnu-libgfortran4.tar.gz/md5/088a85ce5999f373ead5f43e7bece97a
-CompilerSupportLibraries.v0.4.3+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/c3d75384c93afabb2eff3f84a13df8b7ecf535e8f786c5fcea78ee1902fb052854acbfdf9fda5d558ca19f285883836e6827acdb042a9d50ca65d5d0823e44e5
-CompilerSupportLibraries.v0.4.3+0.i686-linux-gnu-libgfortran5.tar.gz/md5/97ddfc865ec5218c7d2d092f65de71b1
-CompilerSupportLibraries.v0.4.3+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/2328f3fd706078125badd6294159d860b2349203b85d77f2ecae914f3a41a99951021ab1124a40c358ea82352f6778a87f8094b039679356965fc4c8bb48beb4
-CompilerSupportLibraries.v0.4.3+0.i686-linux-musl-libgfortran3.tar.gz/md5/479a7a80865c38795cc4454dacebead6
-CompilerSupportLibraries.v0.4.3+0.i686-linux-musl-libgfortran3.tar.gz/sha512/cb4c79f6e5e9129b3d99f3f0ac17f395d696b9f354df966faebc27f6ea120a8592548a59e5f7a7ad124583d23c93d621f00069a4af07a4b41a4a1f474bded4e0
-CompilerSupportLibraries.v0.4.3+0.i686-linux-musl-libgfortran4.tar.gz/md5/03e4d7d3189be081e4b56cdfcd439b5f
-CompilerSupportLibraries.v0.4.3+0.i686-linux-musl-libgfortran4.tar.gz/sha512/6c3f3b9fcad535a5e071853540b4b8689cde976a375b9406c93734e37d412f86069c8133ef85898efedd3b8fab0477d51f9ae681dabb00a66ec3f213e042bf82
-CompilerSupportLibraries.v0.4.3+0.i686-linux-musl-libgfortran5.tar.gz/md5/6b20e61bf6eef2bd8587d93bcbdf8ac2
-CompilerSupportLibraries.v0.4.3+0.i686-linux-musl-libgfortran5.tar.gz/sha512/2f7b0c63773f7c5e8bad43041ec30e727dffb665f4371c7ec5619648644c9ecc085674a15f0df20e5399d25d84bc8e49ce0cd29a5a438e7a828000395e0928eb
-CompilerSupportLibraries.v0.4.3+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/185a1f5582eede2e71bc6664294fe368
-CompilerSupportLibraries.v0.4.3+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/cc54dc1e1fe10374fd62d7e3a6159024dbb9638b90014e9cf6168ed63ee1b64f7a52f8c851315a340e5327513dfe939b3b04035631cdb251ec2232f8ba381d8a
-CompilerSupportLibraries.v0.4.3+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/ec4d496e9c5f3e806d78c30bb92f4324
-CompilerSupportLibraries.v0.4.3+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/4917f4755c3ccf223491d75baf729677d51abae00a66f7a66439b45169283aa86070bb314ae9256525de4b422b7213de9d087d0dba9a821caa71ec346f1138ed
-CompilerSupportLibraries.v0.4.3+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/4080d550f9a31d084c59195a98b6ed7b
-CompilerSupportLibraries.v0.4.3+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/6048b61a476905469e46c4e15a7067f0f39451c7374e981212cc9d2a66bdcbd7f0503d9eef731bfbe10b174d76937d7fa349f079a652587fecdfb2c6d59a1a1e
-CompilerSupportLibraries.v0.4.3+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/30bd967c069fbc73dc653f2ac9d55b6c
-CompilerSupportLibraries.v0.4.3+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/e16e77c72e3dd3399240bfcd72123da4540016eb91f10bd6015f0e6e58b397677b685c143527f5827423e7abb15abf5e461e3b74fccdb07dfdece2f0cb361912
-CompilerSupportLibraries.v0.4.3+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/073a8be233fae3c6b453684de7e51ea7
-CompilerSupportLibraries.v0.4.3+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/3fda4c515131c75181c662fa4d5fd538a0c8e257673edca7f94c46509c641d4720c130cffa37512bea0a215b6a9952735acbe359fb38e8e341822545021d88dc
-CompilerSupportLibraries.v0.4.3+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/4853c451821303959723f541434a7d1c
-CompilerSupportLibraries.v0.4.3+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/539a6b7626883d54b7661db6fcad1b7390ce37ab406a88065b8c24786353725f8cd972cbc29d07e71c9fefcb126239c8a63583626a0b8298c04b34de47bb9248
-CompilerSupportLibraries.v0.4.3+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/889855efa0450aa975166803fa775686
-CompilerSupportLibraries.v0.4.3+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/8162aebac8f13264cebdbc8359f4823f25cd28c76812df8687b5801b6e133206b514cbad5d5ff0d6fbb584eecd82038049c5a965637b43a5d12f77ad386addc8
-CompilerSupportLibraries.v0.4.3+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/ed9f7aee0565904a8cbd5cc26df37a9d
-CompilerSupportLibraries.v0.4.3+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/e93bd2a9e4e2c358f46f756f15d9765ef5aef44e5ee2adbfb23e971f380052f4ad5e4569fc5932b6250a40e204253e70966a6554c30c0251f1d5406babdac837
-CompilerSupportLibraries.v0.4.3+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/6757ed75b520bfd1f6edf55f01f7d1af
-CompilerSupportLibraries.v0.4.3+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/5f50c9df89ebd5a8b2c6a97e99b8340b0e63e4f689e3062a32474fdd6dd33f160647ae1a2ba96a30abac1bfbbd730be9824dcf4b05a4c327c0ad60c9b96f889f
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/954ffb60eb3cba5d7d02d3cf31fc3c75
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/199738c5e226565230368e38183de6af66ac1decc880cb28e072aeba097b8c060a6ee51d755072d66fe955a6621d183f28de364f7d57f372c8ad7585e30cded9
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/02c5342c240220803dea5edaa6aa03c0
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/c752b742d7aa39b7ac2297c8f4bae066c6c8217cb717cb7f913aa045b402350325e8ac96b0656404e39a891c825c57e18e5dc9325a954c7e64d98ece776293cd
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/5b2ca9ee08026e2ab9d24d18bb631ede
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/f98aed5aec767e1145b4f19515c99927e30790f577494e6d439c7f1a24f7e8e2acb977945f616abeceb614776e329f1a1f852edc1ade9de78a0c94f619046e40
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/6e5a0d8521b560e79cb5d5caffa4c675
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/7079605d315f45ebbd2a517b2aad38b226b574ee3f892a20efe02b8336654c84139a810820734456fcf6bb5bcc8fdd9408e783d1dfa2aa25168ec3e9b3e57785
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/dde75524ca38581b671d21c7ccc12c6d
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/ae229ccbb704da44f911704ee0700fe3e01730c9a5e7519dbf41c9e1aaf6d3f594678055845430e9c9d9b3ea974d1437fe2d84ae89f2886512c4569b9659a5dd
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/1d13546f090e9e068540d5ca42f193f2
-CompilerSupportLibraries.v0.4.3+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/cd8a4a83a2f09f9b18baa719b0ed13e9eefbee765bce326854e29ca76075e18401b9052d70b13461f16b08219707237aba7e7857aec28d417bd5dddf4eea9dda
-CompilerSupportLibraries.v0.4.3+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/6987269d8385d6b5716f075ab51ad5a9
-CompilerSupportLibraries.v0.4.3+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/0b5efa2c22c9be737a1396d10779fbbb91acd8662a6d419ba76d98b380b5c9cef977ac2d60e27c844d3c5f083fe4b59a6419675d09b8bd3e5b2fefc74ac09e0e
-CompilerSupportLibraries.v0.4.3+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/d430f7c46b66121833622ed58694368f
-CompilerSupportLibraries.v0.4.3+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/fc3c7bbf2c3730b68780950e4055491639d8874dc4b8509898722a4e7a06341cc43dbd7ed371e89f2a0cd11b515b0901a803f93349039b2c21aff6e453bca669
-CompilerSupportLibraries.v0.4.3+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/557985cb8720a3995482e13c319678fc
-CompilerSupportLibraries.v0.4.3+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/4d2b6b4431456e8067fd09b092617887277b4da3dc6e030d8091e7a9331c5fa73483f72626f6f06b3a749804b8060fc6ec8e592ecf87a3b1fcef96f5fc267c7d
-CompilerSupportLibraries.v0.4.3+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/aa27b022d98f489fb21c6d9a05b913a0
-CompilerSupportLibraries.v0.4.3+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/13d0f7e243674034b1d41a7020db58df6932a9a3d9a9ba450e1b673f5e56ff984ab68af8a3bf5a14590bfa43661a20d88a781d67009e3af9f60c15bf32e56196
-CompilerSupportLibraries.v0.4.3+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/7b381af909065da2da0e8eb035fffb47
-CompilerSupportLibraries.v0.4.3+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/c35170eea5174360ebe795ccb79fe4d6c9dca288d8f751e731dcaaf26866172372b5919393a965e18ba1aa553b6f420ca8d8db32b8d38aebd226906e18b7a4d9
-CompilerSupportLibraries.v0.4.3+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/8b4d1ee5add108fc05879fd0102cf34b
-CompilerSupportLibraries.v0.4.3+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/23c7bd53523d8380491b97cd57083956b55273b8d6aebef2e1b5c80ce8593cfe3eab5ff50b6a417b974996673fdfb810ed2fc28798bba42ce59cfe6284b1ef8f
+CompilerSupportLibraries.v0.5.0+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/307711def378e337a999c182aa7e07d8
+CompilerSupportLibraries.v0.5.0+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/0dcad5e315e045397320f667b27fc378da898ebfea9b55a2837e68b29434fe2c2ddc9652cc75a4551062ce70a2bfaffa8223c77398aa41fe1a73ccb44952cd8f
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/177f2665038919c3f8ed968226ff3b56
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/ea67c3b9986106aee12e5f22ab3d3c5d71a58759a7d20a7724bbb198e5c71f42fa2034e46f3147006a2d2277b3881f0546030d1040cb9393e58eeae87eb82c4d
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/f16db35be9018a5c61eaafaaf7226d10
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/051b5a0dd2235eaa90557e487c83499b3d7e0b9e921f7b2f14e77c81152c338acd5bac8040bdf6679db656cd8039093db43565f843dede253717425e464e61b0
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/e6082f3e46b627fdaef09f1ef81c1d7b
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/13d0ab1c0e84a65db729ea6bd45a868d9d65e1a0ec95412448846d1044e2bbf11b11d96cfa576dccf3d7eccc4bed4eb9ae4bac0989e9b1b97adad5e404dfe4a4
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/00703177897f8c46a577c2b0518432bc
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/af14ad1303f3918dd691e0b509ea0fd52ac7c9f0c285e8dbb741bd34ce0b1927f89f219fcf8d260315c503b18bf98b3df117810328066a9964917cc34968ce98
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/f823b692319cd370ca59189ad2ba4a3d
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/b0c4131bf4d15c482bbed83fcc570da2f7bb8ef99d507e0e13eb0c8f5519ec73ff234c58d505294be3f8d39b6dd1c7022578db02005ae111c7873243e8ddc8ef
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/a9ef1a68518058fe6c945e8b00f8400f
+CompilerSupportLibraries.v0.5.0+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/6aa53edf48a17ec8515cad5c79a15ab0e40cc44c9ffb188fd57fc560dde7a99d6487ead6e4caafaa9912c6590c6a391f914016fd4342589da09d56c657ad2c07
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/d3aaf50955ad671917e941e0dcf3803f
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/72983b2272300c2332cfe6864b5dd5249bbbb181bd65b10bf6bfb3a37e5e582bb9c159db0b63a077066a325899a2864717f28c60c85027be3b637bb80f994e52
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/e221d51df9b18b2562a0f3e8dc8012cd
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/758b07b4a559dda747574649926333a70355e2d80acb2ea37bb39777c0b1cecf8f308a5f8062110c378db2230ec8baf23385ae313d1c58de8bfc651573c64c1f
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/96f7feef9b1dd7944130de2e9cda68b8
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/8b4aaff1388cd506bef7f3a9edd42ed8ee1db468a18d34cd5d58d7da305853dbf48d4665e99c06c6fb0115e421d19dba5c36e947cb06defe7f479a05b547f112
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/a1e3642a7ce2b7834aa2f1b695a9977c
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/9d22b1fa8fa8eaaa5316cb494eb223e0fe73660aa5ca7518180e40d296d6d07a9863938501e5d5350bf79e79d975d7d66dca12768a0a69527d2c17baf7aaf345
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/d897098fd98928c2d644ed5ee26c3faa
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/4aad051f4f1e3d744825c650363a49f39e04cbd44dad25197ddee1890339e9441aa872f893478a2d8ff556c9a70a89c2885cd779ba3efd3c0f7193c386b820b7
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/c36bfd4c5b90d55c55bc18feaf51b134
+CompilerSupportLibraries.v0.5.0+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/ab16c638780a0118b930ac587df81fa74d2731bf1af402266106e1ecb791df353c1f368a8e7fc9147d390825ff8624e600aae45f1f6ccfc0015ce131368452d7
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/feb76551e6f7407de3006a3d363cee7a
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/976f8e34e72231b013ea0418feff9c3c9efa7b9c34688aca115a03f2bade8760ca9f259f8f502ef5012fbb389f4bf365fd7639b066daca16fb7ec1d32b5cd789
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/560ca43fa6dbd3f2e9052401477df165
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/333c7f4fbc172e7fd3d99e2673dbed1d9c699a5bb29a20095a255fadc89ded05abda755fc167aa8a16a4e93f524390c9c817df7b67fccdca88754d0301259977
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/d3ac5f871599ab225a1128c302486345
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/adb706882e923978b6e18c7134578bc86ed4e031a7a0120222018cd1b8efcf530854e426b6442dbd80b8c77c3677f1906aedb12c0ddeb33efcdd3bcd2c4a109a
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/58774aa398a63479af3f4c69678d0191
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/fe9307e6fb0b54522495fc9cc48756a60fc79af27d9e73bfb3ee49cbb366dddec1beedca03614f15761b308bc28014205f174f673fa258e76d5947446b87b039
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/af1a8ce693ba307e61184f4023d73d67
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/2ea581bb44408fc789ac306734736f6eb6cf0a15b234f43a6f50ae8f10014b5689f5aa8356112c2b54a86b9a7734ace3479c4e4aba1e5df636dda3dcd09b7e28
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/20d62064f495877f12b7e87e684ad43a
+CompilerSupportLibraries.v0.5.0+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/31b1c7c9fe3378e8bb788c897bbac0505a5ae70f500f3b1457325dbbb149c14224a88d17fbcf453465d8a572f33157766bb0e815cce7c8a2aa8a44422d34a365
+CompilerSupportLibraries.v0.5.0+0.i686-linux-gnu-libgfortran3.tar.gz/md5/fd4035aef1c83be0b865d70aa35e770b
+CompilerSupportLibraries.v0.5.0+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/a72047e7071838899d75896b4dcbdc102bca884507f4758b4e0dd62f50c9ce584f2b2b86d8b67dfc4fce9864faf9723056820e464bbab1a6173be47ad941d6da
+CompilerSupportLibraries.v0.5.0+0.i686-linux-gnu-libgfortran4.tar.gz/md5/89715bfa0e69528d4d294ed449ef0e09
+CompilerSupportLibraries.v0.5.0+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/6eb7947c72ec32d189221de42d5a76423a1fb5745db0812d88afe7f961d8f42669c7cf487235c1dcc81fbe73106b785c906bd6741e98f60e9931f4083be0e9ce
+CompilerSupportLibraries.v0.5.0+0.i686-linux-gnu-libgfortran5.tar.gz/md5/5c1c73dc72029781847f74bcb1189c4b
+CompilerSupportLibraries.v0.5.0+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/642d35ed41a65c7a2d7f4f127f936d3cb1665c207aa5feef25cce09cc11e733d7ec129673fea873403567c35cf16122ed1635c303ba13bb3349be44585f3ca82
+CompilerSupportLibraries.v0.5.0+0.i686-linux-musl-libgfortran3.tar.gz/md5/f91c962e7bc3ffb825c7e5fb1e099ba6
+CompilerSupportLibraries.v0.5.0+0.i686-linux-musl-libgfortran3.tar.gz/sha512/f89df221ff80bcbb1e6edc2f9cc28dc138d7d6ae99ac018a3cdc9a09ba637f1a9938b1f0876086f4f822fb911853286dd4f1776d603a403190bee052431ae572
+CompilerSupportLibraries.v0.5.0+0.i686-linux-musl-libgfortran4.tar.gz/md5/d2a81da3371a638f76087629ae0a6507
+CompilerSupportLibraries.v0.5.0+0.i686-linux-musl-libgfortran4.tar.gz/sha512/67941af15a0f032a853cdea180e4f87249bed2dfd09ade6fca9760f5a44b26fc94a0d6932803edbd27b75aa8d26e64c377af2d64ddcba3206562be1427a64c80
+CompilerSupportLibraries.v0.5.0+0.i686-linux-musl-libgfortran5.tar.gz/md5/cec9f3b9d4924a49a34c632efd167752
+CompilerSupportLibraries.v0.5.0+0.i686-linux-musl-libgfortran5.tar.gz/sha512/9320eee2b6dbadd4e0ed3f8763d58854eb179b1d1661c8f1dba75c22af2330812040507944b0ab20b7a7cb233c9953a1d3a4b27937e7b7a858aed2255ad0fbbc
+CompilerSupportLibraries.v0.5.0+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/c36411b24c8bec4805230bd4fe0f2391
+CompilerSupportLibraries.v0.5.0+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/839b447efa46caffa699258ec8ae5e0a55d7f98a7fc037b48e6a6c29193e3d8bf48397575cc518716f41e2e9344daa670693df605a1b9d4a23d3f454ec5ab399
+CompilerSupportLibraries.v0.5.0+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/d2e392edff3525afff6734fdf47c9ab1
+CompilerSupportLibraries.v0.5.0+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/1816c7ed409acc1435c7fcfd550b7664a08b31ecf433a906d8903a60ed458dab0fa712bd0d1590a0dc8506763a617446ba402efc78a2c010562c45e8eca66a88
+CompilerSupportLibraries.v0.5.0+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/2cfeb5cd0a7e2400c9be3e846a1875d2
+CompilerSupportLibraries.v0.5.0+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/ca620dd8542ffe9a177b0f95712e77e59b0fc1044e0186dd7468a86aba4d2b92931a1d6f980e75cceb26c6c5f9dab427f4ce32e0f77998b9a827b3ce9151041c
+CompilerSupportLibraries.v0.5.0+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/8ba0e4070358839909934d8a1bc9e0bf
+CompilerSupportLibraries.v0.5.0+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/8750769ca321f863fbb354f6e4e76b1241f7e24e5f4ea14ea511486dc5bc4fe8274740f1500149c5ac85a8214a0193c9a09332f35eb47e6222bef9070eecc6c8
+CompilerSupportLibraries.v0.5.0+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/50554a092af3a4a651b53e3ce3cf8a2d
+CompilerSupportLibraries.v0.5.0+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/53ec765d4de3b0bae9727b3b2a27437b184f2072aecda5d0b22d648a95fbba777bb89da823bc851d7242cd3f8c212e3fdaea8e5af11db21c578c2e12db51991d
+CompilerSupportLibraries.v0.5.0+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/b09a5913b537b26aa7f8996b1877c748
+CompilerSupportLibraries.v0.5.0+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/b68020c1b1acf4a1c51822bccc1eb67574ceffae3c133e7efe22ec0cc3a674a7c056c01be02c1c681f469fe1443d76baf4b0e305bec8181e57c3ce5a446a5c22
+CompilerSupportLibraries.v0.5.0+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/1e4c5d2084f76eacb4419214668c6594
+CompilerSupportLibraries.v0.5.0+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/696155b560bfaf592bf7024ba0e6f084382dd269cdd25416fa8840387c101132901e94709c8d0534f038666a6f6849c3d55e8bed4223b5be499e099b49610e77
+CompilerSupportLibraries.v0.5.0+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/63b386e59f3732d03459c59000fc1382
+CompilerSupportLibraries.v0.5.0+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/f6c7e0611df7fd86cc9ca63b380e112561d10b489bc8fbfe911c441ef5e87776761d3c161ff5f6aade479f7e96456084c6939d7eff175ced4f42b3b9ee29426a
+CompilerSupportLibraries.v0.5.0+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/07e22a4b58aaaf145e52b36602c5b08d
+CompilerSupportLibraries.v0.5.0+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/8a047b0098e8504e2dde0113170416686bc70f9d685fcb19bf3eb76afe30dc16a3b0d2023eb704c25025bbef87e99603dbd2a2708b1a3df908747b06cbfc92ee
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/23048b3be33f184ffc9be42ca914aa3a
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/4573b21e34f4d8127a86c18f95065039da92eeb9ade4058bd8459034bb4a003ceefe29e865089126fdc36cffd95a9c12bcb72ed74bff5987a9d1f4b300ecfe45
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/3314ec0668abf069c900558de0690b65
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/d012c4674401773000f0de831cb8b4b6c454d0ab68d51fbbe970504e76c693211086a24a7df34de2390eaeb438ab23f63c68b480a408ab2136f442aba5094bd7
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/e7768c00909613b8f29f6a5860ff4247
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/43c29456a0fc74c4fda42d088903651c6bbac6b842f2aa600e3019b391b04158ee97f884e6962bd9e7a9cf337dbb1cdb2151d103e1dee5214ba798b167b1ed32
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/b2a30e92ba8e40ef070e3ec7c16b97f0
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/64a4029dd1e84922728b2c93a455d7d6b262c979dddf59301ff96e9c28980fbd9c1db57e81afaece96ccb51b9751e5a0180b84e412427430487280c56d8da266
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/b0610d32a80b3f87baebf0250b0f92d6
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/3b7098fbb82e4a7a903b82f942303b248e0e35be13a47e4839a036085c4a33925f1f78fe941b852331cc52de80f32bcdb9a64ccff0386e1070a6ca4600c08eb8
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/3f905dd4e8b3cfd2cc3f8efcaa50a407
+CompilerSupportLibraries.v0.5.0+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/22af14d245e3c062131dd274afa6d9c7cde9a11ee2455e27ae2f7725a025fc2cd6cdb3a1a3c899988c6c3412a714c1f0763f4e08924726212405938c3cf66da5
+CompilerSupportLibraries.v0.5.0+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/2c56a22c935dda76831f36c713cca099
+CompilerSupportLibraries.v0.5.0+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/6bd9bd6ec8b6b18013b3c6de344de134835c9281d39bc5e6e31928970c60b584fa625df18efbce3ea571dee53011dec73e9aae9159e812f219692fbb4dd86a2d
+CompilerSupportLibraries.v0.5.0+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/e483c3e85b4d4b2685ee4e8f09951ac1
+CompilerSupportLibraries.v0.5.0+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/47c2f305237ccd55ed2ba445cbcd599c23f9c1392388017506f9d61a4dc8fec4ba4136be81a0e82de4f161f6788c4a62acc9d71efe6cf90b766e5339950ed337
+CompilerSupportLibraries.v0.5.0+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/41c25d9cf7545721b8d4dd2386e95ead
+CompilerSupportLibraries.v0.5.0+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/173570bbf4eb60d678472058ec2c18732cd27ad2911457c83f47a1d97c1c0028d91005cf56539e51d4a04178544ac0bba47ea27e74b6b4e8d3310551ad3167fe
+CompilerSupportLibraries.v0.5.0+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/f124c93580a038ce806f479568b46597
+CompilerSupportLibraries.v0.5.0+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/c313390dbcffaea6cb5202645b5304134a1ce6aac5a3835696f45316c8170b237c04f13166694eee0f31903ac1e5c3cd73ad8974ba19b44289da3504d3436f8c
+CompilerSupportLibraries.v0.5.0+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/050fe7a6bdf980c198f4c201629d15e0
+CompilerSupportLibraries.v0.5.0+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/211e435f5e2b7209aedaf4a81b5e0d5e615b9144de248c06e43dc61b31890dbde80d718e74454b489bd1f77476d34bd01d3f9a25355bc50fca0dc07df0264cad
+CompilerSupportLibraries.v0.5.0+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/3566d0f714c1503b92160b486a4eaa4a
+CompilerSupportLibraries.v0.5.0+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/b2f29c1c6dc35e1002021f8f15a20a72a57c346b33a6d045ff7a261e88767738a4da1dd88aa71a20514bdf6376099979c9d938173fa3ae28641c40372c94db60
diff --git a/stdlib/CompilerSupportLibraries_jll/Project.toml b/stdlib/CompilerSupportLibraries_jll/Project.toml
index 95366df955720..ac78369b12602 100644
--- a/stdlib/CompilerSupportLibraries_jll/Project.toml
+++ b/stdlib/CompilerSupportLibraries_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "CompilerSupportLibraries_jll"
 uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"
-version = "0.4.3+0"
+version = "0.5.0+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From 86caa5882e19ad289dc1827401ed2d6bb9755fc1 Mon Sep 17 00:00:00 2001
From: Rogerluo <rogerluo.rl18@gmail.com>
Date: Mon, 21 Jun 2021 13:18:39 -0400
Subject: [PATCH 08/44] fix preference loading (#41294)

(cherry picked from commit 7553ca13cc54852513b7c1eb07c9167833a55b91)
---
 base/loading.jl | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 95909608d861d..851ebf17cc3b9 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1765,9 +1765,9 @@ function get_preferences_hash(uuid::Union{UUID, Nothing}, prefs_list::Vector{Str
 
     # Walk through each name that's called out as a compile-time preference
     for name in prefs_list
-        prefs_name = get(prefs, name, nothing)::Union{String, Nothing}
-        if prefs_name !== nothing
-            h = hash(prefs_name, h)
+        prefs_value = get(prefs, name, nothing)
+        if prefs_value !== nothing
+            h = hash(prefs_value, h)
         end
     end
     # We always return a `UInt64` so that our serialization format is stable

From 6356c475d321b657f8cb1c286816b0a1686a97f1 Mon Sep 17 00:00:00 2001
From: Fredrik Ekre <ekrefredrik@gmail.com>
Date: Tue, 22 Jun 2021 09:06:38 +0200
Subject: [PATCH 09/44] Fix typeassert in worker-worker connection, fixes
 #41155. (#41305)

(cherry picked from commit a4dd5e5338ebebd0913d53befe092e282a68e217)
---
 stdlib/Distributed/src/cluster.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/Distributed/src/cluster.jl b/stdlib/Distributed/src/cluster.jl
index f485384aa1fec..ebe4cac0f3bbe 100644
--- a/stdlib/Distributed/src/cluster.jl
+++ b/stdlib/Distributed/src/cluster.jl
@@ -351,7 +351,7 @@ end
 function parse_connection_info(str)
     m = match(r"^julia_worker:(\d+)#(.*)", str)
     if m !== nothing
-        (m.captures[2], parse(UInt16, m.captures[1]))
+        (String(m.captures[2]), parse(UInt16, m.captures[1]))
     else
         ("", UInt16(0))
     end

From a43da1ee8245145c87ed1f259d32b43755502ee4 Mon Sep 17 00:00:00 2001
From: Sacha Verweij <sacha.verweij@alumni.stanford.edu>
Date: Mon, 21 Jun 2021 18:05:57 -0400
Subject: [PATCH 10/44] Fix inability to find support/{platform,dirpath}.h from
 julia_fasttls.h.

(cherry picked from commit 1b20d2b3aa6dedfba875895adcde86cb668253e5)
---
 src/julia_fasttls.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/julia_fasttls.h b/src/julia_fasttls.h
index 0dc0c05c82e10..3930a6d8a2d3c 100644
--- a/src/julia_fasttls.h
+++ b/src/julia_fasttls.h
@@ -10,8 +10,8 @@ extern "C" {
 #endif
 
 /* Bring in definitions for `_OS_X_`, `PATH_MAX` and `PATHSEPSTRING`, `jl_ptls_t`, etc... */
-#include "support/platform.h"
-#include "support/dirpath.h"
+#include "platform.h"
+#include "dirpath.h"
 
 typedef struct _jl_gcframe_t jl_gcframe_t;
 

From 6e49d1476e0a400e331b4629a9d4cdd51b77789e Mon Sep 17 00:00:00 2001
From: Sacha Verweij <sacha.verweij@alumni.stanford.edu>
Date: Mon, 21 Jun 2021 18:41:31 -0400
Subject: [PATCH 11/44] Drop parens from JULIA_DEFINE_FAST_TLS in
 embedding.{c,md} to match recent redefinition.

(cherry picked from commit 7366c3962e4419a10a96ab8a674b3f05aa2b34e5)
---
 doc/src/manual/embedding.md | 2 +-
 test/embedding/embedding.c  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/embedding.md b/doc/src/manual/embedding.md
index fcc9f06536ab3..22c2f66f9b8b0 100644
--- a/doc/src/manual/embedding.md
+++ b/doc/src/manual/embedding.md
@@ -16,7 +16,7 @@ We start with a simple C program that initializes Julia and calls some Julia cod
 
 ```c
 #include <julia.h>
-JULIA_DEFINE_FAST_TLS() // only define this once, in an executable (not in a shared library) if you want fast code.
+JULIA_DEFINE_FAST_TLS // only define this once, in an executable (not in a shared library) if you want fast code.
 
 int main(int argc, char *argv[])
 {
diff --git a/test/embedding/embedding.c b/test/embedding/embedding.c
index 205b8a7450211..d1816947f3856 100644
--- a/test/embedding/embedding.c
+++ b/test/embedding/embedding.c
@@ -4,7 +4,7 @@
 #include <stdio.h>
 #include <math.h>
 
-JULIA_DEFINE_FAST_TLS() // only define this once, in an executable
+JULIA_DEFINE_FAST_TLS // only define this once, in an executable
 
 #ifdef _OS_WINDOWS_
 __declspec(dllexport) __cdecl

From 096afe9883f14a5f6d18396a2a4b8d01dd751b9e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Wed, 23 Jun 2021 13:01:20 +0100
Subject: [PATCH 12/44] [OpenBLAS_jll] Bump to `v0.3.13+6` (#41322)

* [OpenBLAS_jll] Bump to `v0.3.13+6`

This version backports a fix for a `SIGILL` error on some CPUs.

* [deps] Bundle backported OpenBLAS patches

(cherry picked from commit ab567be6a3dba08e8a2e279aaa31d841b95329ea)
---
 deps/checksums/openblas                       | 186 ++++++++-------
 deps/openblas.mk                              |  12 +-
 ...-Only-filter-out-mavx-on-Sandybridge.patch | 221 ++++++++++++++++++
 ...ilter-out-mavx-flag-on-zgemm-kernels.patch | 162 +++++++++++++
 stdlib/OpenBLAS_jll/Project.toml              |   2 +-
 5 files changed, 487 insertions(+), 96 deletions(-)
 create mode 100644 deps/patches/openblas-Only-filter-out-mavx-on-Sandybridge.patch
 create mode 100644 deps/patches/openblas-filter-out-mavx-flag-on-zgemm-kernels.patch

diff --git a/deps/checksums/openblas b/deps/checksums/openblas
index ad67b3b6a2fc6..4b4d477ddc3d2 100644
--- a/deps/checksums/openblas
+++ b/deps/checksums/openblas
@@ -1,94 +1,92 @@
-openblas-d2b11c47774b9216660e76e2fc67e87079f26fa1.tar.gz/md5/d50510c8b60b477b1ece4abafe66bf4d
-openblas-d2b11c47774b9216660e76e2fc67e87079f26fa1.tar.gz/sha512/95ce349353bea5e9c30455410b92fa9ebc833e58163a53a65b396c76fddf19147a323a3c69eea5892354488c67b027e20dc9b03754a0988f3bc8a4e9ad446b8b
-OpenBLAS.v0.3.13+5.aarch64-apple-darwin-libgfortran5.tar.gz/md5/bd8b87e018af8cf4da8440d9c2d7ea4b
-OpenBLAS.v0.3.13+5.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/b066b590037a2ac6e8cd859ec642a330b4d058b60da2d071353c6dbe7691a8bb31a13fe36a03be3f1db5066ddd636c39911cb827aecb3811b5ff47de6ba3d3d3
-OpenBLAS.v0.3.13+5.aarch64-linux-gnu-libgfortran3.tar.gz/md5/0bfab1cdeab001382fbc6216a509532f
-OpenBLAS.v0.3.13+5.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/6137d4e861e61ad4ec6e871e7d24bf30979f701e27517b4b93cfea6230f34b70860d2bad8c8adadf426efce49d3348c1970d3bc85072c99aa255fcd6032450c0
-OpenBLAS.v0.3.13+5.aarch64-linux-gnu-libgfortran4.tar.gz/md5/ca0a14f775d18ef9313fc5a3d1ba36ad
-OpenBLAS.v0.3.13+5.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/74eb80e9f81519c514ddc09940c3ac6d79788ee0de3384e10039f836b806a7d4e521b25095606c366af1b84ef05aea47f6a6e9fb437b3297a4594c3507b36fc3
-OpenBLAS.v0.3.13+5.aarch64-linux-gnu-libgfortran5.tar.gz/md5/ad2976c0c5e7d5aa9b8d87cc23e9650d
-OpenBLAS.v0.3.13+5.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/2eda1e20468ea51d8196e8d2063cd709579aef33dd180957adf749e6a460330d47561b368885444be8a5eaca8c711058769fb8ebdcb9d7e5d7f55649e74c3677
-OpenBLAS.v0.3.13+5.aarch64-linux-musl-libgfortran3.tar.gz/md5/9f102704c8730df892ca4cb75d78d2a7
-OpenBLAS.v0.3.13+5.aarch64-linux-musl-libgfortran3.tar.gz/sha512/07345f12b03c004ec84e92ba2e4685478e09e13348b6a6c4faf41ddea7ec2bc11e9fbb2234865b931be880ff5a056f4ffa21d01706af46ce983597bddb56f340
-OpenBLAS.v0.3.13+5.aarch64-linux-musl-libgfortran4.tar.gz/md5/3d6132e2ec95f7c5d952e512b095abeb
-OpenBLAS.v0.3.13+5.aarch64-linux-musl-libgfortran4.tar.gz/sha512/b7b4c62ae8040b9290487f3399fdf6fff40c5172e8830d46e7c2d35f1eeae90c54d3a93d297d8e3bb70c8e251cb7ab83fee454b3876443d97cedd8c566325d88
-OpenBLAS.v0.3.13+5.aarch64-linux-musl-libgfortran5.tar.gz/md5/8a6e784e1194eee29bc0077b9d9c431d
-OpenBLAS.v0.3.13+5.aarch64-linux-musl-libgfortran5.tar.gz/sha512/732cfbf3663717aedb70b9b14041b520a0281e3a8597018205a0dd96d89fc8f307bcb9ed1158da50bf643af6f1518e1cb7c1734ac7966611a4a6e181f1f3ec80
-OpenBLAS.v0.3.13+5.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/64ef9d054ac9090d44c250d5ac773a71
-OpenBLAS.v0.3.13+5.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/92cace617a0ca6c06fea90848a1b8d5719e5f7ef62112b2c0ffdd34199e3153759a57c8cdd3f26893d880ddb5db2cf9e57963d758a9dc2d8cad3346cf6b5caae
-OpenBLAS.v0.3.13+5.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/d9d069d165541e1717e0f4bd2cd7018f
-OpenBLAS.v0.3.13+5.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/6b640b432ff56495610555f6f4cec897c25898e8625f8028dc11e3400bf099533e4a88628de85a852c6c10e76e8defd69cd3b6b5b53a072362fab38dfafebd08
-OpenBLAS.v0.3.13+5.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/d557c68c9d6e619f240239c1e3bdda6f
-OpenBLAS.v0.3.13+5.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/a9ee8ed000eb862bc10578526f311cd578d2cb59976b404d370150b97e84348b094852fae000dba4aa83d88b45bd50129da661cde7a1f8120dd1e29db66342cd
-OpenBLAS.v0.3.13+5.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/7570b2ae804f57605715f31ca5144ce2
-OpenBLAS.v0.3.13+5.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/87f169e260093a9652a299ae9b042fab015a21b67bae285bd425bd02471ebe41634f843be18bb4d8cb2fbe2f2ffb062b7de63148ed64fe66f4ba48dd622dd615
-OpenBLAS.v0.3.13+5.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/d2959f5bcb95f9ce759da9941b89dafc
-OpenBLAS.v0.3.13+5.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/dd4b0572c5165e511537f223e2bd2ff9b9c3f9ea241e8fe5c2863064f9dde37245c0e6cb331cd3ac6f02f15b4708bf53dcdd98daeb17f50eecb3abfbfb17a954
-OpenBLAS.v0.3.13+5.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/aa42183091223699052c4011b546f399
-OpenBLAS.v0.3.13+5.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/b465abdcf5e876f2faa091927bd40da8a3c99a64d13ebbb1154a9c5d73652791db1b58564ea7bb0b0801af0ff239c8f3530c7784b91c6e2d770258108458c9fc
-OpenBLAS.v0.3.13+5.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/9ddcfad4d2a2678acad7af0bd802ab94
-OpenBLAS.v0.3.13+5.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/6803844189ae00891559ad0dc624e8253c05c0a27b8bf589539164dacb5251f22e6829fade408d1f64e39dd0979fb0be0993da4c96ae91e76e962e9f0f023de2
-OpenBLAS.v0.3.13+5.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/91d4df8a78d2f6295cdd597ff6f3beea
-OpenBLAS.v0.3.13+5.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/670d8bd3e49fc53d68dba3675f1962a01bbb396fe4e36b5169016f61fe4f8528876d0ed88ed4830714029e73e62b49cafbae2ad384eebf90eee1e6f558abd514
-OpenBLAS.v0.3.13+5.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/d08af1ab6eac6b37a9565080d9179616
-OpenBLAS.v0.3.13+5.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/12f2e08fa4c5d040f0992ba99fd19342d27999ffbdd3df4a1b2981a852caf7148b9b6d17747a61a961da427840f77c8867ed82df6a8fe395e54e92f68739afd0
-OpenBLAS.v0.3.13+5.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/db725dfb473c4cda573950b955415102
-OpenBLAS.v0.3.13+5.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/d9be3863df5dd3ea5282a52489814db24f1a53fc76aaf323aaf6034637053b490dd927b37e71f29ad68cc4a825982d7e846ebe7fc5206d68ba2a74e411afb493
-OpenBLAS.v0.3.13+5.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/8668cfc1158871e4815fc0e169cabcf3
-OpenBLAS.v0.3.13+5.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/6b345f776f853df1c69f73afeb67e35dc7c928ade07b24b561d238fdde2270c054083b7a3e216ec20071f34fa945141fc5b38af84ce42e57cf9e3a0f1bfea4cd
-OpenBLAS.v0.3.13+5.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/00a1d20c390ea1eb8d1005ec9c26e809
-OpenBLAS.v0.3.13+5.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/2d0e0880e36be4761f61b27da16b644cb097012ed2b03141b1646f0b1ceed6176030cfb31a45e7a0d5ded99a2d6a8e472bf2e2c5f5e4260ed997e9e88cdc1b70
-OpenBLAS.v0.3.13+5.i686-linux-gnu-libgfortran3.tar.gz/md5/8d67cca00f231c01330b993f1c2b9b39
-OpenBLAS.v0.3.13+5.i686-linux-gnu-libgfortran3.tar.gz/sha512/abbd1b89f7a40b1b72aa9b0a9d57688e5d6d385029e7e2016d31eda866898c42686f1ad1a47d69213c7e79e0e85c1ab74dc5eb467eb07c286ef3153a7dd33113
-OpenBLAS.v0.3.13+5.i686-linux-gnu-libgfortran4.tar.gz/md5/9473d3d6bd2ff41ce7a9bd70077aa884
-OpenBLAS.v0.3.13+5.i686-linux-gnu-libgfortran4.tar.gz/sha512/3a3da3b01dad7b0171e1ecc18bf274a2c9043c756b06da0f140db68342d8fcbd9afcfd1b1b05aa9d3f3c8fa4ce1915ed25dc38671adcf98fef969a106e49470c
-OpenBLAS.v0.3.13+5.i686-linux-gnu-libgfortran5.tar.gz/md5/d64ccb11a8ea4c4dba5778f754e3e8f5
-OpenBLAS.v0.3.13+5.i686-linux-gnu-libgfortran5.tar.gz/sha512/8b4759484d705aae68d65a0785af9788c86d3766285c6fe3985837b9320f864be32f09e98707fa6d8614a702d44154019818fa4c44bafb9c54828e25555a4ac2
-OpenBLAS.v0.3.13+5.i686-linux-musl-libgfortran3.tar.gz/md5/02c1652b95583156ea798d0e0241b979
-OpenBLAS.v0.3.13+5.i686-linux-musl-libgfortran3.tar.gz/sha512/c9c7ed980170e5b4c23684d3979a972c47ed06c19ef582cbee7130b84511ca110af3408ae5b161162552a55611d7de6007c2a1d6adb4f872f1ccec4f6a3d38cd
-OpenBLAS.v0.3.13+5.i686-linux-musl-libgfortran4.tar.gz/md5/92a0082208291ead889f38ee4eeda56e
-OpenBLAS.v0.3.13+5.i686-linux-musl-libgfortran4.tar.gz/sha512/68cab863ca08fcde9aa75ccf8f34c49bdc4ff48089c982f2c00506765c7d37beaeddfb65e7d31847f1c61ef6390f6ce6fe307c7cf069ef7189ec55d38a56ddd3
-OpenBLAS.v0.3.13+5.i686-linux-musl-libgfortran5.tar.gz/md5/60e2bb9badf6121387d87bd8b88a63e9
-OpenBLAS.v0.3.13+5.i686-linux-musl-libgfortran5.tar.gz/sha512/13f7aaa870e9d7811ee79f1b8133345e0aa0d0bf4ad20d39acb43723b2bda1b11efaa2c6fec3cd8e2bc83b411be926fa74b39a8fcab1af92ccd0665435b22007
-OpenBLAS.v0.3.13+5.i686-w64-mingw32-libgfortran3.tar.gz/md5/f9e29157a222ec195f5d42dbe0472f8d
-OpenBLAS.v0.3.13+5.i686-w64-mingw32-libgfortran3.tar.gz/sha512/a3b0875554a063a966e03d4a2f3d2dfecd44b049b93a9b627aa0491b70fbe4d1ba04f8b939dd402e22fa6f650cc1d0bf0d5375c4453bf3b8f6a097ec8faf3993
-OpenBLAS.v0.3.13+5.i686-w64-mingw32-libgfortran4.tar.gz/md5/ada7c84a9ba17f2af1e54afb65d51790
-OpenBLAS.v0.3.13+5.i686-w64-mingw32-libgfortran4.tar.gz/sha512/0ca3f30c5c56c1d3da850f2c077ed76ea27782013d3a5b5253879ed55078a2435d862278bb5021def8d52e4bc2cbd202ba9d8a8f676afef14bac56cd2d5a6f5a
-OpenBLAS.v0.3.13+5.i686-w64-mingw32-libgfortran5.tar.gz/md5/42944f897776c8f0034fc31d74d1babe
-OpenBLAS.v0.3.13+5.i686-w64-mingw32-libgfortran5.tar.gz/sha512/bb3823fc50440a4a3b6624bfd12b9c1018220345ee3a3d7a7f7b84c75812c8f97bd1403aa88754155b3aa52fa0e70435eebea171969f8c4a79b76c582266a764
-OpenBLAS.v0.3.13+5.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/238e8a32a24c6ffb6881866182588846
-OpenBLAS.v0.3.13+5.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/9da4452924a8513f5f40c1c9350fdda30833a7ac9755421363e74f557944a5022df98881ccb1f9c468481550f8e4cc894d3963df57371a4d8c0dd0ee8cb1de70
-OpenBLAS.v0.3.13+5.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/6d27131cf20d9172ee8486776a768ec1
-OpenBLAS.v0.3.13+5.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/a10ecd91b98cf33e5541b64a5e4cd26cb7738d751f7c40c8e0ad337214ac9c15101f012c37ac9724c5414bea8f1bec5342c33e9ed1f7ae5f3e3a90e29cada89d
-OpenBLAS.v0.3.13+5.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/35d5f8477ea0ac0ce609785811d04164
-OpenBLAS.v0.3.13+5.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/77148afb919ece259c35e383e432cebabb65651fdcce00f8f15ec9d8f8805ea0a5615258b400f7ce73ed44405cd9f671b87c8aa015df4c7d417f9b2ee89e06dc
-OpenBLAS.v0.3.13+5.x86_64-apple-darwin-libgfortran3.tar.gz/md5/5b8910928fdf38f2dca382a3ca583414
-OpenBLAS.v0.3.13+5.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/65303a748366432ac1723009abdcd51674af2e6452522a813b32bd928bbae44de96c9e7279b9cf8e403fdb5adc8a323b1e383275ec5162aaca957fa9e7983116
-OpenBLAS.v0.3.13+5.x86_64-apple-darwin-libgfortran4.tar.gz/md5/a62af36a018e5e695476bedeb189db4c
-OpenBLAS.v0.3.13+5.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/594cd0536a3200bc452a7c1e26e0f179ba75f86f0ccd17ebc0816ff6bdd70ef4d367c6e68d173fa220cb092c4c65f0ceceaf55aa783032e28c465c060ead63d5
-OpenBLAS.v0.3.13+5.x86_64-apple-darwin-libgfortran5.tar.gz/md5/aedbf36e1e5e4aff51c7188c9d52c7f6
-OpenBLAS.v0.3.13+5.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/504afca82f8f30b7a93f0fc9fd9fdb2dbcb74b058fde3c3633b2462deb8b45f4c2f4caca5abf644196ac534799e07e1b7b55ce92ba395ff8e851c27d26113a42
-OpenBLAS.v0.3.13+5.x86_64-linux-gnu-libgfortran3.tar.gz/md5/9fc6ee1c8399a399dc5e6039bd99a3be
-OpenBLAS.v0.3.13+5.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/83896931f1e1f21a3c46a420238d4db2d633402cd72bb15f24d00359d7ff27cfd21f1e51a2e1e1cc95c90cf14ca6181060681784e14ae41d06857e5c732427fe
-OpenBLAS.v0.3.13+5.x86_64-linux-gnu-libgfortran4.tar.gz/md5/e2c0cf837ba543048e66563f339ba674
-OpenBLAS.v0.3.13+5.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/e63eb5501daadf460288aaab8d75ecfe4c321f775c25bf77836a0fb20cdd98f81adb8660e2b9465278fb0f002ed397f07399a93299b4373d571017511f474637
-OpenBLAS.v0.3.13+5.x86_64-linux-gnu-libgfortran5.tar.gz/md5/3301d928cce10270fe57dd9e1a83b9cc
-OpenBLAS.v0.3.13+5.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/2e2db27c44ca65b428cb081a0f6ad441cba91ac67e7309007870e4811398038bd0fc6db494d200cfa14b624797835fdf4f08fb21a34e3a61ca013e64e259fc9a
-OpenBLAS.v0.3.13+5.x86_64-linux-musl-libgfortran3.tar.gz/md5/384fbb41d82460762349990c60900fc2
-OpenBLAS.v0.3.13+5.x86_64-linux-musl-libgfortran3.tar.gz/sha512/05dceac3d28ab52d5becf51bca4b6696848902e70c44cbc3cc237fe761dea92b44d82b463671cd656ea0b82628c4c4eb7f2cf136f9c653e594bb8f349b46850f
-OpenBLAS.v0.3.13+5.x86_64-linux-musl-libgfortran4.tar.gz/md5/04e92d94fa5190e6915ff739a723ab54
-OpenBLAS.v0.3.13+5.x86_64-linux-musl-libgfortran4.tar.gz/sha512/c49f57d5d35adae65db8a5bb6829b2d3fa806c2232698796d1a7769845f122b1d34a5aa409199fd514364a99d854fa8f8369b0f7445a3a22a828d997a8d9e487
-OpenBLAS.v0.3.13+5.x86_64-linux-musl-libgfortran5.tar.gz/md5/26f0bb722acde07d05ea1c35cd976781
-OpenBLAS.v0.3.13+5.x86_64-linux-musl-libgfortran5.tar.gz/sha512/29ba655390118eadd760c2e46a0ad4dd8ed6776a8185e3a6acb5b3fa3542b454f7caf3d3b183ec04ad8cecde774e182d4400be875ff349b00880352a4e4dcc32
-OpenBLAS.v0.3.13+5.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/0d08d7b22e4d6d6a844653718a6beb35
-OpenBLAS.v0.3.13+5.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/08625e91f84243317e881a798e5c0c9f59ac19ec46c592d15ea105d1c24634fa17e66cfb9ac98a87a1bef14d3f550d278cde31e2cc62855288eb027778044a6f
-OpenBLAS.v0.3.13+5.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/5a2484aaedea160beafa0ae928f98bce
-OpenBLAS.v0.3.13+5.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/c5561a01275430fa6361da34f11f0478b343946c08428617d106e36e8ba1514b59628ad2fd798fdd78c0ed79e0d0014da8b08166182bcf88044dedd3357c5026
-OpenBLAS.v0.3.13+5.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/c6f17657a15f180dfe9d911c0b41a244
-OpenBLAS.v0.3.13+5.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/3dc411b0914734ec10d89d6acbb5ed70fc80ad8fc48fbdfa8c56dd209cb4c1251060b441d420bf2deb9cc81dc07605fc4036d7ae37d786a1069716f9bbb5870d
-OpenBLAS.v0.3.13+5.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/5e1451e34917819fa100a92dffeafea5
-OpenBLAS.v0.3.13+5.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/eea215ae37897fd03e0acd7b32547d33ee880ee000836632be637d503159bce5d8093a34d588ad4e9b9fa9b75ecebfeb09f633a8266db202076a4eda57be954b
-OpenBLAS.v0.3.13+5.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/a34a631f7c912ef84ac9a53720b8f2b4
-OpenBLAS.v0.3.13+5.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/78ceb1b14d89fb8ada27a1ce195d9e011a592c41079a7790df8cb9c88df57c798883967ee47ecd633d1eb281d3b751e3e41e4a0394b37d9ef511ec032d2ce299
-OpenBLAS.v0.3.13+5.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/fbfdf0d564cb892aa7d62f9874aad2d7
-OpenBLAS.v0.3.13+5.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/361d1e38445cad0ccd15bb886c7c3a45655ccd83b621cb8d7a50cc5061a05ade9d797f9011894ceede9c782f210c8f320eb1803b4d4620db6087d1bb6e192160
+OpenBLAS.v0.3.13+6.aarch64-apple-darwin-libgfortran5.tar.gz/md5/db35f9fcf744a3d86c0a20b8ab39c7c1
+OpenBLAS.v0.3.13+6.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/45ffdac8aa4150e96981cdc3d32242ebf7b7987fed5408d6cd6a9a6518cf7b7f204ca2a4226a0837cae76c2d4d4822d4ae93d2de1164428830c04e2147976341
+OpenBLAS.v0.3.13+6.aarch64-linux-gnu-libgfortran3.tar.gz/md5/aecd6bc6356314108c4ef2bfd768d006
+OpenBLAS.v0.3.13+6.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/1f5e861d3e14d64d0574a4dde4909f21cc0c22d1bfe052aae93a7ba3b3a9e564e01a7e1c921cb6175ba251a8aadfb0c4fce345803966dd7452db3d289bf144d3
+OpenBLAS.v0.3.13+6.aarch64-linux-gnu-libgfortran4.tar.gz/md5/7d20f2dd20459cee45adb024adb43efd
+OpenBLAS.v0.3.13+6.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/b06dcbf820f74e3e3cda4cfdf76113e7f518639642f141dac13ca19b05fec09160c3728fb4f7b001a9aa63300f6e289cd2126da1179ef4efce18e814d8c32bbf
+OpenBLAS.v0.3.13+6.aarch64-linux-gnu-libgfortran5.tar.gz/md5/5f0a683b55fc2f5a4dcd134a0d03c175
+OpenBLAS.v0.3.13+6.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/89c25976dd89e2e1c856790aaa4d0951f912fd7ded92223952316e40b08e4b9d9218b25a35cf9ab19021b356ccbb72c8bab2237bc62b8dac37317abe31edff6d
+OpenBLAS.v0.3.13+6.aarch64-linux-musl-libgfortran3.tar.gz/md5/5a7815b5981d30b89cb48a3e3bbf8f4d
+OpenBLAS.v0.3.13+6.aarch64-linux-musl-libgfortran3.tar.gz/sha512/358b7d25a069d50434b6621d1831903b88f6e120f10b5978235cc82f795da4d31ca4e6d02eb5eb1fd5587085828e95835e2ad84b2042865c552c5493cc272227
+OpenBLAS.v0.3.13+6.aarch64-linux-musl-libgfortran4.tar.gz/md5/02062032841900e941cfc66a0ef94dae
+OpenBLAS.v0.3.13+6.aarch64-linux-musl-libgfortran4.tar.gz/sha512/86f3072c3b8e36f3b33d90da755bf9d2a95ba0317852eaf1c74deb8a0f62a2b5c19a3b1d551c054536277da50865ef341c5e05fbab195edc4cd1fb160b4203b8
+OpenBLAS.v0.3.13+6.aarch64-linux-musl-libgfortran5.tar.gz/md5/ec50a9a3e5078726d6e3dd011b7a4713
+OpenBLAS.v0.3.13+6.aarch64-linux-musl-libgfortran5.tar.gz/sha512/548d4b893648de6c1a3d6b24f4531c4b190afc338887d1b8eb9040a9aae72cf846127e9c545841568a2f358f090451e13cf12a191456d4c27431661ca41f6e10
+OpenBLAS.v0.3.13+6.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/15cb058e906a1f042d51e8dcc44dac90
+OpenBLAS.v0.3.13+6.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/d74ba1d83199259b07787424832318e31013384d4f7217f6d7adb47dcbfe0836147997c044c8ca7a27b5a5eea435948a42d7f81a38014b7f7b3f4fb049e3578b
+OpenBLAS.v0.3.13+6.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/14b991b59eb27538331fae0544130d8a
+OpenBLAS.v0.3.13+6.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/d2c194692265325f9e5b6c09c23d7dcb45f1f2ce88edf2fbe6f9b021bfedf6b0c7c4b94a7ff5aa7095b7a131870759cd81ec80369e315660f5cbb0ac1c133e76
+OpenBLAS.v0.3.13+6.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/161a6506630eb035bc6afae69aea91dd
+OpenBLAS.v0.3.13+6.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/f64ce6bbaac4e16d5956b6298204628648b35e76f14a528aa8df815b0021053e4e1963438edc7e5f66fd82ea1e1d7bc38b14c52ad0ea7b90eeb1ee59d0927fd8
+OpenBLAS.v0.3.13+6.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/b4d102165aff04f4a3ff583c754ec90c
+OpenBLAS.v0.3.13+6.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/f488da922deaac3fa42f5637003c9dbfd943aa267104e6fce46b77fd9f10dfc580191bd5aa4c97bf5b41ad6a92fd669daca8b11479a3a7e28f41047826f0e6bd
+OpenBLAS.v0.3.13+6.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/9411f83736cbcef0b840914ace71d869
+OpenBLAS.v0.3.13+6.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/3b0c9077255fa639d8798193fb1c5fd8ad7824f58889d0c99b388b3ddc7622122387acc49fc29f7c5b5a62ff7dd2335a47b6e60c14d613ba37e11b79faddf7d2
+OpenBLAS.v0.3.13+6.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/1222f66dbd5eb8dc910efe04d37fb763
+OpenBLAS.v0.3.13+6.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/a747df8a04d50ef4a4b90bb66e682cd7414b6d2f0cd9577e25b18c80d36b599e9506e8fcf24729a8bc0f5ef464c57d86a87e1e74140597466dbd862eeb9a0b18
+OpenBLAS.v0.3.13+6.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/35fd828c77d3e1817bebef49aa045f02
+OpenBLAS.v0.3.13+6.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/fd4ce90ea21f64abde4497d3d6518c341383eae4c8f5052951b5c1469c87f1464cc1c57f7047bd4881b55d70d6453ef558e6d6e1986fe463a98a0567bbb876a5
+OpenBLAS.v0.3.13+6.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/deaa63f74369dbf358946c6796e8bd6b
+OpenBLAS.v0.3.13+6.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/7b16a7f5b5710de0b38122af6ed9e4a6b3ede4cd9c18c79314fbde366ca92c2dae17d1ab9e43213b5a6f80470455afbb06d54ff326e0404d60f5454164f2c62a
+OpenBLAS.v0.3.13+6.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/450506080f49538628dc2407461b894d
+OpenBLAS.v0.3.13+6.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/95dc7f14c1b1f450de59a3f95673dc510bcd0e38b6d82a8657d4dbdd97158d2095002a61ecb4a4c514e530c0a9879afd232f24a71561e8516683c564406a0a55
+OpenBLAS.v0.3.13+6.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/cadda67c770ea3835170c63cf5c1a93f
+OpenBLAS.v0.3.13+6.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/ccd326df1d3ce8e138fc22db37880a0f15b3b5740b75f4d6e54c6496735dea48d1011c31d0fbf6fcaf7f4ccc565cb2aa59bac473b9b12251da1adaa992998373
+OpenBLAS.v0.3.13+6.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/e89c9935ed19d9b6bedd1b70cbe1ea27
+OpenBLAS.v0.3.13+6.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/d537e954d424240315280fe632bfa83088825dd770042a750448e1553b2887a8c3d4edf193c89d2bccb7b0c3eae560937156eb989373accca1dbecee47e32cc4
+OpenBLAS.v0.3.13+6.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/7072bd88910ce5402e18527f178dcd56
+OpenBLAS.v0.3.13+6.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/0e4e038f317faa7a14cc29267202ad781a2551ef444b27f841ad2a39f5fb5032d20d50749d1b5a925e6552247aca40d84a1464c268022d8b9560c6e6fcf9a9bd
+OpenBLAS.v0.3.13+6.i686-linux-gnu-libgfortran3.tar.gz/md5/261636c2b2b3a734e0d054b67fc0e617
+OpenBLAS.v0.3.13+6.i686-linux-gnu-libgfortran3.tar.gz/sha512/0777c0cccb6f688024756e12f8a09ca107cf6f2408d04fb1efeae67299eb8de834de158b9ada232e3e50d4bb0481810181c54f6b63238ba8d4f1a779bf30ceab
+OpenBLAS.v0.3.13+6.i686-linux-gnu-libgfortran4.tar.gz/md5/af9998d911a0919bbc611279f6957d8f
+OpenBLAS.v0.3.13+6.i686-linux-gnu-libgfortran4.tar.gz/sha512/639d0d837dd62f4eff32071e2ef5d95d3d1a80995dc9da0a97e0a2f8bedf4637e3082acec309744d0d36dca8e82b3f7bf792ffb9ba47c18d8b9a44aa0f368adf
+OpenBLAS.v0.3.13+6.i686-linux-gnu-libgfortran5.tar.gz/md5/7bee1a7c3470c32c10e3776289ce730f
+OpenBLAS.v0.3.13+6.i686-linux-gnu-libgfortran5.tar.gz/sha512/ff76d5fc5ff2432dfcd9a36cfb95943fecab3e75153c12260b729a89c6bc2269f7f0ad256f6334d58445de27d32f6073e830cee4a59e9196a0b7395c3a3b7ab0
+OpenBLAS.v0.3.13+6.i686-linux-musl-libgfortran3.tar.gz/md5/362e299c65ed4011563caf8555f55738
+OpenBLAS.v0.3.13+6.i686-linux-musl-libgfortran3.tar.gz/sha512/45eeae6bc817e8d78c0daa69ca2add3c32d714766e1e1341d14c445a1beb5a5a7ae93e88649c9a62f07c5463b6ee300b60acc06d9d29974cc6725d08d9df66d9
+OpenBLAS.v0.3.13+6.i686-linux-musl-libgfortran4.tar.gz/md5/791075ccd19280d58209f48b487ec42b
+OpenBLAS.v0.3.13+6.i686-linux-musl-libgfortran4.tar.gz/sha512/44b9bf0b5d31048fe05f78a71fe9ddee799bd70f7586061fdd9a1390a894701eb96678ad9c332a21f2c2b079896924bee14d64ea89f6314babae1faac289d6eb
+OpenBLAS.v0.3.13+6.i686-linux-musl-libgfortran5.tar.gz/md5/712e9c7ef4640dbc150371ef3a10e249
+OpenBLAS.v0.3.13+6.i686-linux-musl-libgfortran5.tar.gz/sha512/3407fab09ae6e2b12c2b586915557d121bfa345a4bf66597bec2d5850ce33ad70dddb45ad08a975097e2a428e65abffdbd9747f1b46fa944bc52218798fd2e34
+OpenBLAS.v0.3.13+6.i686-w64-mingw32-libgfortran3.tar.gz/md5/93d7254e1e03f4ef1acb6b4e8d63c813
+OpenBLAS.v0.3.13+6.i686-w64-mingw32-libgfortran3.tar.gz/sha512/198d4d0455f981345f20ff4a196cca056fbd7c5fd4d6a2b11e0ec6ba695c362d309947b9fcc13a6c51a44cc3ea73e559c0246a98b26fd6baa6cf07a055f5c972
+OpenBLAS.v0.3.13+6.i686-w64-mingw32-libgfortran4.tar.gz/md5/728d9f80b9e6b5ecce0ffab86b7e1c52
+OpenBLAS.v0.3.13+6.i686-w64-mingw32-libgfortran4.tar.gz/sha512/1b8fc2e3e14fb172ec7d99d5beef54bcabdc807318f1b0415f1bdf7bb97a1e49c20168a9bfc0e89f4f9367dfbd1011e3cffe74b515da53fce00f06896387ca72
+OpenBLAS.v0.3.13+6.i686-w64-mingw32-libgfortran5.tar.gz/md5/b989478ab0496a27daf87f8ebb396316
+OpenBLAS.v0.3.13+6.i686-w64-mingw32-libgfortran5.tar.gz/sha512/c56ae711ecc9c6fe9e65e7610011f7189ecda4c0e94cfdd6bb150a32eac6f3d2343c671005f4008873e2f026fa312ce0257716a47fb4e91f82a6d29013dfc303
+OpenBLAS.v0.3.13+6.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/194ec8e4078fc6624acfefb29a9a1177
+OpenBLAS.v0.3.13+6.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/ecdd5b17232ae08e76f6822ec52cc96e4b5cde0748baf799799aa7946966b61f83c5b1d8a70e4f14b4e074e13e0cc72f2261f2a304ab8d8be15e68a004210be1
+OpenBLAS.v0.3.13+6.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/f08aad57a0d92ba7811b40deb7c40e5a
+OpenBLAS.v0.3.13+6.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/f5759dfce2854f929a73e11253edd37e100b9437829eca893f97a2c08a7ebc7af4815f588466cc8230985932f47b150e671d3a822e8463c1461bc3ce698f222d
+OpenBLAS.v0.3.13+6.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/bf291c76d9c9642e6964141eb541e4e0
+OpenBLAS.v0.3.13+6.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/0792f5d3c4c7f1ff5f43bcf6aafc8547c742e969ef4fc056f098649f7d99470538827349e5f39f0ce81ac15ec992f11d93a78f1ea9673a67ec076787b6d7b9c5
+OpenBLAS.v0.3.13+6.x86_64-apple-darwin-libgfortran3.tar.gz/md5/9a1979528b2b54df3012e2182b834bbd
+OpenBLAS.v0.3.13+6.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/1752e0ee45107eec916a42370e19b6091b41423eb0f9443f23f78c3e8dd8db5fa0b8b72f5edf2d26e759e0f44056034dde1bce38b9c12f58d6c931ec873bd67c
+OpenBLAS.v0.3.13+6.x86_64-apple-darwin-libgfortran4.tar.gz/md5/1b30b010ee8ecf949d83d98be7cd59a0
+OpenBLAS.v0.3.13+6.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/bab954ecbc2e9ece41807409bfef66063dc98cc7fbdbb0bbce24a331d5b121b0c63432a13cea935c5c27090f790e9fba599e1c129e0005656952805260732da6
+OpenBLAS.v0.3.13+6.x86_64-apple-darwin-libgfortran5.tar.gz/md5/da031443b1bd5ed8abb8e956a05c616c
+OpenBLAS.v0.3.13+6.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/0009d10265ff16603c8552663b3c71ab619905b18fe87119a3203fe24d531148b8b18f727260fc125362c58a6226d1dca98a6517e9b7a93418a2cdbb2c66806e
+OpenBLAS.v0.3.13+6.x86_64-linux-gnu-libgfortran3.tar.gz/md5/133b638a2efa22381cd70abe871e6ebe
+OpenBLAS.v0.3.13+6.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/98067cbaf1f5cf4a6ba01cf09ec9de044c04007f3a1953e51a75439cfb7215caa5b1a7f1b848b216926231a9511c45e78ba78abd39da06c6fbec4ce9542890f2
+OpenBLAS.v0.3.13+6.x86_64-linux-gnu-libgfortran4.tar.gz/md5/3590e16f503a615a8c8886af39d3fd14
+OpenBLAS.v0.3.13+6.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/b7f3fd487e44a4f6cbbf035bc9fb433aa761f05bc1cf0c5351e6f9a9e5b80450ffbd11f86f904477c89aadbe24e22780ce108e228585e701d92141a735b454fd
+OpenBLAS.v0.3.13+6.x86_64-linux-gnu-libgfortran5.tar.gz/md5/05472a418ff1d7f6bedb58894d6f5356
+OpenBLAS.v0.3.13+6.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/fc8a84b28db834b93a0c9a9c96ba22dfc6018cba90c0d43f4e1db7fcbda73c0aec04d7347db02b94df5375e785d447b3aeb993bf0ded69e5d43c2486c13b2aa5
+OpenBLAS.v0.3.13+6.x86_64-linux-musl-libgfortran3.tar.gz/md5/22200029744717079b3b8663d683273a
+OpenBLAS.v0.3.13+6.x86_64-linux-musl-libgfortran3.tar.gz/sha512/664bc2e95f10ac5668d51a2ffae488ad002f00995e5e7b620dd894e816bcaeeb7ccffb45f448365484f97f7aa5ac7b237ca1767e2a9421fd5c5fa39098c9fcb4
+OpenBLAS.v0.3.13+6.x86_64-linux-musl-libgfortran4.tar.gz/md5/b9fb6101fa172dd0f1a00c07673b308e
+OpenBLAS.v0.3.13+6.x86_64-linux-musl-libgfortran4.tar.gz/sha512/cf49792da8bc3e3a971b0361f2bdd835db46764c308d4ad0e20215c8bba5d6bd9b96e9e8fe2cdfb835bba4f21e62287f7b67245ff1d00a9ef3f9e44201b53412
+OpenBLAS.v0.3.13+6.x86_64-linux-musl-libgfortran5.tar.gz/md5/17c0ab204c65b252988bf873226f003d
+OpenBLAS.v0.3.13+6.x86_64-linux-musl-libgfortran5.tar.gz/sha512/02f493a6cb20c51c38203928a5a9e4890fc9285ce1907a552b61bd96bc64bc50a1932236d7617e83edc5ae1c40da84cc1d8db80c190605676869a8d1a57c4d7e
+OpenBLAS.v0.3.13+6.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/24e787f88452b2f304c269061ad07b0a
+OpenBLAS.v0.3.13+6.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/d45272120a6e15431b9a08afe5648afa903b588e2d65541f80ce123117dfc0e6d3b620ce4063211a420f1cfd398e969be69eb6a6302211fc368c4af3c9d6d3ef
+OpenBLAS.v0.3.13+6.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/9aa8cd86c2de41ed2ed47bccc315f19f
+OpenBLAS.v0.3.13+6.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/1c42e55fef774a34d3b0e0b0f899418a501cc9d56c4d38cfa0b4823a7622c7eb594f4ab222bd6994ba1c1eb7b69a37b10ec78b206a24d54276b03f69133b7b40
+OpenBLAS.v0.3.13+6.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/e09d926e41b3a52188cac7efe9d9aeed
+OpenBLAS.v0.3.13+6.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/eddc11f4b5535e629af6fe2705f24b142e457fd7721d6f9892e1c951d2722e996f32a59d05df803bc7a77c15ae011cc5f36a88709a7ebc9e6be00cd52789083b
+OpenBLAS.v0.3.13+6.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/5f09322a961185e965f8914b87fb769c
+OpenBLAS.v0.3.13+6.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/531860456a4604d7743b52632ca1562448e3b34015e0a7082935a12fe7537c3824fd6eca29813b8b28043c85db4c748ca2e42dfb443149e225b2ae1ebf641ece
+OpenBLAS.v0.3.13+6.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/68bf07ec07fab8eb000742f5b34a297a
+OpenBLAS.v0.3.13+6.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/5cf754e09737a9ccf67998a0dd64a6eb836784489b337bd9cd3379773ccc0d8261f6eb91ae6811dc45f3dd13480c6e0abc603f13add94bc5505ed4aa41e82951
+OpenBLAS.v0.3.13+6.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/d30d1b10c1a98ecbed686a1d133f4abc
+OpenBLAS.v0.3.13+6.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/6a61cd1eb2b20f33bb6370d760cf98c8c3af2f323b3c83c866ab8d2e3010771da7345fccbbb94880ca0c0956b711d3127566f040bbb79166e281b9ea6d14b2c7
diff --git a/deps/openblas.mk b/deps/openblas.mk
index e555e613c2ebc..d86663efcbde7 100644
--- a/deps/openblas.mk
+++ b/deps/openblas.mk
@@ -108,7 +108,17 @@ $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-exshift.patch-applied: $(BUILDDIR)/$(OP
 		patch -p1 -f < $(SRCDIR)/patches/openblas-exshift.patch
 	echo 1 > $@
 
-$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-exshift.patch-applied
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-filter-out-mavx-flag-on-zgemm-kernels.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-openblas-exshift.patch-applied
+	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && \
+		patch -p1 -f < $(SRCDIR)/patches/openblas-filter-out-mavx-flag-on-zgemm-kernels.patch
+	echo 1 > $@
+
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-Only-filter-out-mavx-on-Sandybridge.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-filter-out-mavx-flag-on-zgemm-kernels.patch
+	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && \
+		patch -p1 -f < $(SRCDIR)/patches/openblas-Only-filter-out-mavx-on-Sandybridge.patch
+	echo 1 > $@
+
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-Only-filter-out-mavx-on-Sandybridge.patch-applied
 	echo 1 > $@
 
 $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-compiled: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured
diff --git a/deps/patches/openblas-Only-filter-out-mavx-on-Sandybridge.patch b/deps/patches/openblas-Only-filter-out-mavx-on-Sandybridge.patch
new file mode 100644
index 0000000000000..10ba3b4a5c6b5
--- /dev/null
+++ b/deps/patches/openblas-Only-filter-out-mavx-on-Sandybridge.patch
@@ -0,0 +1,221 @@
+From c4da892ba0798f8697e7b3219fd631651647e45f Mon Sep 17 00:00:00 2001
+From: Martin Kroeker <martin@ruby.chemie.uni-freiburg.de>
+Date: Fri, 14 May 2021 23:19:10 +0200
+Subject: [PATCH 2/2] Only filter out -mavx on Sandybridge ZGEMM/ZTRMM kernels
+
+---
+ kernel/Makefile.L3 | 86 ++++++++++++++++++++++++++++++++++++----------
+ 1 file changed, 68 insertions(+), 18 deletions(-)
+
+diff --git a/kernel/Makefile.L3 b/kernel/Makefile.L3
+index be10ee01..2d9e3ec3 100644
+--- a/kernel/Makefile.L3
++++ b/kernel/Makefile.L3
+@@ -818,8 +818,10 @@ ifeq ($(OS), AIX)
+ 	m4 zgemm_kernel_n.s > zgemm_kernel_n_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DNN zgemm_kernel_n_nomacros.s -o $@
+ 	rm zgemm_kernel_n.s zgemm_kernel_n_nomacros.s
+-else
++else ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DDOUBLE -DCOMPLEX -DNN $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DNN $< -o $@
+ endif
+ 
+ $(KDIR)zgemm_kernel_l$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL) $(ZGEMMDEPEND)
+@@ -828,8 +830,10 @@ ifeq ($(OS), AIX)
+ 	m4 zgemm_kernel_l.s > zgemm_kernel_l_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DCN zgemm_kernel_l_nomacros.s -o $@
+ 	rm zgemm_kernel_l.s zgemm_kernel_l_nomacros.s
+-else
++else ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DDOUBLE -DCOMPLEX -DCN $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DCN $< -o $@
+ endif
+ 
+ $(KDIR)zgemm_kernel_r$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL) $(ZGEMMDEPEND)
+@@ -838,8 +842,10 @@ ifeq ($(OS), AIX)
+ 	m4 zgemm_kernel_r.s > zgemm_kernel_r_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DNC zgemm_kernel_r_nomacros.s -o $@
+ 	rm zgemm_kernel_r.s zgemm_kernel_r_nomacros.s
+-else
++else ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DDOUBLE -DCOMPLEX -DNC $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DNC $< -o $@
+ endif
+ 
+ $(KDIR)zgemm_kernel_b$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL) $(ZGEMMDEPEND)
+@@ -848,8 +854,10 @@ ifeq ($(OS), AIX)
+ 	m4 zgemm_kernel_b.s > zgemm_kernel_b_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DCC zgemm_kernel_b_nomacros.s -o $@
+ 	rm zgemm_kernel_b.s zgemm_kernel_b_nomacros.s
+-else
++else ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DDOUBLE -DCOMPLEX -DCC $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DCC $< -o $@
+ endif
+ 
+ $(KDIR)xgemm_kernel_n$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(XGEMMKERNEL) $(XGEMMDEPEND)
+@@ -1044,8 +1052,10 @@ ifeq ($(OS), AIX)
+ 	m4 ztrmm_kernel_ln.s > ztrmm_kernel_ln_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN ztrmm_kernel_ln_nomacros.s -o $@
+ 	rm ztrmm_kernel_ln.s ztrmm_kernel_ln_nomacros.s
+-else
++else ifeq ($(CORE), SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_LT$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1054,8 +1064,10 @@ ifeq ($(OS), AIX)
+ 	m4 ztrmm_kernel_lt.s > ztrmm_kernel_lt_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN ztrmm_kernel_lt_nomacros.s -o $@
+ 	rm ztrmm_kernel_lt.s ztrmm_kernel_lt_nomacros.s
+-else
++else ifeq ($(CORE), SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_LR$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1064,8 +1076,10 @@ ifeq ($(OS), AIX)
+ 	m4 ztrmm_kernel_lr.s > ztrmm_kernel_lr_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN ztrmm_kernel_lr_nomacros.s -o $@
+ 	rm ztrmm_kernel_lr.s ztrmm_kernel_lr_nomacros.s
+-else
++else ifeq ($(CORE), SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_LC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1074,8 +1088,10 @@ ifeq ($(OS), AIX)
+ 	m4 ztrmm_kernel_lc.s >ztrmm_kernel_lc_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN ztrmm_kernel_lc_nomacros.s -o $@
+ 	rm ztrmm_kernel_lc.s ztrmm_kernel_lc_nomacros.s 
+-else
++else ifeq ($(CORE), SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_RN$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1084,8 +1100,10 @@ ifeq ($(OS), AIX)
+ 	m4 ztrmm_kernel_rn.s > ztrmm_kernel_rn_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN ztrmm_kernel_rn_nomacros.s -o $@
+ 	rm ztrmm_kernel_rn.s ztrmm_kernel_rn_nomacros.s
+-else
++else ifeq ($(CORE), SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_RT$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1094,8 +1112,10 @@ ifeq ($(OS), AIX)
+ 	m4 ztrmm_kernel_rt.s > ztrmm_kernel_rt_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN ztrmm_kernel_rt_nomacros.s -o $@
+ 	rm ztrmm_kernel_rt.s ztrmm_kernel_rt_nomacros.s
+-else
++else ifeq ($(CORE), SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_RR$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1104,8 +1124,10 @@ ifeq ($(OS), AIX)
+ 	m4 ztrmm_kernel_rr.s > ztrmm_kernel_rr_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC ztrmm_kernel_rr_nomacros.s -o $@
+ 	rm ztrmm_kernel_rr.s ztrmm_kernel_rr_nomacros.s
+-else
++else ifeq ($(CORE), SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_RC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1114,8 +1136,10 @@ ifeq ($(OS), AIX)
+ 	m4 ztrmm_kernel_rc.s > ztrmm_kernel_rc_nomacros.s
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC ztrmm_kernel_rc_nomacros.s -o $@
+ 	rm ztrmm_kernel_rc.s ztrmm_kernel_rc_nomacros.s
+-else
++else ifeq ($(CORE), SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
+ endif
+ 
+ else
+@@ -1187,28 +1211,54 @@ $(KDIR)ctrmm_kernel_RC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(CGEMMKERNEL)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -UDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
+ 
+ $(KDIR)ztrmm_kernel_LN$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
++ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN $< -o $@
++endif
+ 
+ $(KDIR)ztrmm_kernel_LT$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
++ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN $< -o $@
+-
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN $< -o $@
++endif
+ $(KDIR)ztrmm_kernel_LR$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
++ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN $< -o $@
+-
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN $< -o $@
++endif
+ $(KDIR)ztrmm_kernel_LC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
++ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN $< -o $@
+-
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN $< -o $@
++endif
+ $(KDIR)ztrmm_kernel_RN$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
++ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN $< -o $@
+-
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN $< -o $@
++endif
+ $(KDIR)ztrmm_kernel_RT$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
++ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN $< -o $@
+-
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN $< -o $@
++endif
+ $(KDIR)ztrmm_kernel_RR$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
++ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC $< -o $@
+-
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC $< -o $@
++endif
+ $(KDIR)ztrmm_kernel_RC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
++ifeq ($(CORE),SANDYBRIDGE)
+ 	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
++else
++	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
++endif
+ endif
+ 
+ 
+-- 
+2.31.1
+
diff --git a/deps/patches/openblas-filter-out-mavx-flag-on-zgemm-kernels.patch b/deps/patches/openblas-filter-out-mavx-flag-on-zgemm-kernels.patch
new file mode 100644
index 0000000000000..5c9fa4aaa59e9
--- /dev/null
+++ b/deps/patches/openblas-filter-out-mavx-flag-on-zgemm-kernels.patch
@@ -0,0 +1,162 @@
+From bd60fb6ffc9d14834ed03bed0f7e6e44126c6c05 Mon Sep 17 00:00:00 2001
+From: Martin Kroeker <martin@ruby.chemie.uni-freiburg.de>
+Date: Thu, 13 May 2021 23:05:00 +0200
+Subject: [PATCH 1/2] filter out -mavx flag on zgemm kernels as it can cause
+ problems with older gcc
+
+---
+ kernel/Makefile.L3 | 40 ++++++++++++++++++++--------------------
+ 1 file changed, 20 insertions(+), 20 deletions(-)
+
+diff --git a/kernel/Makefile.L3 b/kernel/Makefile.L3
+index d8d73996..be10ee01 100644
+--- a/kernel/Makefile.L3
++++ b/kernel/Makefile.L3
+@@ -819,7 +819,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DNN zgemm_kernel_n_nomacros.s -o $@
+ 	rm zgemm_kernel_n.s zgemm_kernel_n_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DNN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DDOUBLE -DCOMPLEX -DNN $< -o $@
+ endif
+ 
+ $(KDIR)zgemm_kernel_l$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL) $(ZGEMMDEPEND)
+@@ -829,7 +829,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DCN zgemm_kernel_l_nomacros.s -o $@
+ 	rm zgemm_kernel_l.s zgemm_kernel_l_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DCN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DDOUBLE -DCOMPLEX -DCN $< -o $@
+ endif
+ 
+ $(KDIR)zgemm_kernel_r$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL) $(ZGEMMDEPEND)
+@@ -839,7 +839,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DNC zgemm_kernel_r_nomacros.s -o $@
+ 	rm zgemm_kernel_r.s zgemm_kernel_r_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DNC $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DDOUBLE -DCOMPLEX -DNC $< -o $@
+ endif
+ 
+ $(KDIR)zgemm_kernel_b$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL) $(ZGEMMDEPEND)
+@@ -849,7 +849,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DCC zgemm_kernel_b_nomacros.s -o $@
+ 	rm zgemm_kernel_b.s zgemm_kernel_b_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DDOUBLE -DCOMPLEX -DCC $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DDOUBLE -DCOMPLEX -DCC $< -o $@
+ endif
+ 
+ $(KDIR)xgemm_kernel_n$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(XGEMMKERNEL) $(XGEMMDEPEND)
+@@ -1045,7 +1045,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN ztrmm_kernel_ln_nomacros.s -o $@
+ 	rm ztrmm_kernel_ln.s ztrmm_kernel_ln_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_LT$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1055,7 +1055,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN ztrmm_kernel_lt_nomacros.s -o $@
+ 	rm ztrmm_kernel_lt.s ztrmm_kernel_lt_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_LR$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1065,7 +1065,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN ztrmm_kernel_lr_nomacros.s -o $@
+ 	rm ztrmm_kernel_lr.s ztrmm_kernel_lr_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_LC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1075,7 +1075,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN ztrmm_kernel_lc_nomacros.s -o $@
+ 	rm ztrmm_kernel_lc.s ztrmm_kernel_lc_nomacros.s 
+ else
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_RN$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1085,7 +1085,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN ztrmm_kernel_rn_nomacros.s -o $@
+ 	rm ztrmm_kernel_rn.s ztrmm_kernel_rn_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_RT$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1095,7 +1095,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN ztrmm_kernel_rt_nomacros.s -o $@
+ 	rm ztrmm_kernel_rt.s ztrmm_kernel_rt_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_RR$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1105,7 +1105,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC ztrmm_kernel_rr_nomacros.s -o $@
+ 	rm ztrmm_kernel_rr.s ztrmm_kernel_rr_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC $< -o $@
+ endif
+ 
+ $(KDIR)ztrmm_kernel_RC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZTRMMKERNEL)
+@@ -1115,7 +1115,7 @@ ifeq ($(OS), AIX)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC ztrmm_kernel_rc_nomacros.s -o $@
+ 	rm ztrmm_kernel_rc.s ztrmm_kernel_rc_nomacros.s
+ else
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
+ endif
+ 
+ else
+@@ -1187,28 +1187,28 @@ $(KDIR)ctrmm_kernel_RC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(CGEMMKERNEL)
+ 	$(CC) $(CFLAGS) -c -DTRMMKERNEL -UDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
+ 
+ $(KDIR)ztrmm_kernel_LN$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -UCONJ -DNN $< -o $@
+ 
+ $(KDIR)ztrmm_kernel_LT$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -UCONJ -DNN $< -o $@
+ 
+ $(KDIR)ztrmm_kernel_LR$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -UTRANSA -DCONJ -DCN $< -o $@
+ 
+ $(KDIR)ztrmm_kernel_LC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -DLEFT -DTRANSA -DCONJ -DCN $< -o $@
+ 
+ $(KDIR)ztrmm_kernel_RN$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -UCONJ -DNN $< -o $@
+ 
+ $(KDIR)ztrmm_kernel_RT$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -UCONJ -DNN $< -o $@
+ 
+ $(KDIR)ztrmm_kernel_RR$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -UTRANSA -DCONJ -DNC $< -o $@
+ 
+ $(KDIR)ztrmm_kernel_RC$(TSUFFIX).$(SUFFIX) : $(KERNELDIR)/$(ZGEMMKERNEL)
+-	$(CC) $(CFLAGS) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
++	$(CC) $(filter-out -mavx,$(CFLAGS)) -c -DTRMMKERNEL -DDOUBLE -DCOMPLEX -ULEFT -DTRANSA -DCONJ -DNC $< -o $@
+ endif
+ 
+ 
+-- 
+2.31.1
+
diff --git a/stdlib/OpenBLAS_jll/Project.toml b/stdlib/OpenBLAS_jll/Project.toml
index b236ed0809eec..f7d4dcce97cd7 100644
--- a/stdlib/OpenBLAS_jll/Project.toml
+++ b/stdlib/OpenBLAS_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "OpenBLAS_jll"
 uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
-version = "0.3.13+5"
+version = "0.3.13+6"
 
 [deps]
 CompilerSupportLibraries_jll = "e66e0078-7015-5450-92f7-15fbd957f2ae"

From cb312e84719c2b76a95221c6dd923f435e5b3a69 Mon Sep 17 00:00:00 2001
From: GregPlowman <GregPlowman@users.noreply.github.com>
Date: Thu, 24 Jun 2021 12:52:01 +1000
Subject: [PATCH 13/44] change doc for seed! thread-local -> task-local
 (#41341)

default rng is task-local not thread-local?

(cherry picked from commit ba5fffca7bb661031d3e17c6ed8ae378ada125c4)
---
 stdlib/Random/src/Random.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/Random/src/Random.jl b/stdlib/Random/src/Random.jl
index 53dbe38238bbc..45aa6442eed7e 100644
--- a/stdlib/Random/src/Random.jl
+++ b/stdlib/Random/src/Random.jl
@@ -392,7 +392,7 @@ After the call to `seed!`, `rng` is equivalent to a newly created
 object initialized with the same seed.
 
 If `rng` is not specified, it defaults to seeding the state of the
-shared thread-local generator.
+shared task-local generator.
 
 # Examples
 ```julia-repl

From d011977d764e377e53d942a4150f94f7a6004c94 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@alumni.harvard.edu>
Date: Wed, 23 Jun 2021 22:47:57 -0400
Subject: [PATCH 14/44] inference: Add some basic inference for PhiNode
 (#41115)

PhiNode isn't really supported in lowered IR, but it is convenient
to be able to emit it, particularly for code that is designed to
perform transformations both on typed and on lowered IR (such as
Diffractor). Moreover, we do actually supported phinodes in untyped
IR both in the interpreter and in the compiler. At the moment,
inference assumes that PhiNodes get treated as embedded constants,
which is just not what the actual implementation does. At the very
least, it should just leave PhiNodes alone in case they accidentally
end up in lowered IR (rather than causing crashes), but we might
as well give them some basic support.

(cherry picked from commit bb52621dfad3acba5168688ceccb74841fb41483)
---
 base/compiler/abstractinterpretation.jl |  7 +++++
 base/compiler/optimize.jl               | 39 +++++++++++++++++++++----
 base/compiler/typeinfer.jl              |  4 +--
 base/compiler/utilities.jl              | 10 +++++++
 src/codegen.cpp                         |  8 +++--
 test/compiler/inference.jl              | 32 ++++++++++++++++++++
 6 files changed, 89 insertions(+), 11 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index db68fe721642c..7c804c80ae262 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1413,6 +1413,13 @@ end
 
 function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e), vtypes::VarTable, sv::InferenceState)
     if !isa(e, Expr)
+        if isa(e, PhiNode)
+            rt = Union{}
+            for val in e.values
+                rt = tmerge(rt, abstract_eval_special_value(interp, val, vtypes, sv))
+            end
+            return rt
+        end
         return abstract_eval_special_value(interp, e, vtypes, sv)
     end
     e = e::Expr
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 2d4f0d022fd6d..6d059247a43ea 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -593,14 +593,23 @@ function renumber_ir_elements!(body::Vector{Any}, changemap::Vector{Int})
     return renumber_ir_elements!(body, changemap, changemap)
 end
 
-function renumber_ir_elements!(body::Vector{Any}, ssachangemap::Vector{Int}, labelchangemap::Vector{Int})
-    for i = 2:length(labelchangemap)
-        labelchangemap[i] += labelchangemap[i - 1]
+function cumsum_ssamap!(ssamap::Vector{Int})
+    rel_change = 0
+    for i = 1:length(ssamap)
+        rel_change += ssamap[i]
+        if ssamap[i] == -1
+            # Keep a marker that this statement was deleted
+            ssamap[i] = typemin(Int)
+        else
+            ssamap[i] = rel_change
+        end
     end
+end
+
+function renumber_ir_elements!(body::Vector{Any}, ssachangemap::Vector{Int}, labelchangemap::Vector{Int})
+    cumsum_ssamap!(labelchangemap)
     if ssachangemap !== labelchangemap
-        for i = 2:length(ssachangemap)
-            ssachangemap[i] += ssachangemap[i - 1]
-        end
+        cumsum_ssamap!(ssachangemap)
     end
     if labelchangemap[end] == 0 && ssachangemap[end] == 0
         return
@@ -621,6 +630,24 @@ function renumber_ir_elements!(body::Vector{Any}, ssachangemap::Vector{Int}, lab
             end
         elseif isa(el, SSAValue)
             body[i] = SSAValue(el.id + ssachangemap[el.id])
+        elseif isa(el, PhiNode)
+            i = 1
+            edges = el.edges
+            values = el.values
+            while i <= length(edges)
+                was_deleted = ssachangemap[edges[i]] == typemin(Int)
+                if was_deleted
+                    deleteat!(edges, i)
+                    deleteat!(values, i)
+                else
+                    edges[i] += ssachangemap[edges[i]]
+                    val = values[i]
+                    if isa(val, SSAValue)
+                        values[i] = SSAValue(val.id + ssachangemap[val.id])
+                    end
+                    i += 1
+                end
+            end
         elseif isa(el, Expr)
             if el.head === :(=) && el.args[2] isa Expr
                 el = el.args[2]::Expr
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 3fa2f20006fec..4ad96ae2e72f0 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -672,9 +672,7 @@ function type_annotate!(sv::InferenceState, run_optimizer::Bool)
                 deleteat!(src.codelocs, i)
                 deleteat!(sv.stmt_info, i)
                 nexpr -= 1
-                if oldidx < length(changemap)
-                    changemap[oldidx + 1] = -1
-                end
+                changemap[oldidx] = -1
                 continue
             else
                 body[i] = Const(expr) # annotate that this statement actually is dead
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 4e9d2b74cf40c..3b84395c676d2 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -267,6 +267,8 @@ function find_ssavalue_uses(body::Vector{Any}, nvals::Int)
             push!(uses[e.id], line)
         elseif isa(e, Expr)
             find_ssavalue_uses(e, uses, line)
+        elseif isa(e, PhiNode)
+            find_ssavalue_uses(e, uses, line)
         end
     end
     return uses
@@ -287,6 +289,14 @@ function find_ssavalue_uses(e::Expr, uses::Vector{BitSet}, line::Int)
     end
 end
 
+function find_ssavalue_uses(e::PhiNode, uses::Vector{BitSet}, line::Int)
+    for val in e.values
+        if isa(val, SSAValue)
+            push!(uses[val.id], line)
+        end
+    end
+end
+
 function is_throw_call(e::Expr)
     if e.head === :call
         f = e.args[1]
diff --git a/src/codegen.cpp b/src/codegen.cpp
index cba7d1d2d3080..4eba89badbd8e 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -4087,9 +4087,13 @@ static void emit_vi_assignment_unboxed(jl_codectx_t &ctx, jl_varinfo_t &vi, Valu
 static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
 {
     jl_value_t *ssavalue_types = (jl_value_t*)ctx.source->ssavaluetypes;
-    assert(jl_is_array(ssavalue_types));
+    jl_value_t *phiType = NULL;
+    if (jl_is_array(ssavalue_types)) {
+        phiType = jl_array_ptr_ref(ssavalue_types, idx);
+    } else {
+        phiType = (jl_value_t*)jl_any_type;
+    }
     jl_array_t *edges = (jl_array_t*)jl_fieldref_noalloc(r, 0);
-    jl_value_t *phiType = jl_array_ptr_ref(ssavalue_types, idx);
     BasicBlock *BB = ctx.builder.GetInsertBlock();
     auto InsertPt = BB->getFirstInsertionPt();
     if (phiType == jl_bottom_type) {
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 52602a58c517b..d5bad34e38322 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -3323,3 +3323,35 @@ end |> first === Tuple{Int, String}
 primitive type UInt24ish 24 end
 f34288(x) = Core.Intrinsics.checked_sdiv_int(x, Core.Intrinsics.trunc_int(UInt24ish, 0))
 @test Base.return_types(f34288, (UInt24ish,)) == Any[UInt24ish]
+
+# Inference of PhiNode showing up in lowered AST
+function f_convert_me_to_ir(b, x)
+    a = b ? sin(x) : cos(x)
+    return a
+end
+
+let
+    # Test the presence of PhiNodes in lowered IR by taking the above function,
+    # running it through SSA conversion and then putting it into an opaque
+    # closure.
+    mi = Core.Compiler.specialize_method(first(methods(f_convert_me_to_ir)),
+        Tuple{Bool, Float64}, Core.svec())
+    ci = Base.uncompressed_ast(mi.def)
+    ci.ssavaluetypes = Any[Any for i = 1:ci.ssavaluetypes]
+    sv = Core.Compiler.OptimizationState(mi, Core.Compiler.OptimizationParams(),
+        Core.Compiler.NativeInterpreter())
+    ir = Core.Compiler.convert_to_ircode(ci, Core.Compiler.copy_exprargs(ci.code),
+        false, 2, sv)
+    ir = Core.Compiler.slot2reg(ir, ci, 2, sv)
+    ir = Core.Compiler.compact!(ir)
+    Core.Compiler.replace_code_newstyle!(ci, ir, 3)
+    ci.ssavaluetypes = length(ci.code)
+    @test any(x->isa(x, Core.PhiNode), ci.code)
+    oc = @eval b->$(Expr(:new_opaque_closure, Tuple{Bool, Float64}, false, Any, Any,
+        Expr(:opaque_closure_method, nothing, 2, LineNumberNode(0, nothing), ci)))(b, 1.0)
+    @test Base.return_types(oc, Tuple{Bool}) == Any[Float64]
+
+    oc = @eval ()->$(Expr(:new_opaque_closure, Tuple{Bool, Float64}, false, Any, Any,
+        Expr(:opaque_closure_method, nothing, 2, LineNumberNode(0, nothing), ci)))(true, 1.0)
+    @test Base.return_types(oc, Tuple{}) == Any[Float64]
+end

From 1bb99efba17f52da0b032f5659ab75fd9054648c Mon Sep 17 00:00:00 2001
From: Atsushi Sakai <asakai.amsl+github@gmail.com>
Date: Sun, 27 Jun 2021 23:38:35 +0900
Subject: [PATCH 15/44] more links for distributed computing docs (#41378)

(cherry picked from commit 1e3ae2308d5f3ac8fe0c2e47f967e5566edcf0cd)
---
 doc/src/manual/distributed-computing.md | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/doc/src/manual/distributed-computing.md b/doc/src/manual/distributed-computing.md
index bfcfb883e8228..e0f373233c723 100644
--- a/doc/src/manual/distributed-computing.md
+++ b/doc/src/manual/distributed-computing.md
@@ -1,6 +1,6 @@
 # Multi-processing and Distributed Computing
 
-An implementation of distributed memory parallel computing is provided by module `Distributed`
+An implementation of distributed memory parallel computing is provided by module [`Distributed`](@ref man-distributed)
 as part of the standard library shipped with Julia.
 
 Most modern computers possess more than one CPU, and several computers can be combined together
@@ -45,11 +45,11 @@ computation is running on the worker.
 
 Let's try this out. Starting with `julia -p n` provides `n` worker processes on the local machine.
 Generally it makes sense for `n` to equal the number of CPU threads (logical cores) on the machine. Note that the `-p`
-argument implicitly loads module `Distributed`.
+argument implicitly loads module [`Distributed`](@ref man-distributed).
 
 
 ```julia
-$ ./julia -p 2
+$ julia -p 2
 
 julia> r = remotecall(rand, 2, 2, 2)
 Future(2, 1, 4, nothing)
@@ -198,7 +198,7 @@ loaded
 ```
 
 As usual, this does not bring `DummyModule` into scope on any of the process, which requires
-`using` or `import`.  Moreover, when `DummyModule` is brought into scope on one process, it
+[`using`](@ref) or [`import`](@ref).  Moreover, when `DummyModule` is brought into scope on one process, it
 is not on any other:
 
 ```julia-repl
@@ -236,7 +236,7 @@ like a process providing an interactive prompt.
 
 Finally, if `DummyModule.jl` is not a standalone file but a package, then `using
 DummyModule` will _load_ `DummyModule.jl` on all processes, but only bring it into scope on
-the process where `using` was called.
+the process where [`using`](@ref) was called.
 
 ## Starting and managing worker processes
 
@@ -262,7 +262,7 @@ julia> addprocs(2)
  3
 ```
 
-Module `Distributed` must be explicitly loaded on the master process before invoking [`addprocs`](@ref).
+Module [`Distributed`](@ref man-distributed) must be explicitly loaded on the master process before invoking [`addprocs`](@ref).
 It is automatically made available on the worker processes.
 
 Note that workers do not run a `~/.julia/config/startup.jl` startup script, nor do they synchronize
@@ -322,8 +322,8 @@ is replaced with a more expensive operation. Then it might make sense to add ano
 statement just for this step.
 
 ## Global variables
-Expressions executed remotely via `@spawnat`, or closures specified for remote execution using
-`remotecall` may refer to global variables. Global bindings under module `Main` are treated
+Expressions executed remotely via [`@spawnat`](@ref), or closures specified for remote execution using
+[`remotecall`](@ref) may refer to global variables. Global bindings under module `Main` are treated
 a little differently compared to global bindings in other modules. Consider the following code
 snippet:
 
@@ -335,7 +335,7 @@ remotecall_fetch(()->sum(A), 2)
 In this case [`sum`](@ref) MUST be defined in the remote process.
 Note that `A` is a global variable defined in the local workspace. Worker 2 does not have a variable called
 `A` under `Main`. The act of shipping the closure `()->sum(A)` to worker 2 results in `Main.A` being defined
-on 2. `Main.A` continues to exist on worker 2 even after the call `remotecall_fetch` returns. Remote calls
+on 2. `Main.A` continues to exist on worker 2 even after the call [`remotecall_fetch`](@ref) returns. Remote calls
 with embedded global references (under `Main` module only) manage globals as follows:
 
 - New global bindings are created on destination workers if they are referenced as part of a remote call.
@@ -1205,12 +1205,12 @@ requirements for the inbuilt `LocalManager` and `SSHManager`:
     Securing and encrypting all worker-worker traffic (via SSH) or encrypting individual messages
     can be done via a custom `ClusterManager`.
 
-  * If you specify `multiplex=true` as an option to `addprocs`, SSH multiplexing is used to create
+  * If you specify `multiplex=true` as an option to [`addprocs`](@ref), SSH multiplexing is used to create
     a tunnel between the master and workers. If you have configured SSH multiplexing on your own and
     the connection has already been established, SSH multiplexing is used regardless of `multiplex`
     option. If multiplexing is enabled, forwarding is set by using the existing connection
     (`-O forward` option in ssh). This is beneficial if your servers require password authentication;
-    you can avoid authentication in Julia by logging in to the server ahead of `addprocs`. The control
+    you can avoid authentication in Julia by logging in to the server ahead of [`addprocs`](@ref). The control
     socket will be located at `~/.ssh/julia-%r@%h:%p` during the session unless the existing multiplexing
     connection is used. Note that bandwidth may be limited if you create multiple processes on a node
     and enable multiplexing, because in that case processes share a single multiplexing TCP connection.
@@ -1236,7 +1236,7 @@ For example, cookies can be pre-shared and hence not specified as a startup argu
 
 ## Specifying Network Topology (Experimental)
 
-The keyword argument `topology` passed to `addprocs` is used to specify how the workers must be
+The keyword argument `topology` passed to [`addprocs`](@ref) is used to specify how the workers must be
 connected to each other:
 
   * `:all_to_all`, the default: all workers are connected to each other.

From 5dccb0958aedad1c48c84c8488aeca361dfd0901 Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Mon, 28 Jun 2021 10:28:40 +0200
Subject: [PATCH 16/44] fix equality of QRCompactWY (#41363)

Equality for `QRCompactWY` did not ignore the subdiagonal entries of
`T` leading to nondeterministic behavior.

This is pulled out from #41228, since this change should be less
controversial than the other changes there and this particular bug just
came up in ChainRules again.

(cherry picked from commit 74fab49ffba4913fd93edb742ed53c5728bc4c42)
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl  |  3 +-
 stdlib/LinearAlgebra/src/qr.jl             | 34 ++++++++++++
 stdlib/LinearAlgebra/test/factorization.jl | 60 ++++++++++++++++++++++
 stdlib/LinearAlgebra/test/testgroups       |  1 +
 4 files changed, 97 insertions(+), 1 deletion(-)
 create mode 100644 stdlib/LinearAlgebra/test/factorization.jl

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index 8dfed4b5c89b9..eb8d22e55a1e8 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -16,7 +16,8 @@ import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, as
     setindex!, show, similar, sin, sincos, sinh, size, sqrt,
     strides, stride, tan, tanh, transpose, trunc, typed_hcat, vec
 using Base: IndexLinear, promote_op, promote_typeof,
-    @propagate_inbounds, @pure, reduce, typed_vcat, require_one_based_indexing
+    @propagate_inbounds, @pure, reduce, typed_vcat, require_one_based_indexing,
+    splat
 using Base.Broadcast: Broadcasted, broadcasted
 import Libdl
 
diff --git a/stdlib/LinearAlgebra/src/qr.jl b/stdlib/LinearAlgebra/src/qr.jl
index d0ec430347193..2982da339dd17 100644
--- a/stdlib/LinearAlgebra/src/qr.jl
+++ b/stdlib/LinearAlgebra/src/qr.jl
@@ -127,6 +127,40 @@ Base.iterate(S::QRCompactWY) = (S.Q, Val(:R))
 Base.iterate(S::QRCompactWY, ::Val{:R}) = (S.R, Val(:done))
 Base.iterate(S::QRCompactWY, ::Val{:done}) = nothing
 
+# returns upper triangular views of all non-undef values of `qr(A).T`:
+#
+# julia> sparse(qr(A).T .== qr(A).T)
+# 36×100 SparseMatrixCSC{Bool, Int64} with 1767 stored entries:
+# ⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+# ⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+# ⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿
+# ⠀⠀⠀⠀⠀⠂⠛⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿
+# ⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⢀⠐⠙⢿⣿⣿⣿⣿
+# ⠀⠀⠐⠀⠀⠀⠀⠀⠀⢀⢙⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠁⠀⡀⠀⠙⢿⣿⣿
+# ⠀⠀⠐⠀⠀⠀⠀⠀⠀⠀⠄⠀⠙⢿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⡀⠀⠀⢀⠀⠀⠙⢿
+# ⠀⡀⠀⠀⠀⠀⠀⠀⠂⠒⠒⠀⠀⠀⠙⢿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣿⣿⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⠀⡀⠀⠀
+# ⠀⠀⠀⠀⠀⠀⠀⠀⣈⡀⠀⠀⠀⠀⠀⠀⠙⢿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠂⠀⢀⠀
+#
+function _triuppers_qr(T)
+    blocksize, cols = size(T)
+    return Iterators.map(0:div(cols - 1, blocksize)) do i
+        n = min(blocksize, cols - i * blocksize)
+        return UpperTriangular(view(T, 1:n, (1:n) .+ i * blocksize))
+    end
+end
+
+function Base.hash(F::QRCompactWY, h::UInt)
+    return hash(F.factors, foldr(hash, _triuppers_qr(F.T); init=hash(QRCompactWY, h)))
+end
+function Base.:(==)(A::QRCompactWY, B::QRCompactWY)
+    return A.factors == B.factors && all(splat(==), zip(_triuppers_qr.((A.T, B.T))...))
+end
+function Base.isequal(A::QRCompactWY, B::QRCompactWY)
+    return isequal(A.factors, B.factors) && all(zip(_triuppers_qr.((A.T, B.T))...)) do (a, b)
+        isequal(a, b)::Bool
+    end
+end
+
 """
     QRPivoted <: Factorization
 
diff --git a/stdlib/LinearAlgebra/test/factorization.jl b/stdlib/LinearAlgebra/test/factorization.jl
new file mode 100644
index 0000000000000..6a9226d80cdf6
--- /dev/null
+++ b/stdlib/LinearAlgebra/test/factorization.jl
@@ -0,0 +1,60 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+module TestFactorization
+using Test, LinearAlgebra
+
+@testset "equality for factorizations - $f" for f in Any[
+    bunchkaufman,
+    cholesky,
+    x -> cholesky(x, Val(true)),
+    eigen,
+    hessenberg,
+    lq,
+    lu,
+    qr,
+    x -> qr(x, ColumnNorm()),
+    svd,
+    schur,
+]
+    A = randn(3, 3)
+    A = A * A' # ensure A is pos. def. and symmetric
+    F, G = f(A), f(A)
+
+    @test F == G
+    @test isequal(F, G)
+    @test hash(F) == hash(G)
+
+    f === hessenberg && continue
+
+    # change all arrays in F to have eltype Float32
+    F = typeof(F).name.wrapper(Base.mapany(1:nfields(F)) do i
+        x = getfield(F, i)
+        return x isa AbstractArray{Float64} ? Float32.(x) : x
+    end...)
+    # round all arrays in G to the nearest Float64 representable as Float32
+    G = typeof(G).name.wrapper(Base.mapany(1:nfields(G)) do i
+        x = getfield(G, i)
+        return x isa AbstractArray{Float64} ? Float64.(Float32.(x)) : x
+    end...)
+
+    @test F == G broken=!(f === eigen || f === qr)
+    @test isequal(F, G) broken=!(f === eigen || f === qr)
+    @test hash(F) == hash(G)
+end
+
+@testset "equality of QRCompactWY" begin
+    A = rand(100, 100)
+    F, G = qr(A), qr(A)
+
+    @test F == G
+    @test isequal(F, G)
+    @test hash(F) == hash(G)
+
+    G.T[28, 100] = 42
+
+    @test F != G
+    @test !isequal(F, G)
+    @test hash(F) != hash(G)
+end
+
+end
diff --git a/stdlib/LinearAlgebra/test/testgroups b/stdlib/LinearAlgebra/test/testgroups
index b33dfecaa82ee..de082d8e7dce0 100644
--- a/stdlib/LinearAlgebra/test/testgroups
+++ b/stdlib/LinearAlgebra/test/testgroups
@@ -25,3 +25,4 @@ givens
 structuredbroadcast
 addmul
 ldlt
+factorization

From 9fbc0dcd1b9f77766ea3db18749e82c814558af7 Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Mon, 28 Jun 2021 21:42:13 +0200
Subject: [PATCH 17/44] fix #41330: backslash not escaping `\r\n` (#41333)

(cherry picked from commit 96b3c5d733592ff1523a7c75db32d016761d7757)
---
 base/shell.jl        | 7 +++++--
 src/julia-parser.scm | 7 +++++--
 test/syntax.jl       | 7 +++++++
 3 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/base/shell.jl b/base/shell.jl
index a5b25fc63ea44..475a0871d8355 100644
--- a/base/shell.jl
+++ b/base/shell.jl
@@ -88,9 +88,12 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
                 in_double_quotes = !in_double_quotes
                 i = consume_upto!(arg, s, i, j)
             elseif !in_single_quotes && c == '\\'
-                if !isempty(st) && peek(st)[2] == '\n'
+                if !isempty(st) && peek(st)[2] in ('\n', '\r')
                     i = consume_upto!(arg, s, i, j) + 1
-                    _ = popfirst!(st)
+                    if popfirst!(st)[2] == '\r' && peek(st)[2] == '\n'
+                        i += 1
+                        popfirst!(st)
+                    end
                 elseif in_double_quotes
                     isempty(st) && error("unterminated double quote")
                     k, c′ = peek(st)
diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index 3a5dfad9293bd..fb29cb5005fba 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -2365,8 +2365,11 @@
                     (loop (read-char p) b e 0))))
            (let ((nxch (not-eof-for delim (read-char p))))
              (write-char #\\ b)
-             (write-char nxch b)
-             (loop (read-char p) b e 0))))
+             (if (eqv? nxch #\return)
+                 (loop nxch b e 0)
+                 (begin
+                   (write-char nxch b)
+                   (loop (read-char p) b e 0))))))
 
       ((and (eqv? c #\$) (not raw))
        (let* ((ex (parse-interpolate s))
diff --git a/test/syntax.jl b/test/syntax.jl
index 6e3ec82ca3e81..9ef8c033c14ad 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -2930,3 +2930,10 @@ end
 
 # issue #41253
 @test (function (::Dict{}); end)(Dict()) === nothing
+
+@testset "issue #41330" begin
+    @test Meta.parse("\"a\\\r\nb\"") == "ab"
+    @test Meta.parse("\"a\\\rb\"") == "ab"
+    @test eval(Meta.parse("`a\\\r\nb`")) == `ab`
+    @test eval(Meta.parse("`a\\\rb`")) == `ab`
+end

From 49961fb8828a0b73aa1a324df1e40f6c58965591 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 28 Jun 2021 16:09:01 -0400
Subject: [PATCH 18/44] fix `threadcall` for new ccall lookup strategy (#41345)

(cherry picked from commit 5f182852e86c02c6371c913741376cc21c886e25)
---
 base/threadcall.jl | 15 ++++++++-------
 src/jl_uv.c        |  8 +++++---
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/base/threadcall.jl b/base/threadcall.jl
index 2267e4ea2228c..f0e5f336ec0ca 100644
--- a/base/threadcall.jl
+++ b/base/threadcall.jl
@@ -30,7 +30,7 @@ macro threadcall(f, rettype, argtypes, argvals...)
     argvals = map(esc, argvals)
 
     # construct non-allocating wrapper to call C function
-    wrapper = :(function (args_ptr::Ptr{Cvoid}, retval_ptr::Ptr{Cvoid})
+    wrapper = :(function (fptr::Ptr{Cvoid}, args_ptr::Ptr{Cvoid}, retval_ptr::Ptr{Cvoid})
         p = args_ptr
         # the rest of the body is created below
     end)
@@ -42,18 +42,19 @@ macro threadcall(f, rettype, argtypes, argvals...)
         push!(body, :(p += Core.sizeof($T)))
         push!(args, arg)
     end
-    push!(body, :(ret = ccall($f, $rettype, ($(argtypes...),), $(args...))))
+    push!(body, :(ret = ccall(fptr, $rettype, ($(argtypes...),), $(args...))))
     push!(body, :(unsafe_store!(convert(Ptr{$rettype}, retval_ptr), ret)))
     push!(body, :(return Int(Core.sizeof($rettype))))
 
     # return code to generate wrapper function and send work request thread queue
     wrapper = Expr(Symbol("hygienic-scope"), wrapper, @__MODULE__)
-    return :(let fun_ptr = @cfunction($wrapper, Int, (Ptr{Cvoid}, Ptr{Cvoid}))
-        do_threadcall(fun_ptr, $rettype, Any[$(argtypes...)], Any[$(argvals...)])
+    return :(let fun_ptr = @cfunction($wrapper, Int, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}))
+        # use cglobal to look up the function on the calling thread
+        do_threadcall(fun_ptr, cglobal($f), $rettype, Any[$(argtypes...)], Any[$(argvals...)])
     end)
 end
 
-function do_threadcall(fun_ptr::Ptr{Cvoid}, rettype::Type, argtypes::Vector, argvals::Vector)
+function do_threadcall(fun_ptr::Ptr{Cvoid}, cfptr::Ptr{Cvoid}, rettype::Type, argtypes::Vector, argvals::Vector)
     # generate function pointer
     c_notify_fun = @cfunction(
         function notify_fun(idx)
@@ -86,8 +87,8 @@ function do_threadcall(fun_ptr::Ptr{Cvoid}, rettype::Type, argtypes::Vector, arg
     GC.@preserve args_arr ret_arr roots begin
         # queue up the work to be done
         ccall(:jl_queue_work, Cvoid,
-            (Ptr{Cvoid}, Ptr{UInt8}, Ptr{UInt8}, Ptr{Cvoid}, Cint),
-            fun_ptr, args_arr, ret_arr, c_notify_fun, idx)
+            (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{UInt8}, Ptr{UInt8}, Ptr{Cvoid}, Cint),
+            fun_ptr, cfptr, args_arr, ret_arr, c_notify_fun, idx)
 
         # wait for a result & return it
         wait(thread_notifiers[idx])
diff --git a/src/jl_uv.c b/src/jl_uv.c
index a2dce926a924f..18733926e8c54 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -966,12 +966,13 @@ JL_DLLEXPORT int jl_tty_set_mode(uv_tty_t *handle, int mode)
     return uv_tty_set_mode(handle, mode_enum);
 }
 
-typedef int (*work_cb_t)(void *, void *);
+typedef int (*work_cb_t)(void *, void *, void *);
 typedef void (*notify_cb_t)(int);
 
 struct work_baton {
     uv_work_t req;
     work_cb_t work_func;
+    void      *ccall_fptr;
     void      *work_args;
     void      *work_retval;
     notify_cb_t notify_func;
@@ -985,7 +986,7 @@ struct work_baton {
 void jl_work_wrapper(uv_work_t *req)
 {
     struct work_baton *baton = (struct work_baton*) req->data;
-    baton->work_func(baton->work_args, baton->work_retval);
+    baton->work_func(baton->ccall_fptr, baton->work_args, baton->work_retval);
 }
 
 void jl_work_notifier(uv_work_t *req, int status)
@@ -995,12 +996,13 @@ void jl_work_notifier(uv_work_t *req, int status)
     free(baton);
 }
 
-JL_DLLEXPORT int jl_queue_work(work_cb_t work_func, void *work_args, void *work_retval,
+JL_DLLEXPORT int jl_queue_work(work_cb_t work_func, void *ccall_fptr, void *work_args, void *work_retval,
                                notify_cb_t notify_func, int notify_idx)
 {
     struct work_baton *baton = (struct work_baton*)malloc_s(sizeof(struct work_baton));
     baton->req.data = (void*) baton;
     baton->work_func = work_func;
+    baton->ccall_fptr = ccall_fptr;
     baton->work_args = work_args;
     baton->work_retval = work_retval;
     baton->notify_func = notify_func;

From bafa35cbff167e273b662b6d405375380c9ba291 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 28 Jun 2021 18:30:55 -0400
Subject: [PATCH 19/44] make `Task` smaller by rearranging fields (#41351)

This makes jl_task_t 8 bytes smaller, moving it into the next-smallest
pool, which drops the effective size from 400 to 368 bytes.

(cherry picked from commit af4bbfdaa4d89d6d214f3f4351cda31aa2cf6b2c)
---
 src/jltypes.c | 16 ++++++++--------
 src/julia.h   | 14 +++++++-------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/jltypes.c b/src/jltypes.c
index f6200daf65023..f9f60f1227b9a 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -2539,13 +2539,13 @@ void jl_init_types(void) JL_GC_DISABLED
                                         "result",
                                         "logstate",
                                         "code",
-                                        "_state",
-                                        "sticky",
-                                        "_isexception",
                                         "rngState0",
                                         "rngState1",
                                         "rngState2",
-                                        "rngState3"),
+                                        "rngState3",
+                                        "_state",
+                                        "sticky",
+                                        "_isexception"),
                         jl_svec(14,
                                 jl_any_type,
                                 jl_any_type,
@@ -2554,13 +2554,13 @@ void jl_init_types(void) JL_GC_DISABLED
                                 jl_any_type,
                                 jl_any_type,
                                 jl_any_type,
-                                jl_uint8_type,
-                                jl_bool_type,
-                                jl_bool_type,
                                 jl_uint64_type,
                                 jl_uint64_type,
                                 jl_uint64_type,
-                                jl_uint64_type),
+                                jl_uint64_type,
+                                jl_uint8_type,
+                                jl_bool_type,
+                                jl_bool_type),
                         jl_emptysvec,
                         0, 1, 6);
     jl_value_t *listt = jl_new_struct(jl_uniontype_type, jl_task_type, jl_nothing_type);
diff --git a/src/julia.h b/src/julia.h
index faa738913af18..3455817cf1a92 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1829,24 +1829,24 @@ typedef struct _jl_task_t {
     jl_value_t *result;
     jl_value_t *logstate;
     jl_function_t *start;
-    uint8_t _state;
-    uint8_t sticky; // record whether this Task can be migrated to a new thread
-    uint8_t _isexception; // set if `result` is an exception to throw or that we exited with
     uint64_t rngState0; // really rngState[4], but more convenient to split
     uint64_t rngState1;
     uint64_t rngState2;
     uint64_t rngState3;
+    uint8_t _state;
+    uint8_t sticky; // record whether this Task can be migrated to a new thread
+    uint8_t _isexception; // set if `result` is an exception to throw or that we exited with
 
 // hidden state:
+    // id of owning thread - does not need to be defined until the task runs
+    int16_t tid;
+    // multiqueue priority
+    int16_t prio;
     // saved gc stack top for context switches
     jl_gcframe_t *gcstack;
     size_t world_age;
     // quick lookup for current ptls
     jl_tls_states_t *ptls; // == jl_all_tls_states[tid]
-    // id of owning thread - does not need to be defined until the task runs
-    int16_t tid;
-    // multiqueue priority
-    int16_t prio;
     // saved exception stack
     jl_excstack_t *excstack;
     // current exception handler

From 2b41b769f90d45f67f500a966b58465d23f5ad79 Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Tue, 29 Jun 2021 17:31:39 +0200
Subject: [PATCH 20/44] strip spaces after backslash-escaped newline (#41245)

This was discussed on Slack with @StefanKarpinski and @BioTurboNick and
the general consensus was that stripping all spaces following a
backslash-escaped newline would make more sense than the current
behavior. Stripping the newline and spaces after a backslash now happens
before detenting for triple-quoted srings, so in cases like

```julia
"""
  a\
b
  c"""
```

the `b` doesn't affect detenting and the spaces before `a` and `c` are
removed.

(cherry picked from commit be08627b0d2d4f61fb2d1c7b0a379f5faec982ba)
---
 base/shell.jl        |  4 ++++
 src/julia-parser.scm | 25 +++++++++++++++++--------
 test/syntax.jl       | 10 +++++-----
 3 files changed, 26 insertions(+), 13 deletions(-)

diff --git a/base/shell.jl b/base/shell.jl
index 475a0871d8355..2efe61f4bbfdb 100644
--- a/base/shell.jl
+++ b/base/shell.jl
@@ -94,6 +94,10 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
                         i += 1
                         popfirst!(st)
                     end
+                    while !isempty(st) && peek(st)[2] in (' ', '\t')
+                        i = nextind(str, i)
+                        _ = popfirst!(st)
+                    end
                 elseif in_double_quotes
                     isempty(st) && error("unterminated double quote")
                     k, c′ = peek(st)
diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index fb29cb5005fba..a22e714135822 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -2188,8 +2188,13 @@
 (define (unescape-parsed-string-literal strs)
   (map-at even? unescape-string strs))
 
+(define (strip-escaped-newline s raw)
+  (if raw s (map (lambda (s)
+                   (if (string? s) (strip-escaped-newline- s) s))
+                 s)))
+
 ;; remove `\` followed by a newline
-(define (strip-escaped-newline s)
+(define (strip-escaped-newline- s)
   (let ((in  (open-input-string s))
         (out (open-output-string)))
     (define (loop preceding-backslash?)
@@ -2197,7 +2202,10 @@
             (cond ((eof-object? c))
                   (preceding-backslash?
                    (if (not (eqv? c #\newline))
-                       (begin (write-char #\\ out) (write-char c out)))
+                       (begin (write-char #\\ out) (write-char c out))
+                       ((define (loop-)
+                          (if (memv (peek-char in) '(#\space #\tab))
+                              (begin (take-char in) (loop-))))))
                    (loop #f))
                   ((eqv? c #\\) (loop #t))
                   (else (write-char c out) (loop #f)))))
@@ -2210,13 +2218,14 @@
                   (if (eqv? (peek-char (take-char p)) delim)
                       (map-first strip-leading-newline
                                  (dedent-triplequoted-string
-                                   (parse-string-literal- 2 (take-char p) s delim raw)))
+                                   (strip-escaped-newline
+                                     (parse-string-literal- 2 (take-char p) s delim raw)
+                                     raw)))
                       (list ""))
-                  (parse-string-literal- 0 p s delim raw))))
-    (if raw str (unescape-parsed-string-literal
-                  (map (lambda (s)
-                         (if (string? s) (strip-escaped-newline s) s))
-                       str)))))
+                  (strip-escaped-newline
+                    (parse-string-literal- 0 p s delim raw)
+                    raw))))
+    (if raw str (unescape-parsed-string-literal str))))
 
 (define (strip-leading-newline s)
   (let ((n (sizeof s)))
diff --git a/test/syntax.jl b/test/syntax.jl
index 9ef8c033c14ad..707437096ef14 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -2837,7 +2837,7 @@ end
     @test "a\
 b" == "ab"
     @test "a\
-    b" == "a    b"
+    b" == "ab"
     @test raw"a\
 b" == "a\\\nb"
     @test "a$c\
@@ -2851,10 +2851,10 @@ b" == "acb"
           b""" == "ab"
     @test """
           a\
-            b""" == "a  b"
+            b""" == "ab"
     @test """
             a\
-          b""" == "  ab"
+          b""" == "ab"
     @test raw"""
           a\
           b""" == "a\\\nb"
@@ -2894,7 +2894,7 @@ b" == "acb"
     @test `a\
 b` == `ab`
     @test `a\
-    b` == `a    b`
+    b` == `ab`
     @test `a$c\
 b` == `acb`
     @test `"a\
@@ -2910,7 +2910,7 @@ b'` == `$("a\\\nb")`
           b``` == `ab`
     @test ```
           a\
-            b``` == `a  b`
+            b``` == `ab`
     @test ```
             a\
           b``` == `  ab`

From 921b3a3851194a46dd03e9765f166dfc64a89a33 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 29 Jun 2021 18:37:40 -0400
Subject: [PATCH 21/44] fix #41346, update Random docs for Xoshiro256++
 (#41353)

(cherry picked from commit 7c566b1564cc9ee8cc7060329147b444f5113de1)
---
 doc/src/manual/documentation.md |  3 +--
 stdlib/Random/docs/src/index.md | 32 ++++++++++++++++++--------------
 2 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/doc/src/manual/documentation.md b/doc/src/manual/documentation.md
index 8c68e409b7b5b..7089672ec27b1 100644
--- a/doc/src/manual/documentation.md
+++ b/doc/src/manual/documentation.md
@@ -128,8 +128,7 @@ As in the example above, we recommend following some simple conventions when wri
        Calling `rand` and other RNG-related functions should be avoided in doctests since they will not
        produce consistent outputs during different Julia sessions. If you would like to show some random
        number generation related functionality, one option is to explicitly construct and seed your own
-       [`MersenneTwister`](@ref) (or other pseudorandom number generator) and pass it to the functions you are
-       doctesting.
+       RNG object (see [`Random`](@ref Random-Numbers)) and pass it to the functions you are doctesting.
 
        Operating system word size ([`Int32`](@ref) or [`Int64`](@ref)) as well as path separator differences
        (`/` or `\`) will also affect the reproducibility of some doctests.
diff --git a/stdlib/Random/docs/src/index.md b/stdlib/Random/docs/src/index.md
index facb18bbdd8d5..f5508781ef27b 100644
--- a/stdlib/Random/docs/src/index.md
+++ b/stdlib/Random/docs/src/index.md
@@ -4,20 +4,22 @@
 DocTestSetup = :(using Random)
 ```
 
-Random number generation in Julia uses the [Mersenne Twister library](http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/#dSFMT)
-via `MersenneTwister` objects. Julia has a global RNG, which is used by default. Other RNG types
-can be plugged in by inheriting the `AbstractRNG` type; they can then be used to have multiple
-streams of random numbers. Besides `MersenneTwister`, Julia also provides the `RandomDevice` RNG
-type, which is a wrapper over the OS provided entropy.
-
-Most functions related to random generation accept an optional `AbstractRNG` object as first argument,
-which defaults to the global one if not provided. Moreover, some of them accept optionally
-dimension specifications `dims...` (which can be given as a tuple) to generate arrays of random
-values.  In a multi-threaded program, you should generally use different RNG objects from different threads
-in order to be thread-safe. However, the default global RNG is thread-safe as of Julia 1.3 (because
-it internally corresponds to a per-thread RNG).
-
-A `MersenneTwister` or `RandomDevice` RNG can generate uniformly random numbers of the following types:
+Random number generation in Julia uses the [Xoshiro256++](https://prng.di.unimi.it/) algorithm
+by default, with per-`Task` state.
+Other RNG types can be plugged in by inheriting the `AbstractRNG` type; they can then be used to
+obtain multiple streams of random numbers.
+Besides the default `TaskLocalRNG` type, the `Random` package also provides `MersenneTwister`,
+`RandomDevice` (which exposes OS-provided entropy), and `Xoshiro` (for explicitly-managed
+Xoshiro256++ streams).
+
+Most functions related to random generation accept an optional `AbstractRNG` object as first argument.
+Some also accept dimension specifications `dims...` (which can also be given as a tuple) to generate
+arrays of random values.
+In a multi-threaded program, you should generally use different RNG objects from different threads
+or tasks in order to be thread-safe. However, the default RNG is thread-safe as of Julia 1.3
+(using a per-thread RNG up to version 1.6, and per-task thereafter).
+
+The provided RNGs can generate uniform random numbers of the following types:
 [`Float16`](@ref), [`Float32`](@ref), [`Float64`](@ref), [`BigFloat`](@ref), [`Bool`](@ref),
 [`Int8`](@ref), [`UInt8`](@ref), [`Int16`](@ref), [`UInt16`](@ref), [`Int32`](@ref),
 [`UInt32`](@ref), [`Int64`](@ref), [`UInt64`](@ref), [`Int128`](@ref), [`UInt128`](@ref),
@@ -67,6 +69,8 @@ Random.shuffle!
 ```@docs
 Random.seed!
 Random.AbstractRNG
+Random.TaskLocalRNG
+Random.Xoshiro
 Random.MersenneTwister
 Random.RandomDevice
 ```

From b57ea7694c00fb210e0e24539cb601023f6034ab Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 30 Jun 2021 10:34:40 +0900
Subject: [PATCH 22/44] inference: enable constant propagation for `invoke`d
 calls, fixes #41024 (#41383)

* inference: enable constant propagation for `invoke`d calls, fixes #41024

Especially useful for defining mixins with typed interface fields, e.g.
```julia
abstract type AbstractInterface end # mixin, which expects common field `x::Int`
function Base.getproperty(x::AbstractInterface, sym::Symbol)
    if sym === :x
        return getfield(x, sym)::Int # inferred field
    else
        return getfield(x, sym)      # fallback
    end
end

abstract type AbstractInterfaceExtended <: AbstractInterface end # extended mixin, which expects additional common field `y::Rational{Int}`
function Base.getproperty(x::AbstractInterfaceExtended, sym::Symbol)
    if sym === :y
        return getfield(x, sym)::Rational{Int}
    end
    return Base.@invoke getproperty(x::AbstractInterface, sym::Symbol)
end
```

As a bonus, inliner is able to use `InferenceResult` as a fast inlining
pass for constant-prop'ed `invoke`s

* improve compile-time latency

* Update base/compiler/abstractinterpretation.jl

* Update base/compiler/abstractinterpretation.jl

(cherry picked from commit bc6da9353cb25f0d975c8ebe6e56a9047fc1a104)
---
 base/compiler/abstractinterpretation.jl | 51 ++++++++++++++++++-------
 base/compiler/ssair/inlining.jl         | 16 ++++++--
 base/compiler/stmtinfo.jl               |  1 +
 test/compiler/inference.jl              | 40 +++++++++++++++++++
 4 files changed, 91 insertions(+), 17 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 7c804c80ae262..0de1f45460be0 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1127,7 +1127,8 @@ function abstract_call_unionall(argtypes::Vector{Any})
 end
 
 function abstract_invoke(interp::AbstractInterpreter, argtypes::Vector{Any}, sv::InferenceState)
-    ft = widenconst(argtype_by_index(argtypes, 2))
+    ft′ = argtype_by_index(argtypes, 2)
+    ft = widenconst(ft′)
     ft === Bottom && return CallMeta(Bottom, false)
     (types, isexact, isconcrete, istype) = instanceof_tfunc(argtype_by_index(argtypes, 3))
     types === Bottom && return CallMeta(Bottom, false)
@@ -1141,15 +1142,30 @@ function abstract_invoke(interp::AbstractInterpreter, argtypes::Vector{Any}, sv:
     nargtype = Tuple{ft, nargtype.parameters...}
     argtype = Tuple{ft, argtype.parameters...}
     result = findsup(types, method_table(interp))
-    if result === nothing
-        return CallMeta(Any, false)
-    end
+    result === nothing && return CallMeta(Any, false)
     method, valid_worlds = result
     update_valid_age!(sv, valid_worlds)
     (ti, env::SimpleVector) = ccall(:jl_type_intersection_with_env, Any, (Any, Any), nargtype, method.sig)::SimpleVector
-    rt, edge = typeinf_edge(interp, method, ti, env, sv)
+    (; rt, edge) = result = abstract_call_method(interp, method, ti, env, false, sv)
     edge !== nothing && add_backedge!(edge::MethodInstance, sv)
-    return CallMeta(rt, InvokeCallInfo(MethodMatch(ti, env, method, argtype <: method.sig)))
+    match = MethodMatch(ti, env, method, argtype <: method.sig)
+    # try constant propagation with manual inlinings of some of the heuristics
+    # since some checks within `abstract_call_method_with_const_args` seem a bit costly
+    const_prop_entry_heuristic(interp, result, sv) || return CallMeta(rt, InvokeCallInfo(match, nothing))
+    argtypes′ = argtypes[4:end]
+    const_prop_argument_heuristic(interp, argtypes′) || const_prop_rettype_heuristic(interp, rt) || return CallMeta(rt, InvokeCallInfo(match, nothing))
+    pushfirst!(argtypes′, ft)
+    # # typeintersect might have narrowed signature, but the accuracy gain doesn't seem worth the cost involved with the lattice comparisons
+    # for i in 1:length(argtypes′)
+    #     t, a = ti.parameters[i], argtypes′[i]
+    #     argtypes′[i] = t ⊑ a ? t : a
+    # end
+    const_rt, const_result = abstract_call_method_with_const_args(interp, result, argtype_to_function(ft′), argtypes′, match, sv, false)
+    if const_rt !== rt && const_rt ⊑ rt
+        return CallMeta(const_rt, InvokeCallInfo(match, const_result))
+    else
+        return CallMeta(rt, InvokeCallInfo(match, nothing))
+    end
 end
 
 # call where the function is known exactly
@@ -1283,17 +1299,12 @@ function abstract_call(interp::AbstractInterpreter, fargs::Union{Nothing,Vector{
                        sv::InferenceState, max_methods::Int = InferenceParams(interp).MAX_METHODS)
     #print("call ", e.args[1], argtypes, "\n\n")
     ft = argtypes[1]
-    if isa(ft, Const)
-        f = ft.val
-    elseif isconstType(ft)
-        f = ft.parameters[1]
-    elseif isa(ft, DataType) && isdefined(ft, :instance)
-        f = ft.instance
-    elseif isa(ft, PartialOpaque)
+    f = argtype_to_function(ft)
+    if isa(ft, PartialOpaque)
         return abstract_call_opaque_closure(interp, ft, argtypes[2:end], sv)
     elseif isa(unwrap_unionall(ft), DataType) && unwrap_unionall(ft).name === typename(Core.OpaqueClosure)
         return CallMeta(rewrap_unionall(unwrap_unionall(ft).parameters[2], ft), false)
-    else
+    elseif f === nothing
         # non-constant function, but the number of arguments is known
         # and the ft is not a Builtin or IntrinsicFunction
         if typeintersect(widenconst(ft), Union{Builtin, Core.OpaqueClosure}) != Union{}
@@ -1305,6 +1316,18 @@ function abstract_call(interp::AbstractInterpreter, fargs::Union{Nothing,Vector{
     return abstract_call_known(interp, f, fargs, argtypes, sv, max_methods)
 end
 
+function argtype_to_function(@nospecialize(ft))
+    if isa(ft, Const)
+        return ft.val
+    elseif isconstType(ft)
+        return ft.parameters[1]
+    elseif isa(ft, DataType) && isdefined(ft, :instance)
+        return ft.instance
+    else
+        return nothing
+    end
+end
+
 function sp_type_rewrap(@nospecialize(T), linfo::MethodInstance, isreturn::Bool)
     isref = false
     if T === Bottom
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 0420d137da69e..b54beb2c8e8d9 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1049,12 +1049,12 @@ is_builtin(s::Signature) =
     isa(s.f, Builtin) ||
     s.ft ⊑ Builtin
 
-function inline_invoke!(ir::IRCode, idx::Int, sig::Signature, info::InvokeCallInfo,
+function inline_invoke!(ir::IRCode, idx::Int, sig::Signature, (; match, result)::InvokeCallInfo,
         state::InliningState, todo::Vector{Pair{Int, Any}})
     stmt = ir.stmts[idx][:inst]
     calltype = ir.stmts[idx][:type]
 
-    if !info.match.fully_covers
+    if !match.fully_covers
         # TODO: We could union split out the signature check and continue on
         return nothing
     end
@@ -1064,7 +1064,17 @@ function inline_invoke!(ir::IRCode, idx::Int, sig::Signature, info::InvokeCallIn
     atypes = atypes[4:end]
     pushfirst!(atypes, atype0)
 
-    result = analyze_method!(info.match, atypes, state, calltype)
+    if isa(result, InferenceResult)
+        item = InliningTodo(result, atypes, calltype)
+        validate_sparams(item.mi.sparam_vals) || return nothing
+        if argtypes_to_type(atypes) <: item.mi.def.sig
+            state.mi_cache !== nothing && (item = resolve_todo(item, state))
+            handle_single_case!(ir, stmt, idx, item, true, todo)
+            return nothing
+        end
+    end
+
+    result = analyze_method!(match, atypes, state, calltype)
     handle_single_case!(ir, stmt, idx, result, true, todo)
     return nothing
 end
diff --git a/base/compiler/stmtinfo.jl b/base/compiler/stmtinfo.jl
index ad7e8886b6cce..a6ffee299c4f5 100644
--- a/base/compiler/stmtinfo.jl
+++ b/base/compiler/stmtinfo.jl
@@ -108,6 +108,7 @@ method being processed.
 """
 struct InvokeCallInfo
     match::MethodMatch
+    result::Union{Nothing,InferenceResult}
 end
 
 struct OpaqueClosureCallInfo
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index d5bad34e38322..008e6ff0d6997 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -3355,3 +3355,43 @@ let
         Expr(:opaque_closure_method, nothing, 2, LineNumberNode(0, nothing), ci)))(true, 1.0)
     @test Base.return_types(oc, Tuple{}) == Any[Float64]
 end
+
+@testset "constant prop' on `invoke` calls" begin
+    m = Module()
+
+    # simple cases
+    @eval m begin
+        f(a::Any,    sym::Bool) = sym ? Any : :any
+        f(a::Number, sym::Bool) = sym ? Number : :number
+    end
+    @test (@eval m Base.return_types((Any,)) do a
+        Base.@invoke f(a::Any, true::Bool)
+    end) == Any[Type{Any}]
+    @test (@eval m Base.return_types((Any,)) do a
+        Base.@invoke f(a::Number, true::Bool)
+    end) == Any[Type{Number}]
+    @test (@eval m Base.return_types((Any,)) do a
+        Base.@invoke f(a::Any, false::Bool)
+    end) == Any[Symbol]
+    @test (@eval m Base.return_types((Any,)) do a
+        Base.@invoke f(a::Number, false::Bool)
+    end) == Any[Symbol]
+
+    # https://github.com/JuliaLang/julia/issues/41024
+    @eval m begin
+        # mixin, which expects common field `x::Int`
+        abstract type AbstractInterface end
+        Base.getproperty(x::AbstractInterface, sym::Symbol) =
+            sym === :x ? getfield(x, sym)::Int :
+            return getfield(x, sym) # fallback
+
+        # extended mixin, which expects additional field `y::Rational{Int}`
+        abstract type AbstractInterfaceExtended <: AbstractInterface end
+        Base.getproperty(x::AbstractInterfaceExtended, sym::Symbol) =
+            sym === :y ? getfield(x, sym)::Rational{Int} :
+            return Base.@invoke getproperty(x::AbstractInterface, sym::Symbol)
+    end
+    @test (@eval m Base.return_types((AbstractInterfaceExtended,)) do x
+        x.x
+    end) == Any[Int]
+end

From 7846aeb3ed2ac3a0be6808fbfb291c166a0df2d3 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 29 Jun 2021 22:29:30 -0400
Subject: [PATCH 23/44] fix excess array object alignment (#41287)

(cherry picked from commit 61572a6c0e7b0282b23ac485aed915ac7b4e7c86)
---
 src/array.c          | 21 ++++++++++++---------
 src/julia_internal.h |  1 +
 src/options.h        |  8 ++++++--
 src/staticdata.c     | 45 ++++++++++++++++++++++++++++----------------
 test/arrayops.jl     |  2 +-
 test/cmdlineargs.jl  | 12 ++++++++++--
 6 files changed, 59 insertions(+), 30 deletions(-)

diff --git a/src/array.c b/src/array.c
index d8ecf73c8dadf..258b80948bf28 100644
--- a/src/array.c
+++ b/src/array.c
@@ -114,20 +114,23 @@ static jl_array_t *_new_array_(jl_value_t *atype, uint32_t ndims, size_t *dims,
     }
 
     int ndimwords = jl_array_ndimwords(ndims);
-    int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
+    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
     if (tot <= ARRAY_INLINE_NBYTES) {
-        if (isunboxed && elsz >= 4)
-            tsz = JL_ARRAY_ALIGN(tsz, JL_SMALL_BYTE_ALIGNMENT); // align data area
+        // align data area
+        if (tot >= ARRAY_CACHE_ALIGN_THRESHOLD)
+            tsz = JL_ARRAY_ALIGN(tsz, JL_CACHE_BYTE_ALIGNMENT);
+        else if (isunboxed && elsz >= 4)
+            tsz = JL_ARRAY_ALIGN(tsz, JL_SMALL_BYTE_ALIGNMENT);
         size_t doffs = tsz;
         tsz += tot;
-        tsz = JL_ARRAY_ALIGN(tsz, JL_SMALL_BYTE_ALIGNMENT); // align whole object
+        // jl_array_t is large enough that objects will always be aligned 16
         a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, atype);
+        assert(((size_t)a & 15) == 0);
         // No allocation or safepoint allowed after this
         a->flags.how = 0;
         data = (char*)a + doffs;
     }
     else {
-        tsz = JL_ARRAY_ALIGN(tsz, JL_CACHE_BYTE_ALIGNMENT); // align whole object
         data = jl_gc_managed_malloc(tot);
         // Allocate the Array **after** allocating the data
         // to make sure the array is still young
@@ -223,7 +226,7 @@ JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
     assert(jl_types_equal(jl_tparam0(jl_typeof(data)), jl_tparam0(atype)));
 
     int ndimwords = jl_array_ndimwords(ndims);
-    int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords * sizeof(size_t) + sizeof(void*), JL_SMALL_BYTE_ALIGNMENT);
+    int tsz = sizeof(jl_array_t) + ndimwords * sizeof(size_t) + sizeof(void*);
     a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, atype);
     // No allocation or safepoint allowed after this
     a->flags.pooled = tsz <= GC_MAX_SZCLASS;
@@ -304,7 +307,7 @@ JL_DLLEXPORT jl_array_t *jl_string_to_array(jl_value_t *str)
     jl_array_t *a;
 
     int ndimwords = jl_array_ndimwords(1);
-    int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t) + sizeof(void*), JL_SMALL_BYTE_ALIGNMENT);
+    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t) + sizeof(void*);
     a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, jl_array_uint8_type);
     a->flags.pooled = tsz <= GC_MAX_SZCLASS;
     a->flags.ndims = 1;
@@ -351,7 +354,7 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
                       "unsafe_wrap: pointer %p is not properly aligned to %u bytes", data, align);
 
     int ndimwords = jl_array_ndimwords(1);
-    int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
+    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
     a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, atype);
     // No allocation or safepoint allowed after this
     a->flags.pooled = tsz <= GC_MAX_SZCLASS;
@@ -418,7 +421,7 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
                       "unsafe_wrap: pointer %p is not properly aligned to %u bytes", data, align);
 
     int ndimwords = jl_array_ndimwords(ndims);
-    int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
+    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
     a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, atype);
     // No allocation or safepoint allowed after this
     a->flags.pooled = tsz <= GC_MAX_SZCLASS;
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 2f14e3ad6832b..e6bb2ae8602d3 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -323,6 +323,7 @@ STATIC_INLINE uint8_t JL_CONST_FUNC jl_gc_szclass(unsigned sz)
 // JL_HEAP_ALIGNMENT is the maximum alignment that the GC can provide
 #define JL_HEAP_ALIGNMENT JL_SMALL_BYTE_ALIGNMENT
 #define GC_MAX_SZCLASS (2032-sizeof(void*))
+static_assert(ARRAY_CACHE_ALIGN_THRESHOLD > GC_MAX_SZCLASS, "");
 
 STATIC_INLINE jl_value_t *jl_gc_alloc_(jl_ptls_t ptls, size_t sz, void *ty)
 {
diff --git a/src/options.h b/src/options.h
index 5ea220900b5eb..bb56e0c41c7c0 100644
--- a/src/options.h
+++ b/src/options.h
@@ -12,10 +12,14 @@
 
 // object layout options ------------------------------------------------------
 
-// how much space we're willing to waste if an array outgrows its
-// original object
+// The data for an array this size or below will be allocated within the
+// Array object. If the array outgrows that space, it will be wasted.
 #define ARRAY_INLINE_NBYTES (2048*sizeof(void*))
 
+// Arrays at least this size will get larger alignment (JL_CACHE_BYTE_ALIGNMENT).
+// Must be bigger than GC_MAX_SZCLASS.
+#define ARRAY_CACHE_ALIGN_THRESHOLD 2048
+
 // codegen options ------------------------------------------------------------
 
 // (Experimental) Use MCJIT ELF, even where it's not the native format
diff --git a/src/staticdata.c b/src/staticdata.c
index 2425e8bc44450..d70e35542de2a 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -782,14 +782,23 @@ static void jl_write_values(jl_serializer_state *s)
 #define JL_ARRAY_ALIGN(jl_value, nbytes) LLT_ALIGN(jl_value, nbytes)
             jl_array_t *ar = (jl_array_t*)v;
             jl_value_t *et = jl_tparam0(jl_typeof(v));
+            size_t alen = jl_array_len(ar);
+            size_t datasize = alen * ar->elsize;
+            size_t tot = datasize;
+            int isbitsunion = jl_array_isbitsunion(ar);
+            if (isbitsunion)
+                tot += alen;
+            else if (ar->elsize == 1)
+                tot += 1;
             int ndimwords = jl_array_ndimwords(ar->flags.ndims);
-            size_t tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords * sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
+            size_t headersize = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
             // copy header
-            ios_write(s->s, (char*)v, tsz);
+            ios_write(s->s, (char*)v, headersize);
+            size_t alignment_amt = JL_SMALL_BYTE_ALIGNMENT;
+            if (tot >= ARRAY_CACHE_ALIGN_THRESHOLD)
+                alignment_amt = JL_CACHE_BYTE_ALIGNMENT;
             // make some header modifications in-place
             jl_array_t *newa = (jl_array_t*)&s->s->buf[reloc_offset];
-            size_t alen = jl_array_len(ar);
-            size_t tot = alen * ar->elsize;
             if (newa->flags.ndims == 1)
                 newa->maxsize = alen;
             newa->offset = 0;
@@ -799,8 +808,7 @@ static void jl_write_values(jl_serializer_state *s)
 
             // write data
             if (!ar->flags.ptrarray && !ar->flags.hasptr) {
-                uintptr_t data = LLT_ALIGN(ios_pos(s->const_data), 16);
-                // realign stream to max(data-align(array), sizeof(void*))
+                uintptr_t data = LLT_ALIGN(ios_pos(s->const_data), alignment_amt);
                 write_padding(s->const_data, data - ios_pos(s->const_data));
                 // write data and relocations
                 newa->data = NULL; // relocation offset
@@ -815,22 +823,27 @@ static void jl_write_values(jl_serializer_state *s)
                         write_pointer(s->const_data);
                 }
                 else {
-                    int isbitsunion = jl_array_isbitsunion(ar);
-                    if (ar->elsize == 1 && !isbitsunion)
-                        tot += 1;
-                    ios_write(s->const_data, (char*)jl_array_data(ar), tot);
-                    if (isbitsunion)
+                    if (isbitsunion) {
+                        ios_write(s->const_data, (char*)jl_array_data(ar), datasize);
                         ios_write(s->const_data, jl_array_typetagdata(ar), alen);
+                    }
+                    else {
+                        ios_write(s->const_data, (char*)jl_array_data(ar), tot);
+                    }
                 }
             }
             else {
-                newa->data = (void*)tsz; // relocation offset
+                size_t data = LLT_ALIGN(ios_pos(s->s), alignment_amt);
+                size_t padding_amt = data - ios_pos(s->s);
+                write_padding(s->s, padding_amt);
+                headersize += padding_amt;
+                newa->data = (void*)headersize; // relocation offset
                 arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_array_t, data))); // relocation location
                 arraylist_push(&s->relocs_list, (void*)(((uintptr_t)DataRef << RELOC_TAG_OFFSET) + item)); // relocation target
                 if (ar->flags.hasptr) {
                     // copy all of the data first
                     const char *data = (const char*)jl_array_data(ar);
-                    ios_write(s->s, data, tot);
+                    ios_write(s->s, data, datasize);
                     // the rewrite all of the embedded pointers to null+relocation
                     uint16_t elsz = ar->elsize;
                     size_t j, np = ((jl_datatype_t*)et)->layout->npointers;
@@ -840,12 +853,12 @@ static void jl_write_values(jl_serializer_state *s)
                             size_t offset = i * elsz + jl_ptr_offset(((jl_datatype_t*)et), j) * sizeof(jl_value_t*);
                             jl_value_t *fld = *(jl_value_t**)&data[offset];
                             if (fld != NULL) {
-                                arraylist_push(&s->relocs_list, (void*)(uintptr_t)(reloc_offset + tsz + offset)); // relocation location
+                                arraylist_push(&s->relocs_list, (void*)(uintptr_t)(reloc_offset + headersize + offset)); // relocation location
                                 arraylist_push(&s->relocs_list, (void*)backref_id(s, fld)); // relocation target
-                                memset(&s->s->buf[reloc_offset + tsz + offset], 0, sizeof(fld)); // relocation offset (none)
+                                memset(&s->s->buf[reloc_offset + headersize + offset], 0, sizeof(fld)); // relocation offset (none)
                             }
                             else {
-                                assert(*(jl_value_t**)&s->s->buf[reloc_offset + tsz + offset] == NULL);
+                                assert(*(jl_value_t**)&s->s->buf[reloc_offset + headersize + offset] == NULL);
                             }
                         }
                     }
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 27e366f1ce3cc..7823fce7a6175 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -2660,7 +2660,7 @@ let TT = Union{UInt8, Int8}
     resize!(b, 1)
     @assert pointer(a) == pa
     @assert pointer(b) == pb
-    unsafe_store!(pa, 0x1, 2) # reset a[2] to 1
+    unsafe_store!(Ptr{UInt8}(pa), 0x1, 2) # reset a[2] to 1
     @test length(a) == length(b) == 1
     @test a[1] == b[1] == 0x0
     @test a == b
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 13e7251ba3a95..fbf60acdbc848 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -324,7 +324,11 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         rm(memfile)
         @test popfirst!(got) == "        0 g(x) = x + 123456"
         @test popfirst!(got) == "        - function f(x)"
-        @test popfirst!(got) == "       80     []"
+        if Sys.WORD_SIZE == 64
+            @test popfirst!(got) == "       48     []"
+        else
+            @test popfirst!(got) == "       32     []"
+        end
         if Sys.WORD_SIZE == 64
             # P64 pools with 64 bit tags
             @test popfirst!(got) == "       16     Base.invokelatest(g, 0)"
@@ -337,7 +341,11 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
             @test popfirst!(got) == "        8     Base.invokelatest(g, 0)"
             @test popfirst!(got) == "       32     Base.invokelatest(g, x)"
         end
-        @test popfirst!(got) == "       80     []"
+        if Sys.WORD_SIZE == 64
+            @test popfirst!(got) == "       48     []"
+        else
+            @test popfirst!(got) == "       32     []"
+        end
         @test popfirst!(got) == "        - end"
         @test popfirst!(got) == "        - f(1.23)"
         @test isempty(got) || got

From fd2d0c9addcd7e2c92ed57e035f935401cff07a2 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Wed, 30 Jun 2021 04:43:55 +0200
Subject: [PATCH 24/44] [Tasks] Mark parent as sticky if we use `@async`
 (#41334)

Fixes #41324 for 1.7

(cherry picked from commit 75858d73322e29a665bd06947c20dc2b9d996f9f)
---
 base/task.jl         |  6 ++++++
 test/threads_exec.jl | 13 +++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/base/task.jl b/base/task.jl
index 1ed68f70f7ab7..bfb105accef14 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -621,6 +621,12 @@ function enq_work(t::Task)
     # 3. The multiq is full (can be fixed by making it growable).
     if t.sticky || Threads.nthreads() == 1
         if tid == 0
+            # Issue #41324
+            # t.sticky && tid == 0 is a task that needs to be co-scheduled with
+            # the parent task. If the parent (current_task) is not sticky we must
+            # set it to be sticky.
+            # XXX: Ideally we would be able to unset this
+            current_task().sticky = true
             tid = Threads.threadid()
             ccall(:jl_set_task_tid, Cvoid, (Any, Cint), t, tid-1)
         end
diff --git a/test/threads_exec.jl b/test/threads_exec.jl
index b7e4c37631d83..f3d2dc9577c64 100644
--- a/test/threads_exec.jl
+++ b/test/threads_exec.jl
@@ -840,6 +840,19 @@ fib34666(x) =
     end
 @test fib34666(25) == 75025
 
+# issue #41324
+@testset "Co-schedule" begin
+    parent = Threads.@spawn begin
+        @test current_task().sticky == false
+        child = @async begin end
+        @test current_task().sticky == true
+        @test Threads.threadid() == Threads.threadid(child)
+        wait(child)
+    end
+    wait(parent)
+    @test parent.sticky == true
+end
+
 function jitter_channel(f, k, delay, ntasks, schedule)
     x = Channel(ch -> foreach(i -> put!(ch, i), 1:k), 1)
     y = Channel(k) do ch

From d49c6f2fcafa23685327176ec147186acf73c61b Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 29 Jun 2021 23:53:31 -0400
Subject: [PATCH 25/44] fix #41347, better checks for `yield` and `yieldto`
 with finished tasks (#41410)

(cherry picked from commit e2d5f52a01f10dd1062940b61a26d21ebc5ca01c)
---
 base/task.jl |  8 ++++++++
 src/task.c   |  8 ++------
 test/misc.jl | 11 +++++++++++
 3 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/base/task.jl b/base/task.jl
index bfb105accef14..e84c344c28d17 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -721,6 +721,7 @@ A fast, unfair-scheduling version of `schedule(t, arg); yield()` which
 immediately yields to `t` before calling the scheduler.
 """
 function yield(t::Task, @nospecialize(x=nothing))
+    (t._state === task_state_runnable && t.queue === nothing) || error("yield: Task not runnable")
     t.result = x
     enq_work(current_task())
     set_next_task(t)
@@ -736,6 +737,13 @@ call to `yieldto`. This is a low-level call that only switches tasks, not consid
 or scheduling in any way. Its use is discouraged.
 """
 function yieldto(t::Task, @nospecialize(x=nothing))
+    # TODO: these are legacy behaviors; these should perhaps be a scheduler
+    # state error instead.
+    if t._state === task_state_done
+        return x
+    elseif t._state === task_state_failed
+        throw(t.result)
+    end
     t.result = x
     set_next_task(t)
     return try_yieldto(identity)
diff --git a/src/task.c b/src/task.c
index be08deca63fc1..1acdb4d4e9794 100644
--- a/src/task.c
+++ b/src/task.c
@@ -475,12 +475,8 @@ JL_DLLEXPORT void jl_switch(void)
     if (t == ct) {
         return;
     }
-    if (t->_state != JL_TASK_STATE_RUNNABLE || (t->started && t->stkbuf == NULL)) {
-        ct->_isexception = t->_isexception;
-        ct->result = t->result;
-        jl_gc_wb(ct, ct->result);
-        return;
-    }
+    if (t->started && t->stkbuf == NULL)
+        jl_error("attempt to switch to exited task");
     if (ptls->in_finalizer)
         jl_error("task switch not allowed from inside gc finalizer");
     if (ptls->in_pure_callback)
diff --git a/test/misc.jl b/test/misc.jl
index 2305b78250ef2..37c5397b4948f 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -182,6 +182,17 @@ end
 
 @test_throws ErrorException("deadlock detected: cannot wait on current task") wait(current_task())
 
+# issue #41347
+let t = @async 1
+    wait(t)
+    @test_throws ErrorException yield(t)
+end
+
+let t = @async error(42)
+    Base._wait(t)
+    @test_throws ErrorException("42") yieldto(t)
+end
+
 # test that @sync is lexical (PR #27164)
 
 const x27164 = Ref(0)

From b4c34141e30faf77c3815b30289105be8451462c Mon Sep 17 00:00:00 2001
From: Rashid Rafeek <rashidrafeek@gmail.com>
Date: Wed, 30 Jun 2021 13:48:36 +0530
Subject: [PATCH 26/44] Added `edit(::Method)`, fixes #41408 (#41414)

(cherry picked from commit 71bf60858ee2dcf219f6de568f712a0ab3756549)
---
 stdlib/InteractiveUtils/src/editless.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stdlib/InteractiveUtils/src/editless.jl b/stdlib/InteractiveUtils/src/editless.jl
index cc3de27e9a4d9..7a96323c9cdeb 100644
--- a/stdlib/InteractiveUtils/src/editless.jl
+++ b/stdlib/InteractiveUtils/src/editless.jl
@@ -229,6 +229,7 @@ function edit(@nospecialize f)
     length(ms) == 0 && functionloc(f) # throws
     nothing
 end
+edit(m::Method) = edit(functionloc(m)...)
 edit(@nospecialize(f), idx::Integer) = edit(methods(f).ms[idx])
 edit(f, t)  = (@nospecialize; edit(functionloc(f, t)...))
 edit(file::Nothing, line::Integer) = error("could not find source file for function")

From 9bb1633e125ad61dc99569a3e1768e513204a545 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@alumni.harvard.edu>
Date: Thu, 24 Jun 2021 12:36:54 -0400
Subject: [PATCH 27/44] Fix #41299 - Dropped error case in :> special case
 inliner (#41315)

We have custom inference for :>, which prevents the :> method
itself from being inferred. As a result, it needs to be inlined
manually. However, this inlining was overeager and was dropping
an error check when the result was inferred to `Const`. Fix that
by verifying that the inlined <: call would have been nothrow.

(cherry picked from commit d0bbd4c931ba877022dd5fe7a35d0be214a926f4)
---
 base/compiler/ssair/inlining.jl | 2 +-
 test/compiler/inline.jl         | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index b54beb2c8e8d9..78edef88439e9 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1420,7 +1420,7 @@ function late_inline_special_case!(ir::IRCode, sig::Signature, idx::Int, stmt::E
     elseif params.inlining && length(atypes) == 3 && istopfunction(f, :(>:))
         # special-case inliner for issupertype
         # that works, even though inference generally avoids inferring the `>:` Method
-        if isa(typ, Const)
+        if isa(typ, Const) && _builtin_nothrow(<:, Any[atypes[3], atypes[2]], typ)
             ir[SSAValue(idx)] = quoted(typ.val)
             return true
         end
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 1ffd012acb755..eb1c3ddd2a963 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -380,3 +380,7 @@ end
 using Base.Experimental: @opaque
 f_oc_getfield(x) = (@opaque ()->x)()
 @test fully_eliminated(f_oc_getfield, Tuple{Int})
+
+# Issue #41299 - inlining deletes error check in :>
+g41299(f::Tf, args::Vararg{Any,N}) where {Tf,N} = f(args...)
+@test_throws TypeError g41299(>:, 1, 2)

From d55c25bc99f48134a6c72034ccc141cb0ec906f5 Mon Sep 17 00:00:00 2001
From: Fredrik Ekre <ekrefredrik@gmail.com>
Date: Thu, 1 Jul 2021 13:31:04 +0200
Subject: [PATCH 28/44] Update Pkg for 1.7.0. (#41432)

---
 .../Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/md5     | 1 -
 .../Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/sha512  | 1 -
 .../Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/md5     | 1 +
 .../Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/sha512

diff --git a/deps/checksums/Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/md5 b/deps/checksums/Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/md5
deleted file mode 100644
index 35eda4f473f24..0000000000000
--- a/deps/checksums/Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-77b9bf19937476f9b2120dfbafc3322b
diff --git a/deps/checksums/Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/sha512 b/deps/checksums/Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/sha512
deleted file mode 100644
index 67ec25a15762a..0000000000000
--- a/deps/checksums/Pkg-81af75b902586919a858f06949b7c9e6121f1629.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-c9079f0c2b4d6ad34eca479f4db14041ac04f0780feaa1b16de552e55ca862f0d56c9a50437304639b96777a2c941c4b7a5eb0ce23071a456126a5c2da23c2e1
diff --git a/deps/checksums/Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/md5 b/deps/checksums/Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/md5
new file mode 100644
index 0000000000000..c44d4e836688b
--- /dev/null
+++ b/deps/checksums/Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/md5
@@ -0,0 +1 @@
+c848e464b9643d5396cd51ffe492f0b3
diff --git a/deps/checksums/Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/sha512 b/deps/checksums/Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/sha512
new file mode 100644
index 0000000000000..e5c06cafc4e8f
--- /dev/null
+++ b/deps/checksums/Pkg-df2476a01c01cdadd553dbf010b21fabe7e211d3.tar.gz/sha512
@@ -0,0 +1 @@
+4ceb13b64bf66ae50fb0ee87e3dc3e57a52dbdf68592226d36c8d37aaa6179d205de269073fc08be137430deb6c06c6cda65f3e0215f9a32854f1ea07be7ca26
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 1693797662604..937bae89a12d2 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,2 +1,2 @@
 PKG_BRANCH = release-1.7
-PKG_SHA1 = 81af75b902586919a858f06949b7c9e6121f1629
+PKG_SHA1 = df2476a01c01cdadd553dbf010b21fabe7e211d3

From ff5d62327497ae051904eeb08185c56d3592988f Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@alumni.harvard.edu>
Date: Wed, 23 Jun 2021 14:40:31 -0400
Subject: [PATCH 29/44] Export jl_get_pgcstack from libjulia (#41320)

The pgcstack symbol is special because embedders are supposed to
define it themselves in localexec tls, and then access it that way.
However, there is another case of of libraries that link against
julia, but are not embedders, but rather plugins to be loaded later
(e.g. CxxWrap). These do need access to the pgcstack, but do not
have a priori access to the localexec of the embedder. Thus,
re-export the `jl_get_pgcstack` function that provides access
to our internal getter for the pgcstack.

(cherry picked from commit e469a1e4da7e7356257107d174b63fb5206bee04)
---
 src/jl_exported_funcs.inc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 82611bfb50dfa..85c6e79ad27a8 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -540,4 +540,5 @@
     XX(jl_vprintf) \
     XX(jl_wakeup_thread) \
     XX(jl_yield) \
-    XX(jl_print_backtrace)
+    XX(jl_print_backtrace) \
+    XX(jl_get_pgcstack)

From a7a7e645609ce04454e54fa449dc711e98fc6a8b Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 29 Jun 2021 17:48:21 -0400
Subject: [PATCH 30/44] threads: move safepoint into loop

Fixes #41407

(cherry picked from commit a9412439c37fa6f68ab618fdcd67fa6d48668a74)
---
 src/partr.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/partr.c b/src/partr.c
index bfe1f29fa4d1b..c3de56b80cc92 100644
--- a/src/partr.c
+++ b/src/partr.c
@@ -159,6 +159,7 @@ static inline jl_task_t *multiq_deletemin(void)
     int16_t prio1, prio2;
     jl_task_t *task;
  retry:
+    jl_gc_safepoint();
     for (i = 0; i < heap_p; ++i) {
         rn1 = cong(heap_p, cong_unbias, &ptls->rngseed);
         rn2 = cong(heap_p, cong_unbias, &ptls->rngseed);
@@ -397,7 +398,6 @@ static jl_task_t *get_next_task(jl_value_t *trypoptask, jl_value_t *q)
         jl_set_task_tid(task, self);
         return task;
     }
-    jl_gc_safepoint();
     return multiq_deletemin();
 }
 

From 4c2294a5d441c2feb02b9072efec9b72520676af Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Wed, 30 Jun 2021 18:03:17 +0200
Subject: [PATCH 31/44] restrict getindex on `MethodList` to `Integer` (#41419)

(cherry picked from commit 47955e383549263d46baaf0e1b0d982dfdbad383)
---
 base/reflection.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/reflection.jl b/base/reflection.jl
index db1e2bb1caafd..29a4b5f4a66ca 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -925,7 +925,7 @@ mutable struct MethodList <: AbstractArray{Method,1}
 end
 
 size(m::MethodList) = size(m.ms)
-getindex(m::MethodList, i) = m.ms[i]
+getindex(m::MethodList, i::Integer) = m.ms[i]
 
 function MethodList(mt::Core.MethodTable)
     ms = Method[]

From 7b36b7162f40817d398b84d7bc3282c86308dc39 Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Wed, 30 Jun 2021 09:45:55 -0700
Subject: [PATCH 32/44] `dlopen()` our `libblas` and `liblapack` within
 `libjulia-internal` (#41412)

When loading our `libblas` and `liblapack` for the first time, we may
need to rely upon an `RPATH` that has been embedded within
`libjulia-internal`.  If we use `libblastrampoline` to perform the
actual `dlopen()`, however, we don't have that `RPATH` at hand.

To fix this, we instead `dlopen()` the library first, to force the
proper loading of the library (which loads the library and its `SONAME`
into our process), which allows `libblastrampoline`'s `dlopen()` to
immediately succeed, along the happy path of finding the library already
loaded.

(cherry picked from commit 97a62dd4f1e60185518fa9e3dc6a5b0b8e36710d)
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index eb8d22e55a1e8..d9466b3764fc2 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -526,8 +526,13 @@ function __init__()
     try
         libblas_path = find_library_path(Base.libblas_name)
         liblapack_path = find_library_path(Base.liblapack_name)
+        # We manually `dlopen()` these libraries here, so that we search with `libjulia-internal`'s
+        # `RPATH` and not `libblastrampoline's`.  Once it's been opened, when LBT tries to open it,
+        # it will find the library already loaded.
+        libblas_path = Libdl.dlpath(Libdl.dlopen(libblas_path))
         BLAS.lbt_forward(libblas_path; clear=true)
         if liblapack_path != libblas_path
+            liblapack_path = Libdl.dlpath(Libdl.dlopen(liblapack_path))
             BLAS.lbt_forward(liblapack_path)
         end
         BLAS.check()

From be4f2c928c63a0268c4f8c40a6441e0e425775f3 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <v.churavy@gmail.com>
Date: Wed, 30 Jun 2021 23:14:32 +0200
Subject: [PATCH 33/44] Remove the LLVMExtra api

(cherry picked from commit 286f024f4aa70e3f284b6adbb0db935b54d6021c)
---
 src/Makefile     |   2 +-
 src/llvm-api.cpp | 291 -----------------------------------------------
 2 files changed, 1 insertion(+), 292 deletions(-)
 delete mode 100644 src/llvm-api.cpp

diff --git a/src/Makefile b/src/Makefile
index 15543ff11b8e9..bb38a848ab12f 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -55,7 +55,7 @@ SRCS += codegen llvm-ptls
 RUNTIME_SRCS += jitlayers aotcompile debuginfo disasm llvm-simdloop llvm-muladd \
 	llvm-final-gc-lowering llvm-pass-helpers llvm-late-gc-lowering \
 	llvm-lower-handlers llvm-gc-invariant-verifier llvm-propagate-addrspaces \
-	llvm-multiversioning llvm-alloc-opt cgmemmgr llvm-api llvm-remove-addrspaces \
+	llvm-multiversioning llvm-alloc-opt cgmemmgr llvm-remove-addrspaces \
 	llvm-remove-ni llvm-julia-licm llvm-demote-float16
 FLAGS += -I$(shell $(LLVM_CONFIG_HOST) --includedir)
 LLVM_LIBS := all
diff --git a/src/llvm-api.cpp b/src/llvm-api.cpp
deleted file mode 100644
index 56ec131556f98..0000000000000
--- a/src/llvm-api.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-// This file is a part of Julia. License is MIT: https://julialang.org/license
-
-// Extensions of the LLVM C API for LLVM.jl
-//
-// These are part of the Julia repository as they need to be
-// built with the same C++ toolchain Julia & LLVM are built with
-//
-// They are not to be considered a stable API, and will be removed
-// when better package build systems are available
-
-#include "llvm-version.h"
-#include <llvm-c/Core.h>
-#include <llvm-c/Types.h>
-
-#include <llvm/ADT/Triple.h>
-#include <llvm/Analysis/TargetLibraryInfo.h>
-#include <llvm/Analysis/TargetTransformInfo.h>
-#include <llvm/IR/Attributes.h>
-#include <llvm/IR/DebugInfo.h>
-#include <llvm/IR/Function.h>
-#include <llvm/IR/GlobalValue.h>
-#include <llvm/IR/Instruction.h>
-#include <llvm/IR/LegacyPassManager.h>
-#include <llvm/IR/Module.h>
-#include <llvm/Support/TargetSelect.h>
-#include <llvm/Transforms/IPO.h>
-#include <llvm/Transforms/Scalar.h>
-#include <llvm/Transforms/Vectorize.h>
-#if JL_LLVM_VERSION < 120000
-#include <llvm/Transforms/Scalar/InstSimplifyPass.h>
-#endif
-#include <llvm/Transforms/Utils/ModuleUtils.h>
-
-#include "julia.h"
-
-using namespace llvm::legacy;
-
-namespace llvm {
-
-
-// Initialization functions
-//
-// The LLVMInitialize* functions and friends are defined `static inline`
-
-extern "C" JL_DLLEXPORT void LLVMExtraInitializeAllTargetInfos()
-{
-    InitializeAllTargetInfos();
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraInitializeAllTargets()
-{
-    InitializeAllTargets();
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraInitializeAllTargetMCs()
-{
-    InitializeAllTargetMCs();
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraInitializeAllAsmPrinters()
-{
-    InitializeAllAsmPrinters();
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraInitializeAllAsmParsers()
-{
-    InitializeAllAsmParsers();
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraInitializeAllDisassemblers()
-{
-    InitializeAllDisassemblers();
-}
-
-extern "C" JL_DLLEXPORT LLVMBool LLVMExtraInitializeNativeTarget()
-{
-    return InitializeNativeTarget();
-}
-
-extern "C" JL_DLLEXPORT LLVMBool LLVMExtraInitializeNativeAsmParser()
-{
-    return InitializeNativeTargetAsmParser();
-}
-
-extern "C" JL_DLLEXPORT LLVMBool LLVMExtraInitializeNativeAsmPrinter()
-{
-    return InitializeNativeTargetAsmPrinter();
-}
-
-extern "C" JL_DLLEXPORT LLVMBool LLVMExtraInitializeNativeDisassembler()
-{
-    return InitializeNativeTargetDisassembler();
-}
-
-// Various missing passes (being upstreamed)
-
-extern "C" JL_DLLEXPORT void LLVMExtraAddBarrierNoopPass(LLVMPassManagerRef PM)
-{
-    unwrap(PM)->add(createBarrierNoopPass());
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraAddDivRemPairsPass(LLVMPassManagerRef PM) {
-    unwrap(PM)->add(createDivRemPairsPass());
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraAddLoopDistributePass(LLVMPassManagerRef PM) {
-    unwrap(PM)->add(createLoopDistributePass());
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraAddLoopFusePass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createLoopFusePass());
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraLoopLoadEliminationPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createLoopLoadEliminationPass());
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraAddLoadStoreVectorizerPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createLoadStoreVectorizerPass());
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraAddVectorCombinePass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createVectorCombinePass());
-}
-
-// Can be removed in LLVM 12
-extern "C" JL_DLLEXPORT void LLVMExtraAddInstructionSimplifyPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createInstSimplifyLegacyPass());
-}
-
-
-// Infrastructure for writing LLVM passes in Julia
-
-typedef struct LLVMOpaquePass *LLVMPassRef;
-DEFINE_STDCXX_CONVERSION_FUNCTIONS(Pass, LLVMPassRef)
-
-extern "C" JL_DLLEXPORT void
-LLVMExtraAddPass(LLVMPassManagerRef PM, LLVMPassRef P)
-{
-    unwrap(PM)->add(unwrap(P));
-}
-
-typedef LLVMBool (*LLVMPassCallback)(void* Ref, void* Data);
-
-StringMap<char *> PassIDs;
-char &CreatePassID(const char *Name)
-{
-    std::string NameStr(Name);
-    if (PassIDs.find(NameStr) != PassIDs.end())
-        return *PassIDs[NameStr];
-    else
-        return *(PassIDs[NameStr] = new char);
-}
-
-class JuliaModulePass : public ModulePass {
-public:
-    JuliaModulePass(const char *Name, LLVMPassCallback Callback, void* Data)
-        : ModulePass(CreatePassID(Name)), Callback(Callback), Data(Data)
-    {
-    }
-
-    bool runOnModule(Module &M)
-    {
-        void *Ref = (void*)wrap(&M);
-        bool Changed = Callback(Ref, Data);
-        return Changed;
-    }
-
-private:
-    LLVMPassCallback Callback;
-    void* Data;
-};
-
-extern "C" JL_DLLEXPORT LLVMPassRef
-LLVMExtraCreateModulePass2(const char *Name, LLVMPassCallback Callback, void *Data)
-{
-    return wrap(new JuliaModulePass(Name, Callback, Data));
-}
-
-class JuliaFunctionPass : public FunctionPass {
-public:
-    JuliaFunctionPass(const char *Name, LLVMPassCallback Callback, void* Data)
-        : FunctionPass(CreatePassID(Name)), Callback(Callback), Data(Data)
-    {
-    }
-
-    bool runOnFunction(Function &Fn)
-    {
-        void *Ref = (void*)wrap(&Fn);
-        bool Changed = Callback(Ref, Data);
-        return Changed;
-    }
-
-private:
-    LLVMPassCallback Callback;
-    void* Data;
-};
-
-extern "C" JL_DLLEXPORT LLVMPassRef
-LLVMExtraCreateFunctionPass2(const char *Name, LLVMPassCallback Callback, void *Data)
-{
-    return wrap(new JuliaFunctionPass(Name, Callback, Data));
-}
-
-
-// Various missing functions
-
-extern "C" JL_DLLEXPORT unsigned int LLVMExtraGetDebugMDVersion()
-{
-    return DEBUG_METADATA_VERSION;
-}
-
-extern "C" JL_DLLEXPORT LLVMContextRef LLVMExtraGetValueContext(LLVMValueRef V)
-{
-    return wrap(&unwrap(V)->getContext());
-}
-
-extern "C" JL_DLLEXPORT void
-LLVMExtraAddTargetLibraryInfoByTiple(const char *T, LLVMPassManagerRef PM)
-{
-    unwrap(PM)->add(new TargetLibraryInfoWrapperPass(Triple(T)));
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraAddInternalizePassWithExportList(
-        LLVMPassManagerRef PM, const char **ExportList, size_t Length)
-{
-    auto PreserveFobj = [=](const GlobalValue &GV) {
-        for (size_t i = 0; i < Length; i++) {
-            if (strcmp(ExportList[i], GV.getName().data()) == 0)
-                return true;
-        }
-        return false;
-    };
-    unwrap(PM)->add(createInternalizePass(PreserveFobj));
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraAppendToUsed(LLVMModuleRef Mod,
-                                                   LLVMValueRef* Values,
-                                                   size_t Count) {
-    SmallVector<GlobalValue *, 1> GlobalValues;
-    for (auto *Value : makeArrayRef(Values, Count))
-        GlobalValues.push_back(cast<GlobalValue>(unwrap(Value)));
-    appendToUsed(*unwrap(Mod), GlobalValues);
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraAppendToCompilerUsed(LLVMModuleRef Mod,
-                                                           LLVMValueRef* Values,
-                                                           size_t Count) {
-    SmallVector<GlobalValue *, 1> GlobalValues;
-    for (auto *Value : makeArrayRef(Values, Count))
-        GlobalValues.push_back(cast<GlobalValue>(unwrap(Value)));
-    appendToCompilerUsed(*unwrap(Mod), GlobalValues);
-}
-
-extern "C" JL_DLLEXPORT void LLVMExtraAddGenericAnalysisPasses(LLVMPassManagerRef PM) {
-    unwrap(PM)->add(createTargetTransformInfoWrapperPass(TargetIRAnalysis()));
-}
-
-
-// Awaiting D46627
-
-extern "C" JL_DLLEXPORT int LLVMExtraGetSourceLocation(LLVMValueRef V, int index,
-                                                        const char** Name,
-                                                        const char** Filename,
-                                                        unsigned int* Line,
-                                                        unsigned int* Column)
-{
-    if (auto I = dyn_cast<Instruction>(unwrap(V))) {
-        const DILocation* DIL = I->getDebugLoc();
-        if (!DIL)
-            return 0;
-
-        for (int i = index; i > 0; i--) {
-            DIL = DIL->getInlinedAt();
-            if (!DIL)
-                return 0;
-        }
-
-        *Name = DIL->getScope()->getName().data();
-        *Filename = DIL->getScope()->getFilename().data();
-        *Line = DIL->getLine();
-        *Column = DIL->getColumn();
-
-        return 1;
-
-    } else {
-        jl_exceptionf(jl_argumenterror_type, "Can only get source location information of instructions");
-    }
-}
-
-} // namespace llvm

From 370ca6ab6c5d9f736367359706513e97695baa46 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <v.churavy@gmail.com>
Date: Wed, 30 Jun 2021 15:04:40 +0200
Subject: [PATCH 34/44] [LLVM] Add patches for eh_frame emission on
 AArch64/Darwin

(cherry picked from commit 8016ca90a4f2fba4ebe38ea7ece44c8fb9944ec1)
---
 deps/Versions.make                            |   8 +-
 deps/checksums/clang                          | 116 ++---
 deps/checksums/llvm                           | 472 +++++++++---------
 deps/llvm.mk                                  |   2 +
 .../patches/llvm-12-fde-symbols-aarch64.patch | 158 ++++++
 .../llvm-12-force-eh_frame-aarch64.patch      |  31 ++
 stdlib/libLLVM_jll/Project.toml               |   2 +-
 7 files changed, 494 insertions(+), 295 deletions(-)
 create mode 100644 deps/patches/llvm-12-fde-symbols-aarch64.patch
 create mode 100644 deps/patches/llvm-12-force-eh_frame-aarch64.patch

diff --git a/deps/Versions.make b/deps/Versions.make
index cb41d43622aed..770828e28d93c 100644
--- a/deps/Versions.make
+++ b/deps/Versions.make
@@ -15,7 +15,7 @@ CSL_JLL_NAME := CompilerSupportLibraries
 
 # Clang (paired with LLVM, only here as a JLL download)
 CLANG_JLL_NAME := Clang
-CLANG_JLL_VER  := 12.0.0+0
+CLANG_JLL_VER  := 12.0.0+1
 
 # DSFMT
 DSFMT_VER := 2.2.4
@@ -45,13 +45,13 @@ LIBUV_JLL_NAME := LibUV
 
 # LLVM
 LLVM_VER := 12.0.0
-LLVM_ASSERT_JLL_VER := 12.0.0+0
+LLVM_ASSERT_JLL_VER := 12.0.0+1
 LLVM_JLL_NAME := libLLVM
 
 # LLVM_tools (downloads LLVM_jll to get things like `lit` and `opt`)
 LLVM_TOOLS_JLL_NAME := LLVM
-LLVM_TOOLS_JLL_VER := 12.0.0+0
-LLVM_TOOLS_ASSERT_JLL_VER := 12.0.0+0
+LLVM_TOOLS_JLL_VER := 12.0.0+1
+LLVM_TOOLS_ASSERT_JLL_VER := 12.0.0+1
 
 # LLVM libunwind
 LLVMUNWIND_VER := 11.0.1
diff --git a/deps/checksums/clang b/deps/checksums/clang
index 7dec72fad1db5..125b200da0a36 100644
--- a/deps/checksums/clang
+++ b/deps/checksums/clang
@@ -1,58 +1,58 @@
-Clang.v12.0.0+0.aarch64-apple-darwin.tar.gz/md5/980c74812ecb2910ce5ff89f50adeb4e
-Clang.v12.0.0+0.aarch64-apple-darwin.tar.gz/sha512/3d732de9268f4ee3550cb8cd25547025f0c3c2b42733da68570ba40906aac590c51de8819f1643d40f3c2310f666eb1d5adff6beaf1a811e1358f71a2b2e693e
-Clang.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/md5/4cb0061a62021a9f2e8c4c38cc116a32
-Clang.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/sha512/628844979ab97b7e95578cc6a2f01be4853e2e451321baa209d8ef80a3a77f58403f8c905e89ac48570daeae72b10a5dd21de948cc3e886918eec67f87168d2c
-Clang.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/md5/98216114af0c5080f2054012986df84a
-Clang.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/sha512/8f615879985a7840b0c1dec53aaa4f77025464cc32594e3dfd7148ce36201cf0221641fc6de867f605b784d98a2ab360c1aabf1bb98d77363e35d6225f4bce17
-Clang.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/md5/f9ac91da205acb64c95dace753035a45
-Clang.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/sha512/91739206d79d6c75586289205a40c71b922cd42c96564c174b0707a7cc136e77cfbeadbee820ec7ab0e0bfc36f481b88818d3579a205b2d6ae65d7701eb817e6
-Clang.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/md5/7679a6f941daada0225667c017fe50c6
-Clang.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/sha512/aa1532188095bb73dfcea86dc5965302b6a3099c4c95787c0b3ab01ca5c53c7a533325308af6c109d1aa50f69153c57fd5e502f41f2af41dbcf3b039d5f1defa
-Clang.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/01056c4c0a86f8684643a06fefa92f27
-Clang.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/bff88b75e7214135cd6c9e797c47cc5dc2d3f2b9bd8e3cf9f1c7ade3bcb205ca916b63b5c6f2067f4de306dddc4efef36c9089a49562c8d656b95d45c957cfd9
-Clang.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/88e9b5fde388021ef88896d39968b3fe
-Clang.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/aa5ab4375f532629b22a81d927a23bab60c819ae16982a1dc797a043fd3622d2b5a9c0e4f3195d2974df3383438a844c276efe3a60fee1c99ec7d3a10064cd45
-Clang.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/md5/4415d5e19f1e4bf2719b4851ca428ea1
-Clang.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/200d43017d05ca59374950b557eadb5f2630bf70378a2970dbac4da2ada8e2428c786b9f3c1a2774ed863baf34d8ac667c294c2bb46e51125c40a3aa0125b596
-Clang.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/md5/c8b618d1fb0685f0023c3440918923a0
-Clang.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/4b85961d98cd47105cb88a187ac52072af7af27c81defa35b2bbf36a0841c0d7745a294373fde503989bfc22245ba45a1c9d253e7bda5a28381dd6ab9b677238
-Clang.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/d6d6a8fb56ca4e44304310f5ce7e14cd
-Clang.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/dd3a039d3a3099fd8e0f135443ed9145891179437dcc1cd851da3b54d4815058190e2f6ede97d2f0357629e0d173395a86537732b0354bc87ae5815638d402ca
-Clang.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/f0431cd3ad402d8faec1efcddd7f7fef
-Clang.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/0d5e7b96a15db5bd09457aa27aefd05b8f530ff348956ce1699503a03adfd6abec84fee080aa5cac54a7d4eca42730f7f9cd6b13c23e3b13f4d2392f08fcf688
-Clang.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/md5/1579ee70c12a5c38f84e9c52610b196b
-Clang.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/91841937b8c1e3dc4c223a4dae48e7d4fa307df2cc692e512c469994bfabcba897078bc95c4141e5384f53be31d160ee750b60382005d7e5acf99532f47b4566
-Clang.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/md5/75aaeadab3001679561ebd56193cd90c
-Clang.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/7096f0bdb478c2cd76cee8f3ea47ecf8565af0702901f5c6351233458d2c66d3ea61e3f065ae9e90960dc7e0bd6fa1a0c6d160934fe409a663e4eefa23e6c5d6
-Clang.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/md5/987c4b1b50d9bb56e598839e383f79b9
-Clang.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/sha512/e3b827ce6f250a2264700991720585b154bba9c6713da7fa619a5e9e0829c7b02b909e3f73ab9149f58de2e27566a7d47723043d6de5fd027b1233452bd1d2f9
-Clang.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/md5/e8297a60b87199cab225418ec49503ae
-Clang.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/sha512/9b341cdd57982d269df2d8158a5101f451f09031e1e784b593c78aa272c392eb7328b1c328a2f29d494b5ad4ef1e1ef96d01772f176be6395a8503f983e18d56
-Clang.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/md5/46f27859be1f7e162499e846d9532a37
-Clang.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/sha512/5173beba0ba2423c978cc3663e3b6673752efaef34547efe1e1015a18bc5cb1129ebdec3dacbe9894832601d87efffbebb263790d88ae198cd985636cba3fdfe
-Clang.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/md5/00ef76971a4783c7e63a86ccae8b15b3
-Clang.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/sha512/f5e5f89f541df4b1da164392da0ea5397be62138e203f321b0b771942646530acdc621ca36a6e6c15df32c0d722fe9b0b5845c7ac58bf24966ae503979a6e8c8
-Clang.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/md5/8761cdd4810ffe1b3eb3537fb3e03218
-Clang.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/sha512/e5f011a2f74a032ef0ac429acc615b02d3d6bc07271acf2279afd947c1151914533456cf5b111ae7f4c868f7ee739ccd9623ce3ca2850b3cda3db53bfddc8aac
-Clang.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/md5/0048f8c3014f9baf26e9d4e10ea2a893
-Clang.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/sha512/9ac2b0e47d86877bb47f5ff1bb7cfef3c0dcbeb813c770c29e2fac232cab0c06f39b5b2fad15d975d50a9590e9cce3c251e3a3c6ebd87b0656c93ed14a08c901
-Clang.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/md5/b5833c865313b442da0b8bbe47a7ec51
-Clang.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/ef2c7cef9703248a0d09ae0a2b1d09496575411d6a846557a47628c9471824ec6f8b9ec361bb0c6bfe1ad5c27c1160900638b185cd46f21ad0eaf341e9caf600
-Clang.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/md5/e76c4776341d23d2f87d87f2f9b32acd
-Clang.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/e855521dfa1fb07fdbfb3afec0bf27d346bcf316c68dd0b3898ecee9d2e79f02d7bae9763e1c046b9ef6730458b40bdf35f737d0bece9a965c68223c6e1ada96
-Clang.v12.0.0+0.x86_64-apple-darwin.tar.gz/md5/d2522f901fe5fc2f1dc4c9d3c0a82e29
-Clang.v12.0.0+0.x86_64-apple-darwin.tar.gz/sha512/3efb4423573861ecdeaf0a82e7c15c1cc767016ceb9e9a5132a7ecdc2075bc0d8e8326d6bf9e02b649b6c324319fcea471d0e1727e595515488be7b39cfd07d1
-Clang.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/md5/88488b8e890dc41c7c6ac19d1b405a6f
-Clang.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/sha512/dff87a31cc19147c9105ecff15cc0cc671a0f683b6dd3d86446b6a53c745256ebd1a951d0b83e26ad2e29aef6bb044b6c00d30c4647a3eaa0cad45fc1fb70f20
-Clang.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/md5/1b5bde42bd922cbcc06ffaa5c96f3664
-Clang.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/sha512/af499fc2aa6b35cb67414782a9cdb9e21dfafb2d5678c7ba9f95bbd92650c8b7f90879f86ba55b445ce4a42947ec495c1a6fdd6e768742bf8c3cba7552e2bd4e
-Clang.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/md5/a3922ad0741b490daa6e21b91056324f
-Clang.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/sha512/257732327901f32d3baa7e1fc202f266e578b5bb9d929949a900505b664213c9c8c132b109ee93f96c37bde3c4d2c7b806a45f44e93f55af1973fbe45c47c621
-Clang.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/md5/42a813253b2f820bfc4328c55687b096
-Clang.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/sha512/ab4843e2d252f1ad6435d506483c29c752573b6be70c363a3207e8a45d09850f2cec5381ac5491694e69ede5cf0b102f61e5f54d7bce81b049bfce9b6552e194
-Clang.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/md5/b17ec22a9dbb88dcf956ccfbb62f6609
-Clang.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/sha512/d885e4a50e6f57b8314752a590d5ae72b78eec3feb838ad1a66116cc2fb1b4254b77ab36bb86de416ad93e58dc2d60086eaed27ed29399f200355191daf43123
-Clang.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/md5/819b09f861dde64cde72c061feeb1baf
-Clang.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/sha512/4f2e8c402e2a184f115311f129fe731b6445422cfcf7ffb9b1ae577e9588f5d0de040ba6c3eac3263fd3d51cbf10ab822bed24be0a3d8766084adc23c04b082b
-Clang.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/md5/080587a6f5a463efc06362d40730334e
-Clang.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/sha512/46e47a06c996094b385b5939e73ac831a0c08da7e113683433e0e559a5627c43242311be0d6f2ba992d65bc3b5edfab3045b1d06ef26f6b87045c14111845260
+Clang.v12.0.0+1.aarch64-apple-darwin.tar.gz/md5/465b3375db7ab6b93fbe465ed76a275d
+Clang.v12.0.0+1.aarch64-apple-darwin.tar.gz/sha512/a39faf3bb411612da5cb29be70a3b200dac3a4bfd7eb58e4f68edfd09923819f7f465dab4dde4caa0335d8fc392b2f55db762de0e93642ff49a466b68f0fd383
+Clang.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/md5/162a2ee947742b9d0c01c95725b98d96
+Clang.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/sha512/ead804d78ab42d3e1ca6cb7f12ff7544525772badce779eaef5cf973e23966f1398343d3c3148b58195eef7d4e9c7ee897e8bfb30a24c095685cece46344671e
+Clang.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/md5/563e93b82893c8257c23878135de6687
+Clang.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/sha512/ce8103e409790b5d4993ef4259524096617ee27b82b5d1f6c55880814211da6cefb4645a9c5de4ec44f9c961d1ec62da8cde0977d8af4be6e25a638891efc372
+Clang.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/md5/d3eac2234c6fa736c3c8e8a4a7e9eb0c
+Clang.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/sha512/0a7f414dd22d34184c47695b5ad40e57286527a16fe32e90eaccad11d72192679985a9ffd6f9616564ff87de1d189726c3049100269648115f0f983d80400400
+Clang.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/md5/23cdec7b732c13313c897593c40bce2a
+Clang.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/sha512/616fcd76d887cb3188b5dab8a2a15f276f3cc7d73ebdc13e1e12d1d4eaf0a3722ee288b5531bd24ab825a463112052399ab75d839e9df1c98987313fe731a2ef
+Clang.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/f2d3d99ae67b8435021b20bd77aaf433
+Clang.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/7cb4ac7392501a849058822f88aac49f9a0a03496a5fb39b8a8fcfeecf86f004b466e9fbfe2bfdaaed6d9cbe33e61b42d89c03ffddbfc4d8015790f64ca3623b
+Clang.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/3c43e3cbbea5c8f2f197bf6c505a98c4
+Clang.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/31107abd43a3ad43a3df424e9d35739d646c955923c08ca3cc405b7677deacc0cf9aaaf29b29fdd4fd53a434087620317e1f4d91c3bcb2932716a87804388d0b
+Clang.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/md5/dd2eecb77a209c088ad81dec1f4d9610
+Clang.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/7a5a13ed5e046fb05cba3cd7aa55cdef741a7d76274e71d2b2fa194f132bb98c40d200fb04dc111cda7d901babd4f1f5d4e9bdf1dfd635f0492c386971878b5a
+Clang.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/md5/74684a3dfdecad109aa1cb3e5eb1f24b
+Clang.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/e1dae1ae3bd5b82d21401cbc9c6ca2281a05bb1039fffe0d94e7d5ef482a09bedbb5c512aae52873ec7ca471e543c334ff37b1e8429da79724b6b131b0502bf5
+Clang.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/32284100f6a57f5e4b32d0e6d35dff9c
+Clang.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/201cff5571219df602ea2f63d9559e8345aacc8c8691b30614fe6b6f5d0b7692f670b17366185f0e16cd1119bc49cdd1184247b32826bcc0a3a1d026c48e538b
+Clang.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/c854231dcdd3816078ffaf435b152a3c
+Clang.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/082760f1dcb39cccffd5fa0a096ff0c6d823355d22d8cc2b69aa90092fb6157c87070d932fa736e3ddf4de0199c7f06cdca91bb354ee0cc125b505e66f5df068
+Clang.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/md5/5c909ab9d88334058e99be60e0330711
+Clang.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/abb39baac59aff579603870a31dbbbfebae3eea91caa203dbb3409d49cccd81dd96aa82a098c20265ee5f5fd851a0621c11b1a8837952a329c699b909e2c83a1
+Clang.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/md5/5c275a64299c0d4fc51d35f53c3dab00
+Clang.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/05c167d371dc5fa0226f0505ea1339ffcec8563c76adbc1450098ec7aa096fe04d855595d3cee290c2b6dc0843d8fc1c5215c84d3b3095d2cf0d93711dd4acec
+Clang.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/md5/f27a08b7004c4a5eeb35d22198d72c82
+Clang.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/sha512/9fdcadb0d2bb56eb0e880a7b7a0c7660d614670209f76dfd5aae70ef0d3c437d6b56171b542d608784f7c4f7ef7bc5a4844baffae4fa95c25094c630ac39bfdb
+Clang.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/md5/748c1efc36a70910fb3d3fea537c3b4e
+Clang.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/sha512/bf70ba1a1576039210978488050890d6ee049fdab076a9a8498058b732c1c05d47861146aa48262a304f7dd8b24529e1a3425d0afc42c69843eac4b1317327a2
+Clang.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/md5/5233ddc66968db6bd00bcc9e2aed7f12
+Clang.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/sha512/bb9aea78c78c6cbb613b4c3eac6f08776dfafcc5402e6bf1a6670ac8d707de29b0ff8ad654d1d586f3e0b2a324c8fff49524033277f3cceb08c826243dd8a519
+Clang.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/md5/f448936531ab804b56b0d8b63a2b7cb9
+Clang.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/sha512/5ccdaad4623ec17eb72f806bea432fbe62584b512159771cb295bd273771b168f502a3a8f15588e0e9df65024271a8edb891fc48c2535e45a31289b4c3469a28
+Clang.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/md5/2e68b66d9d607414d69bf2b11609ce5d
+Clang.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/sha512/fec58abebab5d632fbfaef8335737a54d83804a823ca6aa8ab9031aa3c2a8afd5c342d6d989d7918352c241b7d7cb8f9802a1422a44316ad0f8760998e2e02ae
+Clang.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/md5/1ab89ec9072eb7d871b3a0eff78d56ac
+Clang.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/sha512/9878561bbf405ca29e1f32049c753215ecac1bbcbb62f66dc573da3826bbdfb5f4e5630273595d611c2aa315d54fdfa35a954f71ba8781e5eb659658a9157886
+Clang.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/md5/4b8045175ede4b934e2ccc8a28920910
+Clang.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/38c952d0ed7e63c52e013e303f77c4d779ca8682926a32705402f5a275358fdd5d7f59188c0f43d994b8c2ea31939c23d0dff9a4b7312ed39574cc39c27691ea
+Clang.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/md5/53ce55e158860afa17cc653f4fc0b500
+Clang.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/15738783329bca1720278526a306d230917d64d6ec6c9542a248953f5c1a071316de6bb80cd1d0498926ce876fd541d939023fda7b234ae9517f4583a2b6aa8c
+Clang.v12.0.0+1.x86_64-apple-darwin.tar.gz/md5/aefdcf918b508ba66cba11abd0d99ef7
+Clang.v12.0.0+1.x86_64-apple-darwin.tar.gz/sha512/c7ef9af9bbb5a1e2fe022c3996566fe774903bee67c15dd6ae304e89fc93e5080f177ea074f9736d6959edecae415586db4dfff8328e8fdfd643019ca7d41131
+Clang.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/md5/490a63fadd41b10c425c1e87170b63eb
+Clang.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/sha512/14ad28afecad4a60d0a978af75b3db68feed71badb271dee0b29bb4cb471f5e69ce85b6cc990b63a2f9db24ca87e897ee935beca532451b2ffc020d80e3cc827
+Clang.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/md5/9056064168e01462aae83721a670fc7e
+Clang.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/sha512/aa0340efa8106acf92c2528c6cd5ac8b6bfd0ca0b8041e22534db4178364467dd8c46f4c77f365fa0ddeb5aefc6ed01e4a4416e1326173a255e18cc890dfc0ef
+Clang.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/md5/b4edd5baae3b1f9b18eae365d7969621
+Clang.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/sha512/abe5ada1bfb6d69ff28fd1d16f5de3e2b12c36730f04d3fb4c9e332d4947438530f4d5a677d3dfc973769a381ec7dd1944c3ce2213bf2177d263b47b4903d186
+Clang.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/md5/d3176f49c216d11f2113caa10020745e
+Clang.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/sha512/8585c40983ab7c401bc6537cfc3ebb7a44e52738576155855db5c51fa9c0dfbec3b5c12f63575b09c038c9f047d9941a192082ba7572489b55d5bcba2e3fb27b
+Clang.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/md5/1d3bb2c77b0a3473697ca2a63de35b89
+Clang.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/sha512/de8922979ad7158fa72d0e152670ad3be75fabdb22a1e91d187e6847e9b6cbc905ca09a476dac651a52c775192b3bada333e68e38e6ba7101a472755bb7ad79f
+Clang.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/md5/ecaf6c8831e8c6de8b8e74f95f04dbf4
+Clang.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/sha512/aec6626dd02fc6a0f82e05783dbce19d69a2fd9eec53189a1086393134ce1f972a1b0ef286b06f19be192fc4575d6e9f5f09984444cd3bd50c66c2fcabe23b73
+Clang.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/md5/23c8b1d208dde43fe2b48f143f2108ea
+Clang.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/sha512/75118203f3ba67ca99279100e9b31eaff165f70af5a487bd9ad6dbf70da8041a374d9953b807739258be6e493a5422a2e5e1ba00b8ebd746b706de3915375c1e
diff --git a/deps/checksums/llvm b/deps/checksums/llvm
index aa0124f257b44..71b445c82f00c 100644
--- a/deps/checksums/llvm
+++ b/deps/checksums/llvm
@@ -1,234 +1,242 @@
-libLLVM_assert.v12.0.0+0.aarch64-apple-darwin.tar.gz/md5/1e5a6d26e657b2900c9c3914dfbad9e9
-libLLVM_assert.v12.0.0+0.aarch64-apple-darwin.tar.gz/sha512/e2846fa7e2503309dfb57159acbf8ca5836fffb1a2a81fc60e88743d13eb67491c5a8977bc3dce7d75de799ff9bb963029abb23dec5450085e480940bd3f4bbb
-libLLVM_assert.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/md5/9b6a0cf448686b657caffe308a8512fa
-libLLVM_assert.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/sha512/151f3c29ea0f21f6a4d4be8b127aad2cdfd0b97ed3f8cf8d518be28f2b3fdaaff29eac04b57b5a5ce0aa3ce137e1afc2fec2e619ea2dd119520ae815e0e064c1
-libLLVM_assert.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/md5/8b4eab1d6ec21bf412a3ca8eaba04f3d
-libLLVM_assert.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/sha512/13009a160683ab073a0a3e089f17d006b1d74273a65b51d16f4e731b47352c972ea0487a79e02084c4f4f72f61bbd1f169b7bbdacb6974e5fa53944d444ec290
-libLLVM_assert.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/md5/d1e35884644357a76dd4fa6f7429bccf
-libLLVM_assert.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/sha512/d0918e7886c9ff6771d3ff809a25a56a7a2154b4713ed2f47f3e0b75748524f5465fa742c771e1fb954e3757a3341ca3f5e8f659225e0edb49f0c50b9dec995f
-libLLVM_assert.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/md5/ab814bef54de513926548605795ee56b
-libLLVM_assert.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/sha512/18aa8f235963f24ff15854708418640eae32c061b663574391d8c70880926a9ea6038cd2d875ee616fc5b247aae6503c6bbe09738d5fd0b65ca92e976057c8f6
-libLLVM_assert.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/6fd292d8e348f895efc567a566a36a98
-libLLVM_assert.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/1b03e5de348c9f563fc31c2325817380df6b995a5f352effd434f786f760612ea53efbae2ddc37251b3dcef73eea88c71869a197006ecd0ec6f860ffdacca5ec
-libLLVM_assert.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/7377e0370c12506893231c4d8e1a28bd
-libLLVM_assert.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/c91aa4226f065c62cf16f9815b0cd34548dfff38cb1a05e0e122ff659c3db2ad6d28d83d9d7ec4d28227b2a5de1d2b48812e50f6af838e69eedbbd8cc153f131
-libLLVM_assert.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/md5/faa491409f4e9d822e9e34f6f2db36ad
-libLLVM_assert.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/a07245c310755567e9e33b26c0f0282eae40abf1a1a1c22a77b6412709b191433ec497e16662f229558e49089d68a1c904cd282c548c02370ed902f544eb5cd5
-libLLVM_assert.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/md5/b42b08d46b64df98e3ab493341ac015a
-libLLVM_assert.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/da2bd53fab48f8b46971639d6ed81b9e57467a6c4a7a3a63984c08f1b799f7352352ba28892a7789811879e3740073487b885d9974b6285fd03da16edca24f2b
-libLLVM_assert.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/52e678465021c06611f86411a8f41e9e
-libLLVM_assert.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/01964e97bb231899b6064734f756d8099bf141674ed6d231108dbb6c901f3079444cd620493b0ea7e8bf1fbd2899f288ed02df3c855e5af87d7db93a9fd60108
-libLLVM_assert.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/c5a5977de4429a0a38e4cf025d57660a
-libLLVM_assert.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/a5e4aed882ca2cbf0a8a8ff5b0c8e4eaadeaf7491ea1887ee5fae628a5d46906e7d480b784b1d1fd190c921cecebcaa243ff39df5a1776a82abcfe4095bf3d07
-libLLVM_assert.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/md5/bb83098ced1081fa0c06ddb84b6cf0fa
-libLLVM_assert.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/e217bb8fe434954191b2b2f0a00d6e32e39557b9ff95a2417a13f3a6a25f2266c180e66c98495b1946171d1652ca62689140814d5337e0e00b4abc15179f2879
-libLLVM_assert.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/md5/77161f57a346fc7f6b9aa1d36db55879
-libLLVM_assert.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/e53440cacd74eb6eb48e4de0b720df177bb9b8c90e682685efcf65f98bc4bc6f990c60ccdb426e85a80db8005dbad1efa5be69e2dc326953d1c0177734f6a84b
-libLLVM_assert.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/md5/33deaff11953a1f1f78658461010b258
-libLLVM_assert.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/sha512/61383ed8e872e21c3419d64928e29c3f1e074c03973ee456062ef774b71cb27785afa47c641ce9db14a144fb66a7f8c53215448721c49ebf3b37674ed04a75e7
-libLLVM_assert.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/md5/65f47baee13c6e2cd9f0f3cd95bd724d
-libLLVM_assert.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/sha512/6f814647393445c5a6ec05cd8c89a3ad106bde4a2197ee0a8bd8e64f1575245d695a01bcfb02861ad452f7d881114a5fb4ab145aa2211b42fc34b07ffec2ccbe
-libLLVM_assert.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/md5/107c0e969aac6bc376588481f3ab4748
-libLLVM_assert.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/sha512/aaf8677bdf4fdf5751a0133c00dfefb28cdf5076d62d749d9bb81f29af2a3f35438b3c4c0aa71fc87214670bb63a2428712a1c07fc46dae217cdef27b9b0c550
-libLLVM_assert.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/md5/b6f7084de25b6b49631a2f2aba8da96e
-libLLVM_assert.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/sha512/75f91fd66da8d1e041c9ed0e8fd69ece5601d909caf10eaf30992b6eb5b743653d97648766fe0782862dc0891a234f3aef05df3b6c04848d4371addbae8bb419
-libLLVM_assert.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/md5/c36270a831b06d5b3654ec7a9fd35b09
-libLLVM_assert.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/sha512/25a095c12ac43dc36fd32b0ceacf9bc10b240a360a45fa0b0fdde367a40dc22a83bb3a6267426c0c02f14f221046c0b453417eae4cc0539ca116149f8ea480ef
-libLLVM_assert.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/md5/8f0c51901b55ff5374c25a0e9bdeae99
-libLLVM_assert.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/sha512/a1387d07d63d0e33632bf77702271bf624fa29bd8e689054d3f71734451d39ef09abb9fb63f78cb6aa1f6f5bbe54737f72740aeb63a94fc6876a600ede5ed159
-libLLVM_assert.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/md5/9a456e2d31115b296b212305988cbf0a
-libLLVM_assert.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/9c93bbdf9b9d11654aa134cdd7b50198a7b49e86148ba3257cf6cb1003fe9d22f568e45ed5b26f4e0db7fb3128f57dadbef9f4494827c66b2957988305aa9b20
-libLLVM_assert.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/md5/efe3eec267a6224e5e8f1458be4fcda6
-libLLVM_assert.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/d5e90b29242b6aeab8b4ec6d37938a5ab15e1b1546f87f795d45b8f9a1520d24408e8b2c3a26cfb4b61c6d3228f98d490e2a0abf375b8afec0fd0e866a833197
-libLLVM_assert.v12.0.0+0.x86_64-apple-darwin.tar.gz/md5/475530f8b87ac033069c4073ba25f62c
-libLLVM_assert.v12.0.0+0.x86_64-apple-darwin.tar.gz/sha512/ae46db3687de3bca657968624d95ec3afed99fc3d07271681ae9cc587baed2b391c17b4b0905cb4da3727a44c7698b248dced4b44c688242042c096f9b2c2a46
-libLLVM_assert.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/md5/888d7bd8ceb30a482438d0fa7526d6a5
-libLLVM_assert.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/sha512/b494736aa3c4378bccc5f72db20fdbc488bb383ec4f569be18848fe1aa712aa6dcd00df1a8c651ed266981e70f4f1e9ba2bf04cc410ef02140f988c21dc9730c
-libLLVM_assert.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/md5/7fb8dee0396a2ef772612de81c4ce222
-libLLVM_assert.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/sha512/ce1bcc5465e61944c4720f615de3bc234d2d2a3d8fed986aa919ba1840c0fa9a8ff4b7e5fd1f8e063bbd153ca1977718a91ac2e1ab2623a4b744d8ca98c3191a
-libLLVM_assert.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/md5/ae631966f7a9f28ff105ae2c5c9b45e2
-libLLVM_assert.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/sha512/da3c1b1335f891b1121fa5f1f8fa4d9705c2bfcc3d98f80ef86f453e4db2d7e4c391b462ff471a87a01403558f81241aff7fbb8f7a05d815b5e15099877f9f3c
-libLLVM_assert.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/md5/a4f21af04ce1407eb8d16e9b4704bfd5
-libLLVM_assert.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/sha512/bc6ada66aecb448f28f61f261d0e7cc009643ec0582c46ab7756e09bb4ba2ffecea8883213e6605144084abbeb1e12ccaf6e2a15b1797151a6aa0522453c0af5
-libLLVM_assert.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/md5/0fee3ab691bab69b30f3ce5721c871db
-libLLVM_assert.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/sha512/4b9adee9596d37b336434a74e3aa007f83afeeeccbeaa16c942dc117f2990d1485887860eae7eee74aec2b4bea0f674aa3c6abbe621ddc26a76697e7ab1be986
-libLLVM_assert.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/md5/2dcc9f9c8e8ea1c96b19d48e9c4da039
-libLLVM_assert.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/sha512/86a518a72558cae62e2b393503bf34e768d5999d2b773b22ae5cffdd6a413780fd8afcb88d8862a62529f3f3238eb50dd5d1210814d417beb01814bbdc029540
-libLLVM_assert.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/md5/0392a6e2b4d2ea9177d57ed1c6758344
-libLLVM_assert.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/sha512/e0306b68650e758121a577133321d07fe42d6e1ff5a1b4fa5ae91d522e0a196f63d0a8465005e8d49a39c3182c1f86be8f79ae3c5da1943b1c5ad3b45dbb90a7
-libLLVM.v12.0.0+0.aarch64-apple-darwin.tar.gz/md5/758342103dc72bef1e97045b61326c12
-libLLVM.v12.0.0+0.aarch64-apple-darwin.tar.gz/sha512/38632deb61b0bdcc509b6781ee8981697e2ed68ddf9c874328b8de613621fbdc04dcd8e8f7e839812ff3b553c8ace00c32bf391b1cd7bd01359df0223400b49f
-libLLVM.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/md5/e46e23c1cb0116a64d4c6c362f36c273
-libLLVM.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/sha512/2f3a8870ccc0a2b9f8a0a1a46a1e3add68e412ca63b5dd2f3179d5c3f20c1c387d93493b4e3523fa1ecfaf676ec13fe8b97908e26d079ee140e24a03ae4138e3
-libLLVM.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/md5/6b29c384991d030f0192cc21d8ba6b07
-libLLVM.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/sha512/c4f90df89d6315b93f574f0149c8b66185252770d7580a96728dabf9b4a3a66abf6f534b528540ddde791e6719e97857069c8b5154bcb134369253be3d51c052
-libLLVM.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/md5/d00dd86e4a94b22976c8674d42eb9830
-libLLVM.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/sha512/7bc5e67ddc45a481ed3349098e581eb8db65b4408478db44b053850b9e534b9ffde27674ec22f3600a794a7a5d334d649907205d58016e6984ae2b8ec675959c
-libLLVM.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/md5/f44c529d8c9afb2c6a5c555bb6a38177
-libLLVM.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/sha512/1c6c7320495d822f4e9ef209f726ef9793d130b28416b8ca7b60d124e5ea54d6a92d73596ae33078b00e863026196177f9ae291a338d00378169f4f0199f8fb3
-libLLVM.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/a49912cfcf61750103f740d60de921bc
-libLLVM.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/3f4d803d5eb62ec23558c739d3afa8bcaa7cf371171019950548d46a07e2e9be771ed1a135995960d7e8b344cd149abe4f50b547889a5b7d30a5fc97a80e6f33
-libLLVM.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/18b0841f11b5d3b8bd30c6a6711f3e84
-libLLVM.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/e891c7d7188593b1c99b8e84ed8b0d9430367886eb1e06923675f666bb206649f570b818080598cca21603693241b8f8474e268a3ddbc5e85cf2640a7648a57a
-libLLVM.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/md5/d0f7682d75992f21e9f4583632af01e5
-libLLVM.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/8f14d78b55a923e497fc72866850ec227ced1f600eae5b1f8060adf25dcc8382ebb4992474a1557b411f010e2fcd356168f2ada79b867ed5afeb82ec4a3fc30e
-libLLVM.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/md5/4b4030175961593cea3d63219cb2a5bc
-libLLVM.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/d3348b34db7e51c66c29e7ec835c5b8287a7f6f4abed97cbd2cae0b9ce6f975aee1e1eadea7e281cb6ac180de209deee277e1b7c2553b67dbf3faf5b0c00d96e
-libLLVM.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/25a752523cef3c8a0630ca80bc612251
-libLLVM.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/ea8257ca590509ff1fe3c1b8379305be067c257e812269ee4af5df35cca1176400e85502b17cedab20e879e082f4bdfb8fe1dd34d83e786afe1c9914931c61df
-libLLVM.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/09971322fd89c0b1102fdfffaec53721
-libLLVM.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/6b5b7169c96e7b7510a6b084af0d36b893a46a1c2c4a966e89f23878ac2e9eafbe3c21c062eed818f200c9eb2083261ba4ee76786af5ceb5f05621f79548ee7d
-libLLVM.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/md5/a7dd5765f7e530a40b72f44b5dfb8b38
-libLLVM.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/c4b119dd79a810001b81b4eb103013b8d7fb8443c060becc3900e6f7379b91e38b70aedeab980062ee53ddec04592aa6790c62bfc59c556423edf9b94218d060
-libLLVM.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/md5/f61a1d6e04a4c5c00bb0d31e997184bf
-libLLVM.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/831dbd3e5e16d4fe6c38fef6f2656f54b3532fac1c1c05121d0d35d6c9de328cd06329ab85f100975097211586bd1fcc3249f8e77661941c9746843d2adb0a6b
-libLLVM.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/md5/4e368d4b4901825f115a3e58483036e1
-libLLVM.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/sha512/0211a7213e1d5dddc64be17c39b330b12d7361613e0a798d007bde9d3f4f3fb7259df8212c1809a45759118ab36af4bae0c1f35a66e88a4195c899a6341c21ba
-libLLVM.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/md5/cacce4ec7289a2a86e9bcc91580a4a5f
-libLLVM.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/sha512/04d71994344fdbf60f01128e8c8fe3c5f940ea3bd72a5eff154d913298893bb73b399eeef1240bab779ba477a02b8ddb647068c76946fcb35f9a530d7fecccea
-libLLVM.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/md5/c242c47e4047bad01c15142eb6623fa6
-libLLVM.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/sha512/225b9ea08454ebd5b24ac1d4442023d21f4727072baa16730b23d71d0dfd1be713bb992868038f8e982af590f499bf6d2b4e64bd3cbff537fa41c1f8d271eb32
-libLLVM.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/md5/7843fcb202beb55d6aa87600a6d60342
-libLLVM.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/sha512/d8c9f6f865e2f1058bd0d3f5b04a799483f1a94336ec82161a8c26e8bf5070b714663cf5d62733c9d4006b9a6e145873a31198e780632f039dc43a980216407e
-libLLVM.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/md5/ea045ca69935f5035071be6ae719ee7d
-libLLVM.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/sha512/06a9b4f762bc08c827ec2d8bc6ff26ebe7af6c8d049bd1015f5d006d7927f7c6ec5d1310b0e74da59994b10c866d2e3358717e36d398d3c01a53455f5f94eaee
-libLLVM.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/md5/cbb10916045594f8c509d158bc9eba2d
-libLLVM.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/sha512/7ae2b3dc6e54bff8db71ab3208cf7d28a4c35819528d6cde17530e8a5509501d7aff18a75e851d93cb2682b0996d78f00e09db6ac11c2bd9bd57d349af8a3c14
-libLLVM.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/md5/f59fa032a3f5d8fda741a7fb2c7908ea
-libLLVM.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/bac6f46e34660cf8b231a1d68eeaedc82f77518296cad4aa6d54ed3661c45c02b3d442e30c37c8b4b8cd0e0701a5ba49b080ffc842e6b58f6f19375250978231
-libLLVM.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/md5/92f7fc40a1ffb473046d5493b329fa69
-libLLVM.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/1f0256620164ee67b6936fc2005a66dba889dae4c0f92b16fa33fc6a3b4146ad1b119db8569a50b1716e2464b0e4def09cc68cb81aff96c234717e507d64b3ac
-libLLVM.v12.0.0+0.x86_64-apple-darwin.tar.gz/md5/de7a0f428a9d6c53feb42cf1224744d1
-libLLVM.v12.0.0+0.x86_64-apple-darwin.tar.gz/sha512/f9f7adb7e80d2192692fae80909bd2a87d5a471cfbcab6e335750011b77abae89dbb2b5a81151bbc34739ee3828e3e84a844b46fbc63c279710f3e12c0369642
-libLLVM.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/md5/38dec37c1b969bd38739dcc88c795ede
-libLLVM.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/sha512/9b0afbe6119925a6a2d7f03208ef4676209e6c6532c78f0badd87564636bc417058097c2038108d6aecf399ae5ed3a8629d75a00f36277a7e97483da92a5c963
-libLLVM.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/md5/68ef2be45e6228a974215cf76c630a8f
-libLLVM.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/sha512/a8e48578b6ccdce02b3e03d7c20de8df90ab40ac99a029169c8dd15907e41b917579bcb0f677dafcf039f95c9be0395b2ee5503ac6e20d9ef62517b5a213f521
-libLLVM.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/md5/8422319066043fc91f69795c10e085ac
-libLLVM.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/sha512/e072e786f4ed2a891b251e43f6b62f6916c3f2d88afdde12a132a468f77281fe6b52438862cec25726a501ae76ee5d9e920fd5a2a8c2ede91999958c157134b8
-libLLVM.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/md5/1251650b38740bcf2203ef52a9dc07fe
-libLLVM.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/sha512/afa9b543a1930440b7e82aec6ff82549de6e1fcf88fa24c20e541ca66843bbf471f30fecc6af5e4e514cf383e91834c0cbbf231f0d97f2af9a99122ba13a6477
-libLLVM.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/md5/673870380f49f24097e9aa040bbae2b2
-libLLVM.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/sha512/88ba49a5063fe67bc91906d2b7d2044238faaa7a1ff52e10625f49d79a9d986de3b3a09b32e76f38f8bdeefadadab233ad8510881ed6ea7c4925b5d6c7396ed1
-libLLVM.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/md5/6ff0f20bad03e04ea511fbe99a4a8c87
-libLLVM.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/sha512/b0496090fe91b7d8485883b3643f170c4a5533bd6bd388ddbb04e189d0073e44ccb31caa2cdbdff49f430c1180dd8c0d1fbffdd2fee83e5be52aaf362c0cd178
-libLLVM.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/md5/1de026b6896ee464493d0b760c938faf
-libLLVM.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/sha512/113ff6c2a706bbd334fd6882f56d1238fe0decd3e80b528166500ac5f831bb321d078b48ebb1883ed0ca5ea22516a9b3ca49fb32cc21b03fa985ddf69208deaa
+libLLVM_assert.v12.0.0+1.aarch64-apple-darwin.tar.gz/md5/9b6a02cdb753464998c2108401321c8c
+libLLVM_assert.v12.0.0+1.aarch64-apple-darwin.tar.gz/sha512/4986a37bdfebb17a2c70f3e24dc104a2b9c48fda5149e1e8f0df1b7139689e09bc6f5438f34e3fb6ca1ccbae57792959e2ca6fe66b267a2081df6a999cc11d35
+libLLVM_assert.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/md5/4e6d298d5680c3a063739f508561e357
+libLLVM_assert.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/sha512/c70ef95a4e3c571b119f8d623b17d98591d268f7242c024e33b87ff80dc6cf96a7589c5e4e528d4f3b54fb8c7b1b6653873b4ec7a94b297524b9fda31dded006
+libLLVM_assert.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/md5/941d910dbfa4f7339c942f547596daa3
+libLLVM_assert.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/sha512/486a01f9c8f632b6f84d802b00c443cf9a5fbcca61ea7cc392c9211c71243e39f50ae8812dde7f5347965e0aa9a8dbd73a4988d780ae77dfa04fe329359c50dd
+libLLVM_assert.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/md5/ab8f2a3167d192a933c86214c275d1e9
+libLLVM_assert.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/sha512/fec5e2ea1398c226cc9a3c31c5041f9b4e111793039f7cc373ff47e86e72685a4cc254ef3d42db7cee239a7422f56fdba513f572f5156f8dd6c286c799547636
+libLLVM_assert.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/md5/dce59160064ef20720e2b97e903dc829
+libLLVM_assert.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/sha512/704d2007d0074a87a2c780e6b9f38117cee75a9e3e7a84edb9915962d7d5dc92453dc8ad3f2a73404173b7cdce5759f7764011452b9dd0da71053fa87bf89be4
+libLLVM_assert.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/e8e483bea9effe1a43cb14eb32d2edce
+libLLVM_assert.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/709e10ae71641ac285380a73457988df8745d9baaa1584ef67871daa42ef16b568aa93633f774a9d4541ed1cefe49c7614b295f16da6fab91e493a2a58ff7143
+libLLVM_assert.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/2ef8f91e7df587e2bd8c73140c29d771
+libLLVM_assert.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/6b16d86a6636b070924d251581ec01df759197e642f8703111869c2510194b40e3dd6d56e605208d9e4d1a0fbe96709d56a9d065f3111979c989cda9c44093f4
+libLLVM_assert.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/md5/7ae9c70790aca9cc9ed2dc6504f44348
+libLLVM_assert.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/4d5aaedf590343bb788d6a8cfd714d3d659a82e44c411d93bcd8f524bd0563dc8ac2ddfafe87b2c762e7d9f22a1bc6cf7a331343738e7a38c246f41a8bf24d64
+libLLVM_assert.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/md5/2be0d9c87322bf63d3081e434b3b5eda
+libLLVM_assert.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/45bc193f86093e479710455ac7bbd4e853537e2d22946a4c30d942a3f2f1946b2156fd80282f05a3fc73a65835d06d372b76ce90685cb4f1ca31606d2481b1d6
+libLLVM_assert.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/7009d45f00f0ce67ffca15a59ae0b682
+libLLVM_assert.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/5030c05e5b91d1fcaa866522ebabe0f112493fae9aa64cd3a003266939093bb422320f2cad31c19ee1989f5beb84781b1b54090b6a4c2a8fda3e80809ae65160
+libLLVM_assert.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/cd92d0ea3f9aa34c834f6ba9c5d6b199
+libLLVM_assert.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/b79e5f42890712e2ced99e80e1827aef0824568c34f029ed94142a29b925375a8e85d305411e42d05bee1959863906f1958485b3fb982b022cf567871005e20e
+libLLVM_assert.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/md5/406cc9431dde64b98b7c2cf0d44b8528
+libLLVM_assert.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/426a99f9b4eac3835de4a1ae3f49a23c342f773af5a3c4c6354cb27a120f8d83513ac9dbdcd1040b018ffdf6f5092de66fb37a8eacb07b9eed67a1f6da411fe1
+libLLVM_assert.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/md5/c6d6c5e91e33fa326763034b58c9c306
+libLLVM_assert.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/7b2557c766371fc12172ac6469624fd7452e2be49c0ee4e0658018e1e779122d89cdb81fddf8df1374ad17286b96e299320d076b2527137680423bcd3a88e5ae
+libLLVM_assert.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/md5/8f3acc592c604ea386488a28c12a69f6
+libLLVM_assert.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/sha512/049d11ea4d44a60037c25c8893a336358f2422a4ed7d350f0212736b040b7af2d50fb80681d20ff58c220f9bc4559cc2b70ead1efa923cd0a36b12f3673f343d
+libLLVM_assert.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/md5/9727f0bd0663847095a8f4574a87c318
+libLLVM_assert.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/sha512/0d3a344b37cc4345d31612964f95674b18d2d41dfb6314d12c88290772bc9ed5d15dd90c2e8940710c1accefa368046c626d12c42297de162e24f08653ef2a6b
+libLLVM_assert.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/md5/9bb55b1d0e0e52443296b96b2117b6cd
+libLLVM_assert.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/sha512/02450ebbd012aeac1e86ce22ce699dc0ebe75748335ab37ef854d3ff27d08e5762a1addf400e51aa26dda44f16c93e7b16199cc6d8e4019736bb0138044693cf
+libLLVM_assert.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/md5/f7bc96ec83a87233c3eaab79f117f9b3
+libLLVM_assert.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/sha512/c398b9684ea06e1cf4595c30eea69bce0623f858647ff686a6592d6d062479cd1ae4bb01367f7ef156ed75457454e6f4df7bcaceaa2f3f50ebdbfe2777f326d0
+libLLVM_assert.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/md5/b495bf59b53148178937ead404f887f2
+libLLVM_assert.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/sha512/ec5e2316b846e436024c16aec6a271f23ad7879119660488509e3a88e8012e1b1592f492696d645b7ec5b2d710c9524100a186df836ff03ed9b8728b009a381f
+libLLVM_assert.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/md5/57e237b29d01266c97c2dc716f8648a7
+libLLVM_assert.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/sha512/742eeba173b2ad95b8ac9ba3b21afc49a081aee6ed12607d1e17e648310372dc95c5f839cac8db74a49a0eed8b82700922176b55a57b3dc9ee4a820da9816283
+libLLVM_assert.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/md5/5d1c3f5cbf94df631b7f1a73a0a2063a
+libLLVM_assert.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/8072be35d0ab07d853815ccc84013f76895603297bb4f4b77b22fe538467b273a6e6918486db8170f7e2ba2507b5e36ef42f9f321c797ac5e871618d3372ce66
+libLLVM_assert.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/md5/5d1ea307a7481ca0393f88f3929de53b
+libLLVM_assert.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/c62e3f7807390144f65cf9081b3f6710c1022f260a2ffda0d7e72583224cac638e87655d472de2490ce465279d79edea18a6fea99b6afbbdd9a427ef5d6439ad
+libLLVM_assert.v12.0.0+1.x86_64-apple-darwin.tar.gz/md5/f7764a7eb7bb79439bcc8a853dff5b22
+libLLVM_assert.v12.0.0+1.x86_64-apple-darwin.tar.gz/sha512/b1cdc7f1078eb07e2d37482c96b14c288f6c0d5c0860854e02c3c1a407fcb66d4f03abccf1b74b7ee9a6eb503b3c60e67e7ed75ece765b385f17c6f502a5d489
+libLLVM_assert.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/md5/99a5965cc849e3dd79878a7c6b29b6df
+libLLVM_assert.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/sha512/9b138f955de9266ff364022f53b6b8641670a8221e0bb6b61d5bbc9151e8c4ce08c61fcb90d6572c51853723f53c6b6afebc5c4e17e6e33e39590c53c5206f91
+libLLVM_assert.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/md5/2a27b02a388679164b58dbd853f5145a
+libLLVM_assert.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/sha512/febee5224a7e4499509105c59365eca340526e002f12395bfb2a31c944fdaf89345fec971c67874356c8235abd14bdff3d7485c13bb4af944105dbb43b2d665c
+libLLVM_assert.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/md5/f23b627174133dd8e94733c6bef0ac89
+libLLVM_assert.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/sha512/b7b2fdc4d154b2e1aa805a98d6b15c6a88a1dd59812dba1030ca0628192b993c965ccc7e0aefb723ce6ce8ecd3a6788fdd0cdcdc5c966bef55f67834b056e52b
+libLLVM_assert.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/md5/0dbab594b2066ffdcf4c1fe47612cab1
+libLLVM_assert.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/sha512/86e4d06a6c52d04175d8751cd84cfe1896ac66614aa92c7d60674a3ba49aa6a68e9700cc8150abecc7acdae4786d9899eb052a015a902a2459858156b0ffc2cd
+libLLVM_assert.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/md5/5b39f69421ab3c5a234436a7b8430c82
+libLLVM_assert.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/sha512/2dc735103c4c4eed676a149ddb8d4959ed8c6c00698683b5213d22661d5a1c079fdaf2c21196bf5d4e3841692bc09dfc4c8b723d808b33b94bb06a407a8ad809
+libLLVM_assert.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/md5/21bd6a1e696b015a880efd795fa0e136
+libLLVM_assert.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/sha512/218bf452d5336d1ed69879b33f50f92f0118fefe21366733746cf50d6accd7b0ce71659233470f1f3eff26180a5245550b2c53b2678ded317bfd0a5c2a4fc2df
+libLLVM_assert.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/md5/cdce26125c4f37ee3c9f92cdd7598da5
+libLLVM_assert.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/sha512/9bed9f8b1fc7f94f67aa5d2496a5081ab594d3210b93e5ee1f71e32bb053e87229afd783d34c8d048afbd396451c75c82b7c7d5f60d018b7325f703687eaa07f
+libLLVM.v12.0.0+1.aarch64-apple-darwin.tar.gz/md5/4ac10ba89a464473457448f2f697abc0
+libLLVM.v12.0.0+1.aarch64-apple-darwin.tar.gz/sha512/ee80c94d8a4c89910d170a9781f72bc53e0b3e3b853157d0830b16626ba7d188d4a3c1c7b723c4c4d428676e4f8c3120928dc7b59a5f950d096d25b5d488ed31
+libLLVM.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/md5/95500f6f9eef53d670fd77a6949d43b0
+libLLVM.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/sha512/e3099e8587aa36785fc48d05691236c62c7121c953f645ac5fc7d9068127c8bc7e3aa48f0a1ec8a994c3729f75ae3bf155baaa4f1c7e761860e38d7f89d29117
+libLLVM.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/md5/a900d9889fc22a19e005e550f0154709
+libLLVM.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/sha512/acc1bc5338d8ded0898818fac5b3a1e0528df3902ae9e4062ce2db3a769ead7168ee152262ad98cfada19941f9c49a72fad7e356d1b7f046bf0a05db83af3f9d
+libLLVM.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/md5/4d62b2d7e0de328a8f1d497acd9dec4c
+libLLVM.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/sha512/6c199d25f038bb619e8c7449d65dd61be4d264109acfe5e694881bd7ae7d207cc714bf3350442c27a73a0d3702a5ab386c90ac6c7147b3b0b7de862f28584e74
+libLLVM.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/md5/52af995cd60019b0fc607f7d89d1db73
+libLLVM.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/sha512/98c412b6ef5d12f6a0fbf2b9a848a3e26ec98f9eaafa9c7048d52164df69716aa2ce172e546c56627d208e9aff03f1fd0b011eeed842cbc92280bda5c42e1e5c
+libLLVM.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/ba0a2f3e9ba09b2081062437d12c3b58
+libLLVM.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/a4f5a47a876b660c1d08805ce296ae59ec65dfa89334542cbbdd696909b2be8697b104006f365ea404c2967928dd5580bd2c7d9a03f3894952742456f450415a
+libLLVM.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/d2c4da0530fea40e082404886e86caf7
+libLLVM.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/a66ec214d80023110e281b2029d9dc8ad61a1a3be9bba96ed7d5bbfcacba76d7359c152982036d317d383a390e27a6eea969d6bd5fc50ef7b879dccac5dd320c
+libLLVM.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/md5/abd5d1cd535566f61ff0138ca852b771
+libLLVM.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/f247d4127798576e0a39cb2b78c359c30679b2f5ade08a39973989fbd72387a06ef35b3421c4ebde564240776a4be9b3a24f78eebc22ea192e72941558264093
+libLLVM.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/md5/abbe7e449a3a0d78ba320b0cf9b98534
+libLLVM.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/8b2b50d972d76b18938856546f7fa13b243cffb348f64f0c528668c1ad6e28bb03f3af05fa5af8ca01a4cb12062719665fdce6018c6141ae7bdeef1cb876351a
+libLLVM.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/a5d0b33472dc32278cacc0b5904aa569
+libLLVM.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/501f6a43cd75f33056723781becc40fa1babab2a0e720700bcf4708782cecff20140d753141de8a2bf06fa8d97360b9e7533a3947a5eb39453fca5ba6d94fd15
+libLLVM.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/b9f62938d21eef15bf58b799d06f049e
+libLLVM.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/6430c18e13c7f97c2b12594d6ec0afee9ffc8fdd0e1608a40df79345932b9739bfd8f7d15b494bd576784b12b4a1400c9fdaaeb350f74bf2f15a3dd66bea4d4c
+libLLVM.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/md5/c87fd44a812346a6c471a7992c1898fb
+libLLVM.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/f00d6caafc3298ac8fd7ecff937e453c97e41167dc2e0f43abf83cf6b899380d1db70e74245ebcb1bba8022e0f86d30dfae214005dc6b02232b0bba6045ddbca
+libLLVM.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/md5/260f3e0ed2bcea0122f4c104cf115661
+libLLVM.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/3a853ca386e8cf578d92ec55c824e0e1b6ef8551dfbd4bd042f81e3063fc9a1bd25a3a3b182444e178e34c4a477bc4293a3b4ab1eea1915f9c063c396c548ee4
+libLLVM.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/md5/eedcb1470ba914c6df43d41aab2f336e
+libLLVM.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/sha512/4634c7bdcb1a7ec31d7f629da1418dbf7c2da8ef35c59daa8acde5ddfb04acf617e60368c1ddf21d7ce3684f0d091471264107a3674ac7cb8eccf05e8d7ef82f
+libLLVM.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/md5/26854ac7b1d8b5cc516310c6f0603e28
+libLLVM.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/sha512/2579b123cbfd7f306747ea0eb9830228b330c2443153dcee3d97388465c974cc1b67ad729a5be8519c31e90a85221c03c56dc244a202a190cc9b54b1e9b4bf09
+libLLVM.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/md5/844eb964e50bdcca7c7c046bc3f7be99
+libLLVM.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/sha512/da0f995f96f060933f828a38c1d1b586ee5ec9a97f22626fb6297d1da7c9be4a79fb17b5207f51e96b0454c9684bd7c371a0f43585e135ccc28d873ca9215649
+libLLVM.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/md5/b3ab85c5a4d2aee0aa07d75e49d35f88
+libLLVM.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/sha512/b1656422f172685ebd8ef090ecf4c06f7364612f4b195820d2782d5252dc965322b66ae3f0d42817685a12ba2460e66ea201bf2bf5e48199156c4f124862097f
+libLLVM.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/md5/619ef68aad7d051b32777551b6465432
+libLLVM.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/sha512/fdedb19322bd216d6aa4908afbc99b0789424c6b27d6be7769c9b1b80e35ae04b3da290d7a5002bf95bee725684d5c8303b3fb762807cde5b5451b5a107a6e5d
+libLLVM.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/md5/9a62570aaafc78a52bfd0799ef27d38e
+libLLVM.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/sha512/3b629bb4611f6ec388c4ffd03f2456780f41528f6f99446f2a0adb35c1953921641d2fffed5224817dfe76a6faad832a11267e57b01469959242ab34d1b1823f
+libLLVM.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/md5/fea7ed9b9d20e76d2fe31ca3e5cfcd3a
+libLLVM.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/5448b21d8746f15c8c496b2123963c4bab271770003bad45150e93d6dd69651b604720bfadd5fe95a9034cf5bceb41c2f85efb0bd3420bc2ff0c0e100a51f10b
+libLLVM.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/md5/04700344e64312cf3d8e0cac982e8a33
+libLLVM.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/f89b350716508a9278ebc64cadc6cac0f7bcf76e966facfa6e8713103554806d8d788d2a8bc8ad7f8c21d5ddb3e943fa11db9cf51aa24f92302d4f592fa5a601
+libLLVM.v12.0.0+1.x86_64-apple-darwin.tar.gz/md5/37dd7c11c6533af26774c8d60f47b944
+libLLVM.v12.0.0+1.x86_64-apple-darwin.tar.gz/sha512/793b04f255546fc76158b21c1e8018700416341199c2681a14a3bd28f9799fe2e7bab40b05421e6bbd9bd08608af3db705e14d1fa52f213821a8a80c69d2ccdb
+libLLVM.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/md5/88b02af758c3373c026f6c727431a1aa
+libLLVM.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/sha512/eb29edd8b35417adcbd400fa5c0327d5c03ca014e6699330d08488c4d83d10aeeb21b60acfc51f5fc05c9fe46a048edd12702790cbd731db653d06b1746e5650
+libLLVM.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/md5/c3c759d8706cc339077d2f084f36d6c7
+libLLVM.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/sha512/595edb80d42b47835ae435526711ec3fae39d12fcad28e1c2abdfb3dd414f71c7ac3e1ac5ac16c25e7e1c0885c6591358ed066d9be0d701c17d155fbc0f9f701
+libLLVM.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/md5/5e297c6897cf1bc9e0d5627a31295473
+libLLVM.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/sha512/3a18eb2fb891071516fec4340809eb511369f70674c96db02558ea07f3819680f4f63cf20fd57a76293ed9c18746b3c2572cbd1b1621721142e7c4526294baf8
+libLLVM.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/md5/a3f0facc8ffe1a806f38a7441e307be5
+libLLVM.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/sha512/751a55ac5ecbe328097998c6a9c57198cf326bd5bbbadcdfc3abdcdbf6802b4a039df8a6a5020fea911fabff7eb113207e87d4fa1a7debef59832d5aa9e10846
+libLLVM.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/md5/2728fc4d132e5f6e955ca684c75dc021
+libLLVM.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/sha512/64b28ec60e564d815f3554f363e70770cec9936264ec5c3022a422acfff836aafce0d7bd3a83819735fec203f62af43e84f8770b89784f3a8e71890d1bc900a3
+libLLVM.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/md5/82abd763588375fa58700085edf4d1b8
+libLLVM.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/sha512/89de803c913967c087851197d18f2ae9d6ea10c653b3988ab77edd1a90b94073fe2477f4291f10fb9496dd5c77c952e7358f68788d487989fb164001b6522d41
+libLLVM.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/md5/6805ae4e8276b1e774decc8d755b518a
+libLLVM.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/sha512/002bf892daa13ce1200996035ad7159d90c5f5974989c5c20a4ebc74c0f82553a2d0198459dc4ee7f7363cc3d10e5b11bf7088bd1288af9fac0cce707de8452c
 llvm-12.0.0.src.tar.xz/md5/ceab21c9081e122a88d82216a80d0dc0
 llvm-12.0.0.src.tar.xz/sha512/ec17153ef774a1e08085763bda7d0dfce6802fbaa17e89831695ce1b2eb015a6c2aebfaa9fe7985a83b9c51bd75d40bb4f1fc706dc16d4c0dc2b2722a1d8a24e
-LLVM_assert.v12.0.0+0.aarch64-apple-darwin.tar.gz/md5/9c1db1cec729fc7f9b65a135290ba820
-LLVM_assert.v12.0.0+0.aarch64-apple-darwin.tar.gz/sha512/684f8fb95bb99fc672d9ecbac831f3d6a68e906c8f0050bdeaac522f8b3ccedf8e54dd23667de3fd0c03f241471df221cd0a965036411b523b0e4016be89e896
-LLVM_assert.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/md5/1e84cba3d675739d2064ace317e8852a
-LLVM_assert.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/sha512/2bd3cac963c0b54d23b1471f26b892c95400c2adea45be4a40dace6a0a456297c44c5edc2aba7d977c6afee1b8ca41c43171b8d99e04fa223ba9df877b8ec614
-LLVM_assert.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/md5/16a1d1b3006b5181e3b27c01775865b2
-LLVM_assert.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/sha512/6c34f0d2d30965a1b826edf98031cbe96cb480998816d351eb2e361acd868d35c11249da0a9273469aadb7f55851e97cbfdd1f5536fc9d7310410c192a592a23
-LLVM_assert.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/md5/b43babd0f88939f70f24d6ba6c42d93f
-LLVM_assert.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/sha512/5aa5c686ed1d75bfff26deed4975eee7eeace2516c93e2d2a88c86d2f88e67f894f24d777d3891dcf962281794143eaca720eaa8dd9c774da3b69346beb50a04
-LLVM_assert.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/md5/ad72b54cbca417fb2fcbc22885315c51
-LLVM_assert.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/sha512/f2d7ddbecc040c8ceb4fffe0240a15a8b18b697ad605fc8c29e16f8502e72e9e8281bac4634e84f95d86ea5cc3abd4fd0fc437b3ee986027bfca6b6efbf39d54
-LLVM_assert.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/176daaa135bdae4140cd64699500af7a
-LLVM_assert.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/c08598773fdb8cbfeeb4e8b6802f90b0139b89e50d7434a7976c36416a2378db7873f49f81810204291c9edae72d82f3716b61df36411b0639b148fc838095fe
-LLVM_assert.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/68c15927b4db3e2507b89e82f3332757
-LLVM_assert.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/e8598844215ed87fe6a1be05465e80100f433d649b4fabeace1de111626577a5747fc27b109de532c024cbd3f3e8261df0d4bd0eeffdc1928354f1ebf501ebcb
-LLVM_assert.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/md5/94cb1baaef471aaa4e07a2a0367caca9
-LLVM_assert.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/bb440e622e2da9f194a2804933131cdc4c084dd27567276e90a6638d6bb15d726abbb40bfbcb81d9934ae2472f1267068bf4f40043e7c928d12316eda66e4806
-LLVM_assert.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/md5/1fb3a0ac1d0511ebd20f9520050a5f1e
-LLVM_assert.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/5453dd469aaaee937d2a89c03fc382c52dcc1742070e6310f2394d4753fdde32bf91fc51e078d2aa00f3bf78cb73ba4e5721e008f84428e1269549af04689368
-LLVM_assert.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/c6c7d20f7bae0e4dd52b538bdb0ab1ce
-LLVM_assert.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/cc1f792fa7dbb91470106d84c168c3d5e3c519079c8514039fbda8692f987ac994b1cf8d6b96995f47ab32ff55cff42bf53d278a78b21378ebea9c03f1b53d43
-LLVM_assert.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/c2fe748bb8e95fc1c22585109c372a37
-LLVM_assert.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/f94a13e0da4a51b4e3f3697ce88ff2ab7d41918e2d25894cb6e41622be9f3c888d6715574e8cbafc3a20bfcc2164a1c9b417c2c66bc420b445e11c5265a96f7f
-LLVM_assert.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/md5/ad087a60c33f5eda018ab8e2966bbfa8
-LLVM_assert.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/d0a4d1eb39491eff08c2991f8876a4e097071b337c4a5ddc783c51a1fa109810db67c5edd2e9b6dbef7e7fadc78224ab45864bee8e9b9e35f0325e49bfdcb6b5
-LLVM_assert.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/md5/0015dc719aed7ac0ce2bd16f11bcf53c
-LLVM_assert.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/de224f36068bce30adb7472e40d0b3ba3e3fe739fe9ed62ddec825fa922bdd075dc081401cd55abd14a303551ff5a047cc98b2a077f367c105953c8e27764d86
-LLVM_assert.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/md5/f9ed12bd7fe3e616016b81bd3c56caa7
-LLVM_assert.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/sha512/9287a724fc4b0a0c098a71c4ff4aaf50c3ca79120e13b3ce718c206a0dab1f239137175e6e8b46559fecb373650ddd8224e04194042eb62c974ebce84ace6ebd
-LLVM_assert.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/md5/04dd433225feb65b499bee9b93698265
-LLVM_assert.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/sha512/2e1d1d9f5ded294890f37dc8c2449d9d66541d242d3aea76f3f170cb319be20b3f7d5a296c0631b6a8b713627c8f952c07de9151e88e1ef4ecb9a6f622595cb6
-LLVM_assert.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/md5/2cbf070301e7ca4a54ddfbd4420f18ae
-LLVM_assert.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/sha512/5a7a2212d0e99130b9f2dca5311e2ac14622976f8d129b120754df9c130047369e2bc57757e8b0bd48430c0637dd886fc85b2143e233d503cb4c92b6bf9735b5
-LLVM_assert.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/md5/ec1eefe92eb1a0ffc08c2761f6bd0ac3
-LLVM_assert.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/sha512/6e54c1eaa55aef60c8a98e3870c1e18392a862b79cb482cc92e7346918cbf886f0845c6bcb0e75dade163bdf60b86d6888dbba30eb088ff0d4cac04624abb2db
-LLVM_assert.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/md5/9b282bc5b379138b634613dc27451588
-LLVM_assert.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/sha512/7969075ec1f8a367bf14cc19185bd1ac66631ddfe8faec955969600cc5e3548a82f2775271cdac71807df7f0fe38106bc6ba28b60514c9461513e9cb9e39de59
-LLVM_assert.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/md5/c2af10728a4cdca9223f2769a5b41572
-LLVM_assert.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/sha512/4ed5303b5bb58fc6fba82c260f368398ba7df17ec9cec8e1ce9fe5f608e19c67cecb62043cc8e20599210d6c438e2d29381ec9d3a8bcdeb11b7676022f21664e
-LLVM_assert.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/md5/b8d7c5bc69c532251738e123124a046f
-LLVM_assert.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/82bff8f8afe76ab38300a9e7fcba93ee07191230c1b2a0ee5bc98c6a1c94899a3da6eafd113ce7d938c27881f2af571534586e4adcdd1ca51ecd399fe56cd484
-LLVM_assert.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/md5/defb081814ccc0cd6732ae3e3cde034d
-LLVM_assert.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/5dd21608cc271d9a4d065bb336301d0e797cc40ed7fdae3a4370b7ef0f93d868e784e8c79ef37ec33b057a2eb86d07720bd0d7c178c9c28f4368724a5d0783d2
-LLVM_assert.v12.0.0+0.x86_64-apple-darwin.tar.gz/md5/212f317b4d01dd033e1eaada7076bfb2
-LLVM_assert.v12.0.0+0.x86_64-apple-darwin.tar.gz/sha512/19a222b4d1a239219498d5a4d67142047e00746ff6548c7adaac40196cc1b3088e320f26fc8c12b2ad41eed37d6dc3738af61a1dcbb81ac42f28e6bba0da1d54
-LLVM_assert.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/md5/5afaaaba76df2d7d5a1c50d51ef45ef2
-LLVM_assert.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/sha512/2bf44283938600faa845b0b8b48f08d1826f80e48264fdc95ec828593afa8e592e0e697cd5b9e4ef959200a776ef3f85cf9c35e98fc908f526e082d4c4b4b340
-LLVM_assert.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/md5/aa41affb6459858a9beabf583842134b
-LLVM_assert.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/sha512/3b35ed3bad9c7e88c3d937548bf9af24b270c1faf4aae9ecaaaef8000b02ef17f90d425f7506a9716c1aaf3c7247472d2098ab7ecbdb4010f478602a2ba9c5ff
-LLVM_assert.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/md5/0429e7474dc3d250b0fc8772beed5b5e
-LLVM_assert.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/sha512/13c180d03d337e911769793bd4624b75be846fb67d71aa0f0ff837c232e14d5d016aaa2fa2b986676297f3bbcc2599f104ebf4877e7110f92888e5c4d95f9ee9
-LLVM_assert.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/md5/e4403471e47034e849cc66610724cd50
-LLVM_assert.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/sha512/957df75539a723b680173d823bf96e542dc4cffb4b05b64783a9d60f0f0bafc1b0d1113fb9c4ae25ffe7e36c4764804a2f98fd9cc2468e2af3f1fa0e77929788
-LLVM_assert.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/md5/070bd8e25a76b980564f9160bdaa66f3
-LLVM_assert.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/sha512/c7c03229c34dbb715e2c59ce3c9d404f5b6a337506952bbee594c2109a0824c4962575f8ae9801a89a30d5569a85f05e4c1c4fd231ecdfe36d3ca7488799d3c5
-LLVM_assert.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/md5/1b7726c382c08e3e24fc1ec35b8c015c
-LLVM_assert.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/sha512/029c084d83ee049f45b1026757d631751cd2edc6c7e10deeec398baab792e8cce366fad5c971a120154ed2b6cd28b6659090dee7402e8f904bf43371b4170048
-LLVM_assert.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/md5/2c6d5945a5ee5b4d216acc6fdf22b54a
-LLVM_assert.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/sha512/f086e0c58eff5560c23bb9444270005407e66afeb969b4e5bfb1eb041a3479939ada7014c696e1dc50b0aa2717928887d434941d5266bf16264375dd3acfb67d
-LLVM.v12.0.0+0.aarch64-apple-darwin.tar.gz/md5/8837684991656303d1ccd1da16cef6ab
-LLVM.v12.0.0+0.aarch64-apple-darwin.tar.gz/sha512/de2a74fc6c305a8353168ab7e5849706e29fd4b66936bf4a8b6b9cf9dbaa2b7c30a30c118cf59f1421eaa399e7b5a7efa52ccb9ee4c2ce55c7afb9ceb2050a23
-LLVM.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/md5/4597b32ca87cbab6ca3de44ad0ff33d9
-LLVM.v12.0.0+0.aarch64-linux-gnu-cxx03.tar.gz/sha512/648233efb5037da8928e6d584ce7c0176fd41fd3ab66ffc36bc15fa0829bf4b19d554fdbfe7ad6d1fce28be5d66ee3e650871f4ca0973afeebb19ca4aa0cc596
-LLVM.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/md5/fa65be0be8c747801bf518e036d6b87e
-LLVM.v12.0.0+0.aarch64-linux-gnu-cxx11.tar.gz/sha512/cb9d926450b9e2d805ed3cde63db738eb4bfa2073382f52acdece2ca46019da0205b305db10af8feb96832016b0d10ad766e37b7f986541ef07b3877526a745c
-LLVM.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/md5/d8ada1b149428e1b363a3776208778c0
-LLVM.v12.0.0+0.aarch64-linux-musl-cxx03.tar.gz/sha512/5cbb49cfa03aef5f455a282dd76a7943d0a791bc3e2818d0e8bdebe3b072202a35d1a37119bf2fbb8082f18af99c1aa935b1f07b7a8a6ec3d0fdf05d7d7d0f1d
-LLVM.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/md5/f7af27355d90e71ed8d3b643ea058801
-LLVM.v12.0.0+0.aarch64-linux-musl-cxx11.tar.gz/sha512/27043b1229ae05e4502eff589a04469ede3f4b701aa62d33f69c9cb57ec5c84ecd1c1a312a3853b27a6f32281c41b62098b623a6a592671a7f53947eac7d955f
-LLVM.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/0f19ff6eb5d6874f386a55dd903a3808
-LLVM.v12.0.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/fc57dc902c574701555a86b404fa07ba676252b405cfc130fe253adc7bba7518ebeb6e984846f1a75fc192292fb5f546c3269960419351991aef74adfe6ce30b
-LLVM.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/bb054c404683edecdcaa8b4e6c5d1969
-LLVM.v12.0.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/10de5dbad00bd92e47c6a77d249e45ceae2cb790893c6472e91a8ce9d8f3f03f736f598d9930bf6bb53411f490f971559b281ef38b0cc953ff3aab766ff20cbc
-LLVM.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/md5/81c6b866133c044922149e8da3330234
-LLVM.v12.0.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/b56ba063e89320a72e4db45e1ea31ea5f2238d3f317f3c8ea042a36b312f9c4a02eeb9da722cf34aac0e7d703c66d996b0f2c0c8b0e61b38e1e10d7c6a872270
-LLVM.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/md5/0cf3669c60ccb6304566a612ec84dd96
-LLVM.v12.0.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/a9b91abbcb1130e3bf83ffffa7c74e74a663f12fd79c1429f804af5d2a6dc71863bd387a080153fb241488baf9d0c9a3c317c92c7c95553fafb6714463b65e4e
-LLVM.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/971bdc3c1e5f200d6d5e0791de47fc8c
-LLVM.v12.0.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/71d50e5852892a8777076022dbe615c49363bd2321975a0fe93202a93518a9064c805966eb2b09783fb2679b589059e8673072fccbcf2110584b25e4174db365
-LLVM.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/2352473188a90f6b1df3613ff9f162ee
-LLVM.v12.0.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/6f0e5a8eaf0d7976d31648370423caf9518f44182cd45fe7732d918d4cb2fcf302a5e1deb0856beed3064230e41581441a2ca339db7412a636c930e20bc8fefd
-LLVM.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/md5/6e9d5b4cda3fc8faf5d3b82d384e69c5
-LLVM.v12.0.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/ea0ebee79f685ea25d2be85656ae21cf18dac72874342ff960b6fbdc89c60383a2d6af8f36d14621cbc9bd534cbeb0f8a58c791c724e5469aa48d50606c2c08c
-LLVM.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/md5/4ab6e621226d158701368af6af0b8c1b
-LLVM.v12.0.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/3ead9d5227bfae81251d5327c98e28a4f888206176835626e24603fa2638354f4bd0f9880fdd14919091c756a9ee5d0901d76af8555b67094cdf7b6094fb2afa
-LLVM.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/md5/799676b765c76572ec4217fea32a569f
-LLVM.v12.0.0+0.i686-linux-gnu-cxx03.tar.gz/sha512/6a712ae86de5bacacbf805f9f53e7274a9f25c8b0dec28cbad756e6ac3e190ff1e6576a1d132659208f114cd36703bff0f049180b5e1ae7a49e05175db1689a4
-LLVM.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/md5/a14269eaee410d35904760ee26029a13
-LLVM.v12.0.0+0.i686-linux-gnu-cxx11.tar.gz/sha512/bc5208ed6d365da10e7c9f9b4a771cab0ec7f2d340e8c35184e80ab093b7b79fc8e2735e6baf7fde6e7f4910d0fa893012c3635291528a0575ccfeae5a2baece
-LLVM.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/md5/8c01b166aeddb75916a24b5bc4a5288d
-LLVM.v12.0.0+0.i686-linux-musl-cxx03.tar.gz/sha512/51b6436452cc3dafdd0bdd03852a3ba131740b8bc701abd50d5123d08ff04b8be03051192fff26ccc4c446a3d1b08981fb66619c080d9450e52071dde62fa31a
-LLVM.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/md5/b95bf3b5d2a0db37ff16fa6dceb4c55f
-LLVM.v12.0.0+0.i686-linux-musl-cxx11.tar.gz/sha512/9fe5a3c4fc758c25eae7fa8886607e8cd926f6d15d65fa1dd2f745a38d885eaf248c2c199cee73bfd25bd98e65392dfde2004a9c63c061aa2c7d8a465b469b0c
-LLVM.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/md5/f714f857ac90c159a390d6f5d761e067
-LLVM.v12.0.0+0.i686-w64-mingw32-cxx03.tar.gz/sha512/4befbb7f17f717669eb670cb18b9e60026c84722e0b8d7b4cc91e27c8c05b27d7b04b50b2ef20ffaf30cfb785f951836d08ec824f6b8fa95ff6b30d21c252212
-LLVM.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/md5/9648a00d069ed91628d0214366df6477
-LLVM.v12.0.0+0.i686-w64-mingw32-cxx11.tar.gz/sha512/a5fa4c4015e1ad450767f694cf0ce701aff5c3a20916745f60ad788f933029418b8303dccfe818be482862fb59bc889d8c4c0ffa3f8104a1f957a8f5578bb442
-LLVM.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/md5/1b05656cd5ea85d90c0ff7e0f3d2bb09
-LLVM.v12.0.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/070628a05d0beb3efb12831725db2da0b55910180290842b63373a39a73e305a6c87b91615ef7f31dd771813e32d6d93b6260a2200ed62ca14c04bf713d775c3
-LLVM.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/md5/0c41e6d77cea62b37d2b04cea3e3e865
-LLVM.v12.0.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/ec6c2a9e4de3921a2237ae0deefeef084713a0e8afdac63bc82a6ec4954ded1935696ada3e452d8c3929320d33a7ee6a861f3ad969e740e313639f72eaa33678
-LLVM.v12.0.0+0.x86_64-apple-darwin.tar.gz/md5/d716a03e7300f2c8b6cfd157baf82841
-LLVM.v12.0.0+0.x86_64-apple-darwin.tar.gz/sha512/be4bc5164d80db972cd4c0ce7e4325ad058243cc27850ca288635d191c0ac3b3428217623a01a312cfe4700a2af014eca03e06f4a345f52b5308185a38a2de65
-LLVM.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/md5/c4ef15b188097912a8893395e079d6fa
-LLVM.v12.0.0+0.x86_64-linux-gnu-cxx03.tar.gz/sha512/2f06bfddbb907de527517b4a455bb7398b36a7bf9f72fcad778f2586425cbe90be9b3eb9d1cc03ff6b7e5fa6d04a0a06988aa9d2003e748163a7e7460102ced7
-LLVM.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/md5/3ec8ed370b0995c3fb3062768d9211c1
-LLVM.v12.0.0+0.x86_64-linux-gnu-cxx11.tar.gz/sha512/6e2414c5c4cc2696c951b928253bbed88b576d207772c2f14e483aa4f84fe16d0b8731c955ba7680596d29b5339f4ef90d1a2f8edac1a196b22923af09f6cbd1
-LLVM.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/md5/a186e057c1141e7efe465be3c07a167a
-LLVM.v12.0.0+0.x86_64-linux-musl-cxx03.tar.gz/sha512/5e88b8a5a79889a7d402af9c49a1b7743dafc3572161b3137060066c5de18d48f7e6f6abc837ec1e794e22bb6dee3dd1663526c31b852be48c2c3f9d0ab85505
-LLVM.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/md5/ae4a90d5826c5b3db4085c90f91a42f5
-LLVM.v12.0.0+0.x86_64-linux-musl-cxx11.tar.gz/sha512/5bf3edbd72f86401d0f63803dbb0ef0ba9a835bd8cb9cece09e54807c0966d75b0ba68b6a0b337e40f8f754c04e0b6e95565baa4320a47a2b7f9d69c1e45de61
-LLVM.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/md5/1f3679db43d3b4b2fd2b2a4a8f92ddce
-LLVM.v12.0.0+0.x86_64-unknown-freebsd.tar.gz/sha512/5ae1316d5327177975fcb7d4342760b66ba6bf7f38b90cdc04f77a00cb5d924b2dd041c1f354b9855001fae01b8cb301b486ee16db7daf4d0c41fcdf3e78fe39
-LLVM.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/md5/441c0fc39bd0db777bf1c4a05a00d7eb
-LLVM.v12.0.0+0.x86_64-w64-mingw32-cxx03.tar.gz/sha512/7cd2556e0a7d6a9ee93cc23ee5e755d7f777edad22b838867d25c00c742e4591dcad40496388a149b54df25aa5697aa025d49a061614ea6d20c67f29ac66a484
-LLVM.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/md5/62f73d2ba5ccae272f6d85c6477d78e9
-LLVM.v12.0.0+0.x86_64-w64-mingw32-cxx11.tar.gz/sha512/a0f47a38994632c36502ec2f1b1d32f3f3c487062c7d47c38318ec6e85eb802a0e9d331b9743611eac86ef6d90c02960a6604f892aa295a88688905af6907b34
+LLVM_assert.v12.0.0+1.aarch64-apple-darwin.tar.gz/md5/a6ac9c9c1831bf01edf1bcb526e7c62d
+LLVM_assert.v12.0.0+1.aarch64-apple-darwin.tar.gz/sha512/4473ba37065329cf91192c0496136f161030da03a9a7e72106f41403e5b49debe7f0c203839f7deac7ca0b61b3d136404bf442b4f044f10e636a994e34994a40
+LLVM_assert.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/md5/0ccdf2fadf185c90e1938d946a6542e3
+LLVM_assert.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/sha512/d35e314b2928ce16b0369c1b7b38682d42d1443e0ca72f77e1b32d2231af5dc5a66eaee1881832ade8777566a0447319805e8fc1f2b702b19097240ac36da1fb
+LLVM_assert.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/md5/3acde3cd87feb3984f45f0ef323002e1
+LLVM_assert.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/sha512/be8d40794a5eee7ea775e33c8173deb3a775e5eaebfdc20341ad66a6d12d48692e0838e872245c74a8bea46ca085f8f3e7995f6ba33df2444fdf79d251ee272b
+LLVM_assert.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/md5/760edd92d241365409c59ca9ba46ce6c
+LLVM_assert.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/sha512/45b52ec2f516a7098f89f6ca6027d677329780ce61886821478d6889b1b1624d7f43e6f23daa2037c4fdbb25a71f97ef5a1ad9e0574760f0f304a2eb01cf6793
+LLVM_assert.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/md5/907174cef57551c44825034487417b31
+LLVM_assert.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/sha512/5abac8be17a83108ce3bf0c6d48342cc5db506049623c35859045758a3c31829bf388fc9c6ecc2ad1438e464930d9e1870cadc895eb7dbc72bdafd04666f60d7
+LLVM_assert.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/f90b16fffb796299a4e061d302a9855d
+LLVM_assert.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/cc3f019f88f167ee45638e3bf23f04ec8e4b021000e53342189bd75a2145f99523aa501e60457fc5cbbf5d35e1f8fd17a97fa9b18ebed5a04c2366333094e440
+LLVM_assert.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/3aa7211a765fe31a56d48151b7ec820d
+LLVM_assert.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/1e4e6a1a91ff1093b6441b43e50dd2cffa14d8cacecb6d812fde94164961e44569c17d74c65feccd613dee14311478bda112088d245e89bb307a3453e4d4d378
+LLVM_assert.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/md5/0155f81732916dcad2aa40b14d9db752
+LLVM_assert.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/7521fb007a0d589c9e70f7434afdc9e12867b6f82e6b7bc4c1f59fa337149648d6ea0367ae9dc7bb88840f6db05734d921f8da86633776a48529a0d6838feeee
+LLVM_assert.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/md5/90095ad6a9506c7e83b195becc9f9cf4
+LLVM_assert.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/15d34c652513a25d967d2721b4ab196f570fa80e02f17a905240ae838aafeb4fc88c99810c26558babf35ef2b478b067126d76f1e4c9366a143b139640a14939
+LLVM_assert.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/0384e43e079b05f8cc2bbc23012794be
+LLVM_assert.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/c599404cfc5b78342ce8f4790b6f9b1d7e7cc0e26e674040d1538d676e11c1c95734bfec7a7869a5eeef20641ac3c4b510bc40f2c6a1ef40dfd196d975c0d596
+LLVM_assert.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/7d1c3fd8fe1458ad5e8996dd282087e8
+LLVM_assert.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/c5b378c395be0339639baf8f10918ca2c6eed59a8fa8a34601e26c2433c6b543e92f71b73ceda254fa41f5b73796062758df26fe46335882c70c31c97ec128b5
+LLVM_assert.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/md5/6b42ab461336ea90274db8d059b7eec6
+LLVM_assert.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/3cb43d785825705567cb2b557a19486c75810d223e8ae828bfa9502de38f4bf76a3913634402529bda9f4a7525cc04fc33ab2a152c5dabb5adbbfd2497ade3fd
+LLVM_assert.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/md5/8fa56521559c7bc15c52e3282b75e377
+LLVM_assert.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/9632ff9a34cb92527eda6b3904f3444dfc79577a30d047062d1a1320fb0b91fa8bd2ff061ef075b2a7340db330800e9ca14f26090ede82707e92f6bb449be3ad
+LLVM_assert.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/md5/b93efe32fa26b868a37b698d27aff94b
+LLVM_assert.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/sha512/fc3d05bea5f40ae893585314f6f7fbf92eebd58676489760c8dc3e5a7bba1963fc251a87d685c3fa1922f9d5e63cb59645b2126b3746258bc01acaeeb425796a
+LLVM_assert.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/md5/01cb79e3c4d4d198f53fe0f79223ad03
+LLVM_assert.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/sha512/8620f2339e270c3cb5f455cc95acaa11bd9539475e64786c1869cd8582442812e732b903cda89a06bca8abf2aad3ff111f320fdd54e52d96ece6d57b35da3678
+LLVM_assert.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/md5/84948b34ac2d1a3d3e5011df423070a9
+LLVM_assert.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/sha512/df02613ed334d9d1d59daeb99e346e824e2cb0a35f092be5521e520ef0255c90a1d80b3b65db05162be2ae9707b7655da048f958b3dbcb7b57302a4105a57ada
+LLVM_assert.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/md5/d2e047b04a3a7aa8006b310f105f6503
+LLVM_assert.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/sha512/3f574b15d3341e2897986a1cab9a883582c1eff594b4d952550ac4753b2ee795f8f2c6947cfd8dc1ee2dd2a5ed4414a11675dd86f53088274aa6d5c71111dd32
+LLVM_assert.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/md5/1bc857bdf2d143fdf808a956ca528f05
+LLVM_assert.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/sha512/0c2357fa990b20f247487a22a2d73289b7288a23269d7212c4066dd86ba02a18eff59be86e77b6cd50cd20ef05cc50bba8ed7fb7cddcae7c61603ff556e01fd0
+LLVM_assert.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/md5/baed06cea973e29804f05ed77c6974fa
+LLVM_assert.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/sha512/b119901a524211cab7fd5eff962722fe5768975775267134094990a682d68779dafc9a9fba0b011e6927fca65e2cd52bee3e80fc505eb9571f32ccf41dbc1bb4
+LLVM_assert.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/md5/be94db30f358856a1e246be7355be7cf
+LLVM_assert.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/de63c33dec3440626315457a93a860230cce3c8cb0bd967459ffc12af9bd0684fdf3c81edf7440ce2dcd02367dd3e5679238c588ca52daa870308bb6b3e56fce
+LLVM_assert.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/md5/df5844b2dd49fe0eb4eac58fb22b7f8d
+LLVM_assert.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/ef4a99aa6957d11aaa8a94027f6a7c2b7800f9b8f3fd8f7a7e9762383ac0064245e695c7040d9189a47ad7f95b1a0760fa6b655aa0f44e95d7ba684b9ccf174e
+LLVM_assert.v12.0.0+1.x86_64-apple-darwin.tar.gz/md5/bdb347aa9b67ce6d24aba48d34299f0b
+LLVM_assert.v12.0.0+1.x86_64-apple-darwin.tar.gz/sha512/527164a4db3e146f72eee0f2972209cf9eb705c3d614f0e505e0b503ef2a0e7986eeacdbf3e1197631454c90bfdc6f55dfc80c85a1537c3791ea0360610ffe19
+LLVM_assert.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/md5/a900923c8800c1860d5c98f9172b4c75
+LLVM_assert.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/sha512/04732d78b628b8fb06b2368d1ed48d21a3aefd5def2566f7fa17ab279b99e9fb0c0cb7f1d65933cbc6ff473c4e566034066666838644f9792eaa1d4ed0a8122e
+LLVM_assert.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/md5/7669055a5e43049fc14282d9a37bd39d
+LLVM_assert.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/sha512/71a8daba8baae164a6af16353d49a3f5bcb4b41714813659d8d488d7c8d26ffd8fbec92c6b53b98f05a4234224df81eebe7006e0ec5567518d7b42fa285be1a3
+LLVM_assert.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/md5/1c38ee7ccb6dcbe22698f2eb08ffa627
+LLVM_assert.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/sha512/dcd059ac9121f59507391657baf4c8eaaea7f531adc0ca02ea688d09643ada9e10a74e6441755014914f3f1764b90f99299ed4a3af5b234ec64cb5ed84934cb0
+LLVM_assert.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/md5/a98e8304dd300af4b14211fd5f5c8a68
+LLVM_assert.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/sha512/2a4a567d681a42cb6b05059dd68646f85841ba431eecfa36d0b8d0d0a9290d3aa9a628317050711e6c3a599e48b77d1988cfa9e4429b07e9f371741aa8d6f841
+LLVM_assert.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/md5/9c92e5737faf62609844983f1603f75f
+LLVM_assert.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/sha512/dfe1f1836d74693f4061a07d834f622c6c9142ce8c949c07a5ca9a0976feecc67a483edcb1ff4dfab04fd54f063c0890655e855f55734d81fa3d595fcfc23109
+LLVM_assert.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/md5/578f4ab4fd290342f3290e5b182af9c4
+LLVM_assert.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/sha512/f8d23c8b994f8e503d041322dbd68b0d5682d8939480afab620ee861799000ba91571f59832f148dcd97cb0ab2bac9691eaa83107b98b8dbdf99569bc1b77432
+LLVM_assert.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/md5/818b94c89b0af9f9e1dbfc98db278d03
+LLVM_assert.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/sha512/672853d70cd25b13249479c1c831ba121e164a1aefbf46d6b9647501bf746b0925538bf126c552317482b9729fc9653800246ff25206775f5f5c6fb4196bffe9
+LLVM_full_assert.v9.0.1-1.x86_64-linux-gnu-cxx11.tar.gz/md5/1faea42ae449b43c9f3119ccc0c1b375
+LLVM_full_assert.v9.0.1-1.x86_64-linux-gnu-cxx11.tar.gz/sha512/c99baba5a831405d4ad4d8636eefbc260fcffcb8026fa1537cf63dc79d71dea7e57b52acf6815cbbc0aec8ae8c9aadfb1349791b0b31cfa8418529faa494195e
+LLVM_full.v10.0.1-0.i686-linux-gnu-cxx03.tar.gz/md5/68d90f435664d4fef450eff70539dca9
+LLVM_full.v10.0.1-0.i686-linux-gnu-cxx03.tar.gz/sha512/65b07bc5f6145b063d7bc8d35fd22a2d578cd972c74b08ec827b9980e4ceb1fd77ce5ba921cd0d907643594fe73d67a7b56c699d3e64f9ac6b2b6953972a4179
+LLVM_full.v10.0.1-0.i686-linux-gnu-cxx11.tar.gz/md5/2128286984b014f41e1449e884a8f7c4
+LLVM_full.v10.0.1-0.i686-linux-gnu-cxx11.tar.gz/sha512/d8e99a78e29a7eec99bf5924c8f095b82fd7b020c19f8f41401eec514e468c48e489fd047401d751c8273f264fafd13964d1dd160d2be1e19d50f48133a7da9b
+LLVM_full.v10.0.1-0.x86_64-linux-gnu-cxx11.tar.gz/md5/7718b789700c0f6f5329efabf6b0bfd0
+LLVM_full.v10.0.1-0.x86_64-linux-gnu-cxx11.tar.gz/sha512/94d6a951e5f6d6b9a2399a80b9cae5a52d37145956e4752f0bf2fb9b8b9e43e16987ed3833126efacef32831a200925f040fc2eeaf7b1f83817ed17954a993c2
+LLVM.v12.0.0+1.aarch64-apple-darwin.tar.gz/md5/e438402bcff0a77f20510badbb1f3c0f
+LLVM.v12.0.0+1.aarch64-apple-darwin.tar.gz/sha512/14cafe77b353fbede64c736052032db77ced2757bb53696925899b79037a3b5a72d75f1ad8972a191e216a25a83f26517b0291fd246e0aad7a1ca040bdc7011d
+LLVM.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/md5/8ff58f44d6f27d3dfb2b3670533a472c
+LLVM.v12.0.0+1.aarch64-linux-gnu-cxx03.tar.gz/sha512/b9738d4b4f00c08cc06b3f1d73bdcaec96e578e02de08f14e2e084eabba934c24f9c4e65758e102515e3c9a1527612c468d8b178f2e87ca667f2e7a62343b1f2
+LLVM.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/md5/f4994c8abfd4fe71004b499bd95140bc
+LLVM.v12.0.0+1.aarch64-linux-gnu-cxx11.tar.gz/sha512/fa01e3d6f154b695e9230c13365098af60ca5f6077d63e3cbc6c410a89615eb7634413532db4f93661289c590f4576c18488cae20ec5dfabe1c273cd97c18f7e
+LLVM.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/md5/52066c3a492d69cc0da23f0861f1f6a9
+LLVM.v12.0.0+1.aarch64-linux-musl-cxx03.tar.gz/sha512/db60079a09654f00a452c70862d1453c2ca8bf9b5ef055b66e99edfcc35a52a94245e21b0cd6acd88f556dd99c492b6f057dd48e3047286af0ed612493e895c7
+LLVM.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/md5/b02a6d93f190aff2de4f03a1cd121a30
+LLVM.v12.0.0+1.aarch64-linux-musl-cxx11.tar.gz/sha512/3c0c9a3753b8e709361f1faceb02b3d19cc8e0c7a183601be528283c8871c92a234c3805206c37e1ec04577a53f57282b4874e4175e2ffb83b4b1ead744b9c0b
+LLVM.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/88858237d7941887f27af62b7e249a62
+LLVM.v12.0.0+1.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/342d4bd418547f3b6543182a5593e21fd4af84eaab0b91ae04723e485b48accb2a119c7c89d766fcee2fa13af9ec3454da310d452e1262aa0e97fab9aa498422
+LLVM.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/1cdef3420fc7fba9e74765c839742350
+LLVM.v12.0.0+1.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/d7af8ec5abdc1ff75efa3f4f0546efa7d2328893b11533cde68a515a0d117272efa5e8bb1e821996ad12214668644bdf7a9a3f5e7578b24a174b5b04bc0cf1db
+LLVM.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/md5/3ee4b9db085916dc73aa4131ff6a73a5
+LLVM.v12.0.0+1.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/b456e096bbe2964f678f09edcfd49e0e8b4922984cfb1fc47358868eb099b82655ba8d5209ac31452af511d7c773de2a2f56a24ad0b36841d9f557ddb2c09a88
+LLVM.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/md5/bcfe6505477413c52c3193dd8d0c22fc
+LLVM.v12.0.0+1.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/50a2af7655acaa0e13f15cfcf490b334e104cdc847ddd5900fae04b322ecdecc69d85bd3b15b6170f584fe364dedea140e1fbd9a8835499067da59f4b665f849
+LLVM.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/c11d635651c82dbd5f0038f24afdcb03
+LLVM.v12.0.0+1.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/da3676b598851f07a875fb3282f2a1c078d0f447213049dac6e33bb07b5334d332df6f26b1e0e851f85bba20a72e65e158f848c67563be9a6e23c9d06b1a7f19
+LLVM.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/a299db2b5337c8b79bb0f37a39929c13
+LLVM.v12.0.0+1.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/46c7f0737dd3f46cbd30173d39c268a4606b169d80b146070fd2c61f32eb31b1cc8ef509bd1bc7f0c197a4b7b4a6e3d45a320b4a11a27d6a0233bbc1d79dd90b
+LLVM.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/md5/3f8c17f38d47008ef26457ca29cd626e
+LLVM.v12.0.0+1.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/265dad34a231c55b07f9fcc059dde0ef72c156374d7334372f0ee486f9c1ebe95e8ec187cc4b07623dc94b8f8def7d3235fba0ee11a1b8419d9b7a7182a91d5e
+LLVM.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/md5/5e49fc12546f4b1deaefa249f7e1f77f
+LLVM.v12.0.0+1.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/85940dac65199307fe6a571b7f369b02430c4ac980c7fe35c1ca4dae6d29a1e5ceaa72151ecc4d8fd29116b82e1d1d4b9054fc0fdc1de31becbdef1365164ecc
+LLVM.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/md5/74c5e7b4e2bb44879f8a907d54c57398
+LLVM.v12.0.0+1.i686-linux-gnu-cxx03.tar.gz/sha512/41124a32c83e19e0fbd0f0c870bdda7d9a8f59ae51ec1017eba203e01e7fbc33b43334e12154ab0be57892f5bf85faf0c76c375da77e7c9097caf54b45a0d19b
+LLVM.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/md5/6ff76e552a78453ac1e149a85179d7e8
+LLVM.v12.0.0+1.i686-linux-gnu-cxx11.tar.gz/sha512/8623d31b9bcc59ef3565db310e323e8b165c9c35a0ce170f5f5e2d58ff218974d2ad35ce1781a9558556a33247bcba2bcb1e1171254838fdc3780e9408df7525
+LLVM.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/md5/8e097ffb90dfb3786ae1d9074314632c
+LLVM.v12.0.0+1.i686-linux-musl-cxx03.tar.gz/sha512/96291e3c1620a358594be1dfd99354dcae76b9c7536ffb93bac93bf6523f323dc44d55b1faec85a763f1579f9ce0f1ae220f2943100d2f286dcb4cbd043ec088
+LLVM.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/md5/bc19a91fcca8d8aad83f5b38c8db2a0c
+LLVM.v12.0.0+1.i686-linux-musl-cxx11.tar.gz/sha512/ce5914eaa76e9eb21a218755211d613c4261ae284773222e40b383c20c5e7c6ef00be2836750cb1e85d2b1f6e65869e016d49f365d554ce845486fdd352c1b7c
+LLVM.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/md5/67f319faa58c136910cc6497eb73b234
+LLVM.v12.0.0+1.i686-w64-mingw32-cxx03.tar.gz/sha512/e5697c29f54bae9d9e551084ca702aafb09ff11f6de60aa723d90cad9675d18846c1cf2fc093ec1eb54c5db7f2328aa05555bf453f798cc3e96f79f2afebb283
+LLVM.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/md5/e5d38ab0e686a0cc9452c1f1c81c21a7
+LLVM.v12.0.0+1.i686-w64-mingw32-cxx11.tar.gz/sha512/9cdfd778255faed49a53fcbc691a3a1c234b0649b13ba8499a90a61ffe7ee864ace982fd33e6e736f4466fc11d5a2c0b735bd68f7e5ac4eca5892ee76a5f0bd6
+LLVM.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/md5/c300da4c0c1a26115756d5b34583b0c2
+LLVM.v12.0.0+1.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/1ef72ad1007363f25a410733efd5ce8c69d47718bd3df8d3e00e8cf22fd8ec3dbc4a19d4211a72877f90767a9b5d46318d5c059642de21a32072dd8099225add
+LLVM.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/md5/32863e5fc4dbc7003326474e3b057412
+LLVM.v12.0.0+1.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/2f3b726d787a6bb7cf92e7e4e91a9f72eac0da7fbf61b5cb94a49de812ec07b05b2cdb37800fce556071b410328dd7db1ed375961684e141fc54bc632ff10df8
+LLVM.v12.0.0+1.x86_64-apple-darwin.tar.gz/md5/0bd322858942def11a7a331211782917
+LLVM.v12.0.0+1.x86_64-apple-darwin.tar.gz/sha512/a33160fdee69ca06bcc1fc6843d19f306dacbf88037108c9fe5a0c57e2e4176c9ec108bd286486029312617a86da4791e123e89407a2ae71cae6f1726f44e9b3
+LLVM.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/md5/3efdba4e35e0c76b3d60bf8ad03fc321
+LLVM.v12.0.0+1.x86_64-linux-gnu-cxx03.tar.gz/sha512/0018caf8c878b482a7621d950687018586b5c0aaaa08a68d26855b40bc9b2ba60600e83d6bfd729b69d25eee3f0e4126afab9f7f523b41d5532400f6289508f8
+LLVM.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/md5/4ed4c4245ead0905cece3c5ac4c48886
+LLVM.v12.0.0+1.x86_64-linux-gnu-cxx11.tar.gz/sha512/609fba22a5d438d039f77fbb8c726766e71da9c768df83033d9b7cc8f178d2b25175427a5adfa6a004d61b610e4303f2a301e4ff5af51cf90296b883bd33c824
+LLVM.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/md5/d78fe12460c99fc47f9139325c19d377
+LLVM.v12.0.0+1.x86_64-linux-musl-cxx03.tar.gz/sha512/698fd57da10afef2c5c43915292a4e9778bb9a005694391273cd2c2184aa792f914bf3f9e37bc31bb541054ddbe75122d01d34a4ac688a8b87ea22c795369fd6
+LLVM.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/md5/49855ae6aaa48f3b6d55cf6a8c354449
+LLVM.v12.0.0+1.x86_64-linux-musl-cxx11.tar.gz/sha512/06bec6da4dba5956b35571dec54f81ccbd55a0e88aafa4d2d4477f50ca8f4c875853ce25db5fee236a2cd8be9f4b98528d051690db61efafb51c964e1953f159
+LLVM.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/md5/f2362ea7f927839c1a12724e11c721da
+LLVM.v12.0.0+1.x86_64-unknown-freebsd.tar.gz/sha512/e42248a84d8bc52d3cb23cb8c5b5d51560480333ff367d95ba5390e956bc78b8a48d5d7f70809aaa9288997db4b99a13e0e99f484f97713da9b167666c2fa284
+LLVM.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/md5/4115b1aed76cfab64e6327593be41e2e
+LLVM.v12.0.0+1.x86_64-w64-mingw32-cxx03.tar.gz/sha512/0c184e7e788dd5b9e76a10a6a0ca367eb0df76608d1d773abeec4583fcc8c59014eaf09ff9af67815c935a29816e055f9c4cf8d9c1ab5c98840bb24515f6ec22
+LLVM.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/md5/2e663337eecbd7745e9decd60030f12d
+LLVM.v12.0.0+1.x86_64-w64-mingw32-cxx11.tar.gz/sha512/198c8340de6ea5f01347d1465e0059ac6f83e23ab603c5789ed12a5a85eb738544cd490cf42a7799b44203fa19d55034c65b5a3f8e85eb2eade188d2bd32d43b
diff --git a/deps/llvm.mk b/deps/llvm.mk
index c436a1a08a78c..b6f6455f88255 100644
--- a/deps/llvm.mk
+++ b/deps/llvm.mk
@@ -512,6 +512,8 @@ $(eval $(call LLVM_PROJ_PATCH,llvm-11-AArch64-FastIsel-bug))
 $(eval $(call LLVM_PATCH,llvm-12-D97435-AArch64-movaddrreg))
 $(eval $(call LLVM_PROJ_PATCH,llvm-11-D97571-AArch64-loh)) # remove for LLVM 13
 $(eval $(call LLVM_PROJ_PATCH,llvm-11-aarch64-addrspace)) # remove for LLVM 13
+$(eval $(call LLVM_PROJ_PATCH,llvm-12-fde-symbols-aarch64)) # remove for LLVM 13
+$(eval $(call LLVM_PROJ_PATCH,llvm-12-force-eh_frame-aarch64)) # remove for LLVM 13
 endif # LLVM_VER 12.0
 
 # Add a JL prefix to the version map. DO NOT REMOVE
diff --git a/deps/patches/llvm-12-fde-symbols-aarch64.patch b/deps/patches/llvm-12-fde-symbols-aarch64.patch
new file mode 100644
index 0000000000000..c62e65765ae21
--- /dev/null
+++ b/deps/patches/llvm-12-fde-symbols-aarch64.patch
@@ -0,0 +1,158 @@
+From 7133a3d3b0bd639d36d9d40f1135159442ab73c7 Mon Sep 17 00:00:00 2001
+From: Cody Tapscott <cody+github@tapscott.me>
+Date: Mon, 24 May 2021 15:11:39 -0700
+Subject: [PATCH] Do not patch FDE symbols in RuntimeDyld, on targets that use
+ non-absolute symbol relocations in `.eh_frame`
+
+Since processFDE adds a delta to the values in the FDE, it assumes that the relocations for the .eh_frame section have not been applied by RuntimeDyld. It expects instead that only the relocation addend has been written to the symbol locations, and that the section-to-section offset needs to be added.
+
+However, there are platform differences that interfere with this:
+1) X86-64 has DwarfFDESymbolsUseAbsDiff enabled in its AsmInfo, causing an absolute symbol to be emitted for the FDE pcStart.  Absolute symbols are skipped as a relocation by RuntimeDyld, so the processFDE function in RuntimeDyldMachO.cpp calculates the relocation correctly.
+2) AArch64 has DwarfFDESymbolsUseAbsDiff disabled, so a relocation is emitted in the eh_frame section. Since this isn't absolute, the relocation is applied by RuntimeDyld. This means that processFDE ends up adding an additional section-to-section offset to the pcStart field, generating an incorrect FDE
+
+Differential Revision: https://reviews.llvm.org/D103052
+---
+ .../RuntimeDyld/RuntimeDyldMachO.cpp          | 37 +++++++++++--------
+ .../RuntimeDyld/RuntimeDyldMachO.h            |  8 +++-
+ .../Targets/RuntimeDyldMachOAArch64.h         |  2 +
+ .../RuntimeDyld/Targets/RuntimeDyldMachOARM.h |  2 +
+ .../Targets/RuntimeDyldMachOI386.h            |  2 +
+ .../Targets/RuntimeDyldMachOX86_64.h          |  2 +
+ 6 files changed, 35 insertions(+), 18 deletions(-)
+
+diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
+index 9ca76602ea18..e61bfd1bd31c 100644
+--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
++++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
+@@ -272,9 +272,9 @@ RuntimeDyldMachOCRTPBase<Impl>::finalizeLoad(const ObjectFile &Obj,
+ }
+ 
+ template <typename Impl>
+-unsigned char *RuntimeDyldMachOCRTPBase<Impl>::processFDE(uint8_t *P,
+-                                                          int64_t DeltaForText,
+-                                                          int64_t DeltaForEH) {
++unsigned char *RuntimeDyldMachOCRTPBase<Impl>::patchFDERelocations(uint8_t *P,
++                                                                   int64_t DeltaForText,
++                                                                   int64_t DeltaForEH) {
+   typedef typename Impl::TargetPtrT TargetPtrT;
+ 
+   LLVM_DEBUG(dbgs() << "Processing FDE: Delta for text: " << DeltaForText
+@@ -324,19 +324,24 @@ void RuntimeDyldMachOCRTPBase<Impl>::registerEHFrames() {
+       continue;
+     SectionEntry *Text = &Sections[SectionInfo.TextSID];
+     SectionEntry *EHFrame = &Sections[SectionInfo.EHFrameSID];
+-    SectionEntry *ExceptTab = nullptr;
+-    if (SectionInfo.ExceptTabSID != RTDYLD_INVALID_SECTION_ID)
+-      ExceptTab = &Sections[SectionInfo.ExceptTabSID];
+-
+-    int64_t DeltaForText = computeDelta(Text, EHFrame);
+-    int64_t DeltaForEH = 0;
+-    if (ExceptTab)
+-      DeltaForEH = computeDelta(ExceptTab, EHFrame);
+-
+-    uint8_t *P = EHFrame->getAddress();
+-    uint8_t *End = P + EHFrame->getSize();
+-    while (P != End) {
+-      P = processFDE(P, DeltaForText, DeltaForEH);
++
++    // If the FDE includes absolute symbol relocations (not supported
++    // by RuntimeDyld), we need to manually patch-up the values
++    if (doDwarfFDESymbolsUseAbsDiff()) {
++      SectionEntry *ExceptTab = nullptr;
++      if (SectionInfo.ExceptTabSID != RTDYLD_INVALID_SECTION_ID)
++        ExceptTab = &Sections[SectionInfo.ExceptTabSID];
++
++      int64_t DeltaForText = computeDelta(Text, EHFrame);
++      int64_t DeltaForEH = 0;
++      if (ExceptTab)
++        DeltaForEH = computeDelta(ExceptTab, EHFrame);
++
++      uint8_t *P = EHFrame->getAddress();
++      uint8_t *End = P + EHFrame->getSize();
++      while (P != End) {
++        P = patchFDERelocations(P, DeltaForText, DeltaForEH);
++      }
+     }
+ 
+     MemMgr.registerEHFrames(EHFrame->getAddress(), EHFrame->getLoadAddress(),
+diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
+index 650e7b79fbb8..a7e5c9cb56e8 100644
+--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
++++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
+@@ -43,6 +43,10 @@ protected:
+     SID ExceptTabSID;
+   };
+ 
++  // Returns true if the FDE section includes absolute symbol relocations
++  // on this platform.
++  virtual bool doDwarfFDESymbolsUseAbsDiff() = 0;
++
+   // When a module is loaded we save the SectionID of the EH frame section
+   // in a table until we receive a request to register all unregistered
+   // EH frame sections with the memory manager.
+@@ -147,8 +151,8 @@ private:
+   Impl &impl() { return static_cast<Impl &>(*this); }
+   const Impl &impl() const { return static_cast<const Impl &>(*this); }
+ 
+-  unsigned char *processFDE(uint8_t *P, int64_t DeltaForText,
+-                            int64_t DeltaForEH);
++  unsigned char *patchFDERelocations(uint8_t *P, int64_t DeltaForText,
++                                     int64_t DeltaForEH);
+ 
+ public:
+   RuntimeDyldMachOCRTPBase(RuntimeDyld::MemoryManager &MemMgr,
+diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h
+index f2ee1b06d494..90a9a4c44c84 100644
+--- a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h
++++ b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h
+@@ -30,6 +30,8 @@ public:
+ 
+   unsigned getStubAlignment() override { return 8; }
+ 
++  bool doDwarfFDESymbolsUseAbsDiff() override { return false; }
++  
+   /// Extract the addend encoded in the instruction / memory location.
+   Expected<int64_t> decodeAddend(const RelocationEntry &RE) const {
+     const SectionEntry &Section = Sections[RE.SectionID];
+diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h
+index a76958a9e2c2..7281249d25bf 100644
+--- a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h
++++ b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h
+@@ -33,6 +33,8 @@ public:
+ 
+   unsigned getStubAlignment() override { return 4; }
+ 
++  bool doDwarfFDESymbolsUseAbsDiff() override { return false; }
++
+   Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &SR) override {
+     auto Flags = RuntimeDyldImpl::getJITSymbolFlags(SR);
+     if (!Flags)
+diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h
+index 523deb29b723..755bc13afeb4 100644
+--- a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h
++++ b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h
+@@ -30,6 +30,8 @@ public:
+ 
+   unsigned getStubAlignment() override { return 1; }
+ 
++  bool doDwarfFDESymbolsUseAbsDiff() override { return true; }
++
+   Expected<relocation_iterator>
+   processRelocationRef(unsigned SectionID, relocation_iterator RelI,
+                        const ObjectFile &BaseObjT,
+diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOX86_64.h b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOX86_64.h
+index 28febbdb948c..9854da24a2ce 100644
+--- a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOX86_64.h
++++ b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOX86_64.h
+@@ -30,6 +30,8 @@ public:
+ 
+   unsigned getStubAlignment() override { return 8; }
+ 
++  bool doDwarfFDESymbolsUseAbsDiff() override { return true; }
++
+   Expected<relocation_iterator>
+   processRelocationRef(unsigned SectionID, relocation_iterator RelI,
+                        const ObjectFile &BaseObjT,
+-- 
+2.30.1 (Apple Git-130)
+
diff --git a/deps/patches/llvm-12-force-eh_frame-aarch64.patch b/deps/patches/llvm-12-force-eh_frame-aarch64.patch
new file mode 100644
index 0000000000000..aff55f35e7bd8
--- /dev/null
+++ b/deps/patches/llvm-12-force-eh_frame-aarch64.patch
@@ -0,0 +1,31 @@
+From 026f3518c4713e388a8ed06fa032e0925d35c6f5 Mon Sep 17 00:00:00 2001
+From: Cody Tapscott <cody+github@tapscott.me>
+Date: Mon, 24 May 2021 16:36:06 -0700
+Subject: [PATCH] Force `.eh_frame` emission on AArch64
+
+We need to force the emission of the EH Frame section (currently done via SupportsCompactUnwindWithoutEHFrame in the MCObjectFileInfo for the target), since libunwind doesn't yet support dynamically registering compact unwind information at run-time.
+---
+ llvm/lib/MC/MCObjectFileInfo.cpp | 7 ++++---
+ 1 file changed, 4 insertions(+), 3 deletions(-)
+
+diff --git a/llvm/lib/MC/MCObjectFileInfo.cpp b/llvm/lib/MC/MCObjectFileInfo.cpp
+index 1a448f040b3b..e12154deca5f 100644
+--- a/llvm/lib/MC/MCObjectFileInfo.cpp
++++ b/llvm/lib/MC/MCObjectFileInfo.cpp
+@@ -57,9 +57,10 @@ void MCObjectFileInfo::initMachOMCObjectFileInfo(const Triple &T) {
+           MachO::S_ATTR_STRIP_STATIC_SYMS | MachO::S_ATTR_LIVE_SUPPORT,
+       SectionKind::getReadOnly());
+ 
+-  if (T.isOSDarwin() &&
+-      (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32))
+-    SupportsCompactUnwindWithoutEHFrame = true;
++  // Disabled for now, since we need to emit EH Frames for stack unwinding in the JIT
++  // if (T.isOSDarwin() &&
++  //     (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32))
++  //   SupportsCompactUnwindWithoutEHFrame = true;
+ 
+   if (T.isWatchABI())
+     OmitDwarfIfHaveCompactUnwind = true;
+-- 
+2.30.1 (Apple Git-130)
+
diff --git a/stdlib/libLLVM_jll/Project.toml b/stdlib/libLLVM_jll/Project.toml
index 5db781e86a88c..1321496e0695f 100644
--- a/stdlib/libLLVM_jll/Project.toml
+++ b/stdlib/libLLVM_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "libLLVM_jll"
 uuid = "8f36deef-c2a5-5394-99ed-8e07531fb29a"
-version = "12.0.0+0"
+version = "12.0.0+1"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From bf84b5e749763e7d495cceb35aa1a542ba225dde Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Thu, 1 Jul 2021 03:51:12 -0400
Subject: [PATCH 35/44] fix #41416, splatted default argument lost with keyword
 argument (#41427)

(cherry picked from commit ebc8f3c61701f271f5fac33e3dac56eed786679c)
---
 src/ast.scm          |  6 +++++-
 src/julia-syntax.scm | 17 ++++++++---------
 test/keywordargs.jl  |  7 +++++++
 3 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/src/ast.scm b/src/ast.scm
index 005afb4647f5f..bc8d847279fc9 100644
--- a/src/ast.scm
+++ b/src/ast.scm
@@ -319,7 +319,7 @@
          (bad-formal-argument v))
         (else
          (case (car v)
-           ((... kw)
+           ((...)
 	    (arg-name (cadr v)) ;; to check for errors
 	    (decl-var (cadr v)))
            ((|::|)
@@ -330,6 +330,8 @@
             (if (nospecialize-meta? v #t)
                 (arg-name (caddr v))
                 (bad-formal-argument v)))
+           ((kw)
+            (arg-name (cadr v)))
            (else (bad-formal-argument v))))))
 
 (define (arg-type v)
@@ -349,6 +351,8 @@
             (if (nospecialize-meta? v #t)
                 (arg-type (caddr v))
                 (bad-formal-argument v)))
+           ((kw)
+            (arg-type (cadr v)))
            (else (bad-formal-argument v))))))
 
 ;; convert a lambda list into a list of just symbols
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index d80c6a5052c85..420eeaf51f747 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -442,9 +442,12 @@
          ;; 1-element list of vararg argument, or empty if none
          (vararg (let* ((l (if (null? pargl) '() (last pargl)))
                         ;; handle vararg with default value
-                        (l (if (kwarg? l) (cadr l) l)))
-                   (if (or (vararg? l) (varargexpr? l))
+                        (l- (if (kwarg? l) (cadr l) l)))
+                   (if (or (vararg? l-) (varargexpr? l-))
                        (list l) '())))
+         ;; expression to forward varargs to another call
+         (splatted-vararg (if (null? vararg) '()
+                              (list `(... ,(arg-name (car vararg))))))
          ;; positional args with vararg
          (pargl-all pargl)
          ;; positional args without vararg
@@ -520,8 +523,7 @@
                                        ,@(if ordered-defaults keynames vals)
                                        ,@(if (null? restkw) '() `((call (top pairs) (call (core NamedTuple)))))
                                        ,@(map arg-name pargl)
-                                       ,@(if (null? vararg) '()
-                                             (list `(... ,(arg-name (car vararg)))))))))
+                                       ,@splatted-vararg))))
                (if ordered-defaults
                    (scopenest keynames vals ret)
                    ret))))
@@ -579,16 +581,13 @@
                 ,@(if (null? restkw)
                       `((if (call (top isempty) ,rkw)
                             (null)
-                            (call (top kwerr) ,kw ,@(map arg-name pargl)
-                                  ,@(if (null? vararg) '()
-                                        (list `(... ,(arg-name (car vararg))))))))
+                            (call (top kwerr) ,kw ,@(map arg-name pargl) ,@splatted-vararg)))
                       '())
                 (return (call ,mangled  ;; finally, call the core function
                               ,@keynames
                               ,@(if (null? restkw) '() (list rkw))
                               ,@(map arg-name pargl)
-                              ,@(if (null? vararg) '()
-                                    (list `(... ,(arg-name (car vararg)))))))))))
+                              ,@splatted-vararg))))))
         ;; return primary function
         ,(if (not (symbol? name))
              '(null) name)))))
diff --git a/test/keywordargs.jl b/test/keywordargs.jl
index 348eaea2ee4c3..9cbae2b1a0b19 100644
--- a/test/keywordargs.jl
+++ b/test/keywordargs.jl
@@ -380,3 +380,10 @@ f40964(xs::Int...=1; k = 2) = (xs, k)
 @test f40964() === ((1,), 2)
 @test f40964(7, 8) === ((7,8), 2)
 @test f40964(7, 8, k=0) === ((7,8), 0)
+# issue #41416
+@test f40964(; k = 1) === ((1,), 1)
+f41416(a...="a"; b=true) = (b, a)
+@test f41416()           === (true, ("a",))
+@test f41416(;b=false)   === (false, ("a",))
+@test f41416(33)         === (true, (33,))
+@test f41416(3; b=false) === (false, (3,))

From a81b4f8a7b31226f0425192de0b3a35e88c7318d Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Thu, 1 Jul 2021 10:08:27 +0200
Subject: [PATCH 36/44] make "Add information to passing tests" a bit more
 backwards compatible (#41424)

(cherry picked from commit d09c8e09ac2b8e14e4b9300bf632ee8d7c229209)
---
 stdlib/Test/src/Test.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/Test/src/Test.jl b/stdlib/Test/src/Test.jl
index 260f6e33bac7d..461c48026944e 100644
--- a/stdlib/Test/src/Test.jl
+++ b/stdlib/Test/src/Test.jl
@@ -86,7 +86,7 @@ struct Pass <: Result
     data
     value
     source::Union{Nothing,LineNumberNode}
-    function Pass(test_type::Symbol, orig_expr, data, thrown, source)
+    function Pass(test_type::Symbol, orig_expr, data, thrown, source=nothing)
         return new(test_type, orig_expr, data, thrown isa String ? "String" : thrown, source)
     end
 end

From ad9476f9d2835effb37ddb3871734f3735289b9a Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 4 Jul 2021 08:45:34 -0400
Subject: [PATCH 37/44] codegen: complete handling for partial-layout objects
 (#41438)

Fixes #41425

(cherry picked from commit 7ffc10bf4ee13d0d0669a6a2315907a2361c38df)
---
 src/ccall.cpp            |  2 +-
 src/cgutils.cpp          | 20 +++++++-------------
 src/codegen.cpp          | 22 ++++++++++-----------
 src/datatype.c           | 41 +++++++++++++++++++++++++---------------
 src/jltypes.c            | 28 +++++++++++++--------------
 src/julia_internal.h     |  3 ++-
 test/compiler/codegen.jl | 13 +++++++++++++
 7 files changed, 74 insertions(+), 55 deletions(-)

diff --git a/src/ccall.cpp b/src/ccall.cpp
index 15f51cf9d6897..c7853ccc2a8d8 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -493,7 +493,7 @@ static Value *julia_to_native(
         assert(!byRef); // don't expect any ABI to pass pointers by pointer
         return boxed(ctx, jvinfo);
     }
-    assert(jl_is_datatype(jlto) && julia_struct_has_layout((jl_datatype_t*)jlto));
+    assert(jl_is_datatype(jlto) && jl_struct_try_layout((jl_datatype_t*)jlto));
 
     typeassert_input(ctx, jvinfo, jlto, jlto_env, argn);
     if (!byRef)
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index c5e25466110d0..5f4ef560c83ce 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -321,7 +321,7 @@ static size_t dereferenceable_size(jl_value_t *jt)
         // Array has at least this much data
         return sizeof(jl_array_t);
     }
-    else if (jl_is_datatype(jt) && ((jl_datatype_t*)jt)->layout) {
+    else if (jl_is_datatype(jt) && jl_struct_try_layout((jl_datatype_t*)jt)) {
         return jl_datatype_size(jt);
     }
     return 0;
@@ -339,7 +339,7 @@ static unsigned julia_alignment(jl_value_t *jt)
         // and this is the guarantee we have for the GC bits
         return 16;
     }
-    assert(jl_is_datatype(jt) && ((jl_datatype_t*)jt)->layout);
+    assert(jl_is_datatype(jt) && jl_struct_try_layout((jl_datatype_t*)jt));
     unsigned alignment = jl_datatype_align(jt);
     if (alignment > JL_HEAP_ALIGNMENT)
         return JL_HEAP_ALIGNMENT;
@@ -555,16 +555,10 @@ static Type *bitstype_to_llvm(jl_value_t *bt, bool llvmcall = false)
 }
 
 static bool jl_type_hasptr(jl_value_t* typ)
-{ // assumes that jl_stored_inline(typ) is true
+{ // assumes that jl_stored_inline(typ) is true (and therefore that layout is defined)
     return jl_is_datatype(typ) && ((jl_datatype_t*)typ)->layout->npointers > 0;
 }
 
-// return whether all concrete subtypes of this type have the same layout
-static bool julia_struct_has_layout(jl_datatype_t *dt)
-{
-    return dt->layout || jl_has_fixed_layout(dt);
-}
-
 static unsigned jl_field_align(jl_datatype_t *dt, size_t i)
 {
     unsigned al = jl_field_offset(dt, i);
@@ -588,11 +582,8 @@ static Type *_julia_struct_to_llvm(jl_codegen_params_t *ctx, jl_value_t *jt, boo
         bool isTuple = jl_is_tuple_type(jt);
         jl_svec_t *ftypes = jl_get_fieldtypes(jst);
         size_t i, ntypes = jl_svec_len(ftypes);
-        if (!julia_struct_has_layout(jst))
+        if (!jl_struct_try_layout(jst))
             return NULL; // caller should have checked jl_type_mappable_to_c already, but we'll be nice
-        if (jst->layout == NULL)
-            jl_compute_field_offsets(jst);
-        assert(jst->layout);
         if (ntypes == 0 || jl_datatype_nbits(jst) == 0)
             return T_void;
         Type *_struct_decl = NULL;
@@ -1640,6 +1631,9 @@ static bool emit_getfield_unknownidx(jl_codectx_t &ctx,
         return true;
     }
     if (nfields == 1) {
+        if (jl_has_free_typevars(jl_field_type(stt, 0))) {
+            return false;
+        }
         (void)idx0();
         *ret = emit_getfield_knownidx(ctx, strct, 0, stt, order);
         return true;
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 4eba89badbd8e..5a4bc9fec6b4b 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -931,12 +931,12 @@ static MDNode *best_tbaa(jl_value_t *jt) {
 // note that this includes jl_isbits, although codegen should work regardless
 static bool jl_is_concrete_immutable(jl_value_t* t)
 {
-    return jl_is_immutable_datatype(t) && ((jl_datatype_t*)t)->layout;
+    return jl_is_immutable_datatype(t) && ((jl_datatype_t*)t)->isconcretetype;
 }
 
 static bool jl_is_pointerfree(jl_value_t* t)
 {
-    if (!jl_is_immutable_datatype(t))
+    if (!jl_is_concrete_immutable(t))
         return 0;
     const jl_datatype_layout_t *layout = ((jl_datatype_t*)t)->layout;
     return layout && layout->npointers == 0;
@@ -3070,9 +3070,9 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                 return true;
             }
 
-            if (jl_is_datatype(utt) && utt->layout) {
+            if (jl_is_datatype(utt) && jl_struct_try_layout(utt)) {
                 ssize_t idx = jl_field_index(utt, name, 0);
-                if (idx != -1) {
+                if (idx != -1 && !jl_has_free_typevars(jl_field_type(utt, idx))) {
                     *ret = emit_getfield_knownidx(ctx, obj, idx, utt, order);
                     return true;
                 }
@@ -3100,14 +3100,16 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
             }
 
             if (jl_is_datatype(utt)) {
-                if (jl_is_structtype(utt) && utt->layout) {
+                if (jl_struct_try_layout(utt)) {
                     size_t nfields = jl_datatype_nfields(utt);
                     // integer index
                     size_t idx;
                     if (fld.constant && (idx = jl_unbox_long(fld.constant) - 1) < nfields) {
-                        // known index
-                        *ret = emit_getfield_knownidx(ctx, obj, idx, utt, order);
-                        return true;
+                        if (!jl_has_free_typevars(jl_field_type(utt, idx))) {
+                            // known index
+                            *ret = emit_getfield_knownidx(ctx, obj, idx, utt, order);
+                            return true;
+                        }
                     }
                     else {
                         // unknown index
@@ -3152,8 +3154,6 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                 }
             }
         }
-        // TODO: attempt better codegen for approximate types, if the types
-        // and offsets of some fields are independent of parameters.
         // TODO: generic getfield func with more efficient calling convention
         return false;
     }
@@ -3177,7 +3177,7 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
         }
 
         jl_datatype_t *uty = (jl_datatype_t*)jl_unwrap_unionall(obj.typ);
-        if (jl_is_structtype(uty) && uty->layout) {
+        if (jl_is_datatype(uty) && jl_struct_try_layout(uty)) {
             ssize_t idx = -1;
             if (fld.constant && fld.typ == (jl_value_t*)jl_symbol_type) {
                 idx = jl_field_index(uty, (jl_sym_t*)fld.constant, 0);
diff --git a/src/datatype.c b/src/datatype.c
index 9bad2bc3d3bd8..a321b417d91c0 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -220,27 +220,36 @@ unsigned jl_special_vector_alignment(size_t nfields, jl_value_t *t)
     return next_power_of_two(size);
 }
 
-STATIC_INLINE int jl_is_datatype_make_singleton(jl_datatype_t *d)
+STATIC_INLINE int jl_is_datatype_make_singleton(jl_datatype_t *d) JL_NOTSAFEPOINT
 {
     return (!d->name->abstract && jl_datatype_size(d) == 0 && d != jl_symbol_type && d->name != jl_array_typename &&
             d->isconcretetype && !d->name->mutabl);
 }
 
-STATIC_INLINE void jl_maybe_allocate_singleton_instance(jl_datatype_t *st)
+STATIC_INLINE void jl_maybe_allocate_singleton_instance(jl_datatype_t *st) JL_NOTSAFEPOINT
 {
     if (jl_is_datatype_make_singleton(st)) {
         // It's possible for st to already have an ->instance if it was redefined
-        if (!st->instance) {
-            jl_task_t *ct = jl_current_task;
-            st->instance = jl_gc_alloc(ct->ptls, 0, st);
-            jl_gc_wb(st, st->instance);
-        }
+        if (!st->instance)
+            st->instance = jl_gc_permobj(0, st);
     }
 }
 
+// return whether all concrete subtypes of this type have the same layout
+int jl_struct_try_layout(jl_datatype_t *dt)
+{
+    if (dt->layout)
+        return 1;
+    else if (!jl_has_fixed_layout(dt))
+        return 0;
+    jl_compute_field_offsets(dt);
+    assert(dt->layout);
+    return 1;
+}
+
 int jl_datatype_isinlinealloc(jl_datatype_t *ty, int pointerfree) JL_NOTSAFEPOINT
 {
-    if (ty->name->mayinlinealloc && ty->layout) {
+    if (ty->name->mayinlinealloc && (ty->isconcretetype || ((jl_datatype_t*)jl_unwrap_unionall(ty->name->wrapper))->layout)) { // TODO: use jl_struct_try_layout(dt) (but it is a safepoint)
         if (ty->layout->npointers > 0) {
             if (pointerfree)
                 return 0;
@@ -348,9 +357,6 @@ void jl_compute_field_offsets(jl_datatype_t *st)
     if (st->name->wrapper == NULL)
         return; // we got called too early--we'll be back
     jl_datatype_t *w = (jl_datatype_t*)jl_unwrap_unionall(st->name->wrapper);
-    assert(st->types && w->types);
-    size_t i, nfields = jl_svec_len(st->types);
-    assert(st->name->n_uninitialized <= nfields);
     if (st == w && st->layout) {
         // this check allows us to force re-computation of the layout for some types during init
         st->layout = NULL;
@@ -358,6 +364,7 @@ void jl_compute_field_offsets(jl_datatype_t *st)
         st->zeroinit = 0;
         st->has_concrete_subtype = 1;
     }
+    int isbitstype = st->isconcretetype && st->name->mayinlinealloc;
     // If layout doesn't depend on type parameters, it's stored in st->name->wrapper
     // and reused by all subtypes.
     if (w->layout) {
@@ -365,11 +372,16 @@ void jl_compute_field_offsets(jl_datatype_t *st)
         st->size = w->size;
         st->zeroinit = w->zeroinit;
         st->has_concrete_subtype = w->has_concrete_subtype;
-        if (jl_is_layout_opaque(st->layout)) { // e.g. jl_array_typename
-            return;
+        if (!jl_is_layout_opaque(st->layout)) { // e.g. jl_array_typename
+            st->isbitstype = isbitstype && st->layout->npointers == 0;
+            jl_maybe_allocate_singleton_instance(st);
         }
+        return;
     }
-    else if (nfields == 0) {
+    assert(st->types && w->types);
+    size_t i, nfields = jl_svec_len(st->types);
+    assert(st->name->n_uninitialized <= nfields);
+    if (nfields == 0) {
         // if we have no fields, we can trivially skip the rest
         if (st == jl_symbol_type || st == jl_string_type) {
             // opaque layout - heap-allocated blob
@@ -404,7 +416,6 @@ void jl_compute_field_offsets(jl_datatype_t *st)
         }
     }
 
-    int isbitstype = st->isconcretetype && st->name->mayinlinealloc;
     for (i = 0; isbitstype && i < nfields; i++) {
         jl_value_t *fld = jl_field_type(st, i);
         isbitstype = jl_isbits(fld);
diff --git a/src/jltypes.c b/src/jltypes.c
index f9f60f1227b9a..886abadb046e0 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -223,7 +223,9 @@ int jl_has_fixed_layout(jl_datatype_t *dt)
 {
     if (dt->layout || dt->isconcretetype)
         return 1;
-    if (jl_is_tuple_type(dt))
+    if (dt->name->abstract)
+        return 0;
+    if (jl_is_tuple_type(dt) || jl_is_namedtuple_type(dt))
         return 0; // TODO: relax more?
     jl_svec_t *types = jl_get_fieldtypes(dt);
     size_t i, l = jl_svec_len(types);
@@ -242,9 +244,10 @@ int jl_type_mappable_to_c(jl_value_t *ty)
     assert(!jl_is_typevar(ty) && jl_is_type(ty));
     if (jl_is_structtype(ty)) {
         jl_datatype_t *jst = (jl_datatype_t*)ty;
-        return jst->layout || jl_has_fixed_layout(jst);
+        return jl_has_fixed_layout(jst);
     }
-    if (jl_is_tuple_type(jl_unwrap_unionall(ty)))
+    ty = jl_unwrap_unionall(ty);
+    if (jl_is_tuple_type(ty) || jl_is_namedtuple_type(ty))
         return 0; // TODO: relax some?
     return 1; // as boxed or primitive
 }
@@ -1437,7 +1440,7 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
     jl_gc_wb(ndt, ndt->parameters);
     ndt->types = NULL; // to be filled in below
     if (istuple) {
-        ndt->types = p;
+        ndt->types = p; // TODO: this may need to filter out certain types
     }
     else if (isnamedtuple) {
         jl_value_t *names_tup = jl_svecref(p, 0);
@@ -1463,19 +1466,16 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
             jl_gc_wb(ndt, ndt->types);
         }
         else {
-            ndt->types = jl_emptysvec;
+            ndt->types = jl_emptysvec; // XXX: this is essentially always false
         }
     }
-    ndt->size = 0;
-    jl_precompute_memoized_dt(ndt, cacheable);
-
-    if (jl_is_primitivetype(dt)) {
-        ndt->size = dt->size;
-        ndt->layout = dt->layout;
-        ndt->isbitstype = ndt->isconcretetype;
-    }
 
     jl_datatype_t *primarydt = ((jl_datatype_t*)jl_unwrap_unionall(tn->wrapper));
+    jl_precompute_memoized_dt(ndt, cacheable);
+    ndt->size = 0;
+    if (primarydt->layout)
+        jl_compute_field_offsets(ndt);
+
     if (istuple || isnamedtuple) {
         ndt->super = jl_any_type;
     }
@@ -1516,7 +1516,7 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
     // leading to incorrect layouts and data races (#40050: the A{T} should be
     // an isbitstype singleton of size 0)
     if (cacheable) {
-        if (!jl_is_primitivetype(dt) && ndt->types != NULL && ndt->isconcretetype) {
+        if (dt->layout == NULL && !jl_is_primitivetype(dt) && ndt->types != NULL && ndt->isconcretetype) {
             jl_compute_field_offsets(ndt);
         }
         jl_cache_type_(ndt);
diff --git a/src/julia_internal.h b/src/julia_internal.h
index e6bb2ae8602d3..11eb24330c638 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -370,7 +370,7 @@ STATIC_INLINE jl_gc_tracked_buffer_t *jl_gc_alloc_buf(jl_ptls_t ptls, size_t sz)
     return jl_gc_alloc(ptls, sz, (void*)jl_buff_tag);
 }
 
-STATIC_INLINE jl_value_t *jl_gc_permobj(size_t sz, void *ty)
+STATIC_INLINE jl_value_t *jl_gc_permobj(size_t sz, void *ty) JL_NOTSAFEPOINT
 {
     const size_t allocsz = sz + sizeof(jl_taggedvalue_t);
     unsigned align = (sz == 0 ? sizeof(void*) : (allocsz <= sizeof(void*) * 2 ?
@@ -521,6 +521,7 @@ jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_a
 int jl_obviously_unequal(jl_value_t *a, jl_value_t *b);
 JL_DLLEXPORT jl_array_t *jl_find_free_typevars(jl_value_t *v);
 int jl_has_fixed_layout(jl_datatype_t *t);
+int jl_struct_try_layout(jl_datatype_t *dt);
 int jl_type_mappable_to_c(jl_value_t *ty);
 jl_svec_t *jl_outer_unionall_vars(jl_value_t *u);
 jl_value_t *jl_type_intersection_env_s(jl_value_t *a, jl_value_t *b, jl_svec_t **penv, int *issubty);
diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl
index b8fa5536865bb..df29a339d5a85 100644
--- a/test/compiler/codegen.jl
+++ b/test/compiler/codegen.jl
@@ -580,3 +580,16 @@ g40612(a, b) = a[]|a[] === b[]|b[]
 @test g40612(Union{Bool,Missing}[missing], Union{Bool,Missing}[missing])
 @test g40612(Union{Bool,Missing}[true], Union{Bool,Missing}[true])
 @test g40612(Union{Bool,Missing}[false], Union{Bool,Missing}[false])
+
+# issue #41438
+struct A41438{T}
+  x::Ptr{T}
+end
+struct B41438{T}
+  x::T
+end
+f41438(y) = y[].x
+@test A41438.body.layout != C_NULL
+@test B41438.body.layout === C_NULL
+@test f41438(Ref{A41438}(A41438(C_NULL))) === C_NULL
+@test f41438(Ref{B41438}(B41438(C_NULL))) === C_NULL

From 585536fd9be63732d2061695155ea88c57984325 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Sun, 4 Jul 2021 23:16:47 +0200
Subject: [PATCH 38/44] remove dependency of Pkg from libblastrampoline_jll
 (#41460)

(cherry picked from commit 5faad5fee902b8654880d97ed0d9e533083bded2)
---
 stdlib/libblastrampoline_jll/Project.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stdlib/libblastrampoline_jll/Project.toml b/stdlib/libblastrampoline_jll/Project.toml
index d44c420b56332..5eb555f4f326b 100644
--- a/stdlib/libblastrampoline_jll/Project.toml
+++ b/stdlib/libblastrampoline_jll/Project.toml
@@ -3,7 +3,6 @@ uuid = "8e850b90-86db-534c-a0d3-1478176c7d93"
 version = "3.0.4+0"
 
 [deps]
-Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
 OpenBLAS_jll = "4536629a-c528-5b80-bd46-f80d51c5b363"

From c00da173df59ddf97a549af44641b84dbf6f44ce Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Mon, 5 Jul 2021 10:06:35 +0200
Subject: [PATCH 39/44] Export jl_field_index from libjulia

(cherry picked from commit 18f41425eb12e089a15890ac695fd8a814a01be2)
---
 src/jl_exported_funcs.inc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 85c6e79ad27a8..81e68f3b78ee7 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -149,6 +149,7 @@
     XX(jl_expand_with_loc) \
     XX(jl_expand_with_loc_warn) \
     XX(jl_extern_c) \
+    XX(jl_field_index) \
     XX(jl_gc_add_finalizer) \
     XX(jl_gc_add_finalizer_th) \
     XX(jl_gc_add_ptr_finalizer) \

From f4a3ec8f73e53d0ec5ec9a77d9017c6543cb84af Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Mon, 5 Jul 2021 19:19:16 -0400
Subject: [PATCH 40/44] MPFR tests: skip the `log2(x) == log2(42)` test
 (#41473)

* MPFR tests: mark the `log2(x) == log2(42)` test as broken on Windows

* Apply suggestions from code review

Co-authored-by: Simeon Schaub <simeondavidschaub99@gmail.com>

Co-authored-by: Simeon Schaub <simeondavidschaub99@gmail.com>
(cherry picked from commit fee57110d517e01b7018303f550e686275e92676)
---
 test/mpfr.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/mpfr.jl b/test/mpfr.jl
index a4fac9c93c79a..0b6ff30e372dc 100644
--- a/test/mpfr.jl
+++ b/test/mpfr.jl
@@ -606,7 +606,8 @@ end
         @test log(x) == log(42)
         @test isinf(log(BigFloat(0)))
         @test_throws DomainError log(BigFloat(-1))
-        @test log2(x) == log2(42)
+        # issue #41450
+        @test_skip log2(x) == log2(42)
         @test isinf(log2(BigFloat(0)))
         @test_throws DomainError log2(BigFloat(-1))
         @test log10(x) == log10(42)

From e5b3e4fa144e09fd24bbac7daeea1b2960d5d230 Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Mon, 5 Jul 2021 20:58:41 -0400
Subject: [PATCH 41/44] Remove mentions of `USE_INTEL_MKL` from the build docs
 (#41474)

(cherry picked from commit bd665cf48976bcd13bd8d6fcf5691deaa73a56e5)
---
 doc/build/build.md | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/doc/build/build.md b/doc/build/build.md
index 3d351bd83e71c..89b293a57df30 100644
--- a/doc/build/build.md
+++ b/doc/build/build.md
@@ -250,21 +250,6 @@ Julia uses a custom fork of libuv. It is a small dependency, and can be safely b
 
 As a high-performance numerical language, Julia should be linked to a multi-threaded BLAS and LAPACK, such as OpenBLAS or ATLAS, which will provide much better performance than the reference `libblas` implementations which may be default on some systems.
 
-### Intel MKL
-
-**Note:** If you are building Julia for the sole purpose of incorporating Intel MKL, it may be beneficial to first try [MKL.jl](https://github.com/JuliaComputing/MKL.jl). This package will automatically download MKL and rebuild Julia's system image against it, sidestepping the need to set up a working build environment just to add MKL functionality. MKL.jl replaces OpenBLAS with MKL for dense linear algebra functions called directly from Julia, but SuiteSparse and other C/Fortran libraries will continue to use the BLAS they were linked against at build time. If you want SuiteSparse to use MKL, you will need to build from source.
-
-For a 64-bit architecture, the environment should be set up as follows:
-```sh
-# bash
-source /path/to/intel/bin/compilervars.sh intel64
-```
-Add the following to the `Make.user` file:
-
-    USE_INTEL_MKL = 1
-
-It is highly recommended to start with a fresh clone of the Julia repository.
-
 ## Source distributions of releases
 
 Each pre-release and release of Julia has a "full" source distribution and a "light" source

From 4bda75ca0c67b3a42a23da05e865f64987e0b202 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 6 Jul 2021 09:48:28 +0200
Subject: [PATCH 42/44] put back Any16 and All16 since some packges seem to
 rely on it (#41469)

(cherry picked from commit 261906c2094c155ba4891721c26cfdcd960ea145)
---
 base/deprecated.jl | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/base/deprecated.jl b/base/deprecated.jl
index d60cc3393662c..c2a717a403a90 100644
--- a/base/deprecated.jl
+++ b/base/deprecated.jl
@@ -240,6 +240,12 @@ end
 @deprecate cat_shape(dims, shape::Tuple{}, shapes::Tuple...) cat_shape(dims, shapes) false
 cat_shape(dims, shape::Tuple{}) = () # make sure `cat_shape(dims, ())` do not recursively calls itself
 
+# these were internal type aliases, but some pacakges seem to be relying on them
+const Any16{N} = Tuple{Any,Any,Any,Any,Any,Any,Any,Any,
+                        Any,Any,Any,Any,Any,Any,Any,Any,Vararg{Any,N}}
+const All16{T,N} = Tuple{T,T,T,T,T,T,T,T,
+                         T,T,T,T,T,T,T,T,Vararg{T,N}}
+
 # END 1.6 deprecations
 
 # BEGIN 1.7 deprecations

From 8b6a7ea096e5824d2e07ea3a4e02f75a149835de Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 24 Jun 2021 11:14:23 -0400
Subject: [PATCH 43/44] codegen: add optimizations for swapfield and
 replacefield (#41275)

(cherry picked from commit 5650c93f1aa45a17c10c9482e5d3e0042cf4cc6b)
---
 src/builtins.c                     |   6 +-
 src/cgutils.cpp                    | 423 ++++++++++++++++++++++++-----
 src/codegen.cpp                    | 155 +++++------
 src/intrinsics.cpp                 |   3 +-
 src/llvm-gc-invariant-verifier.cpp |  32 ++-
 src/llvm-late-gc-lowering.cpp      |  31 ++-
 src/llvm-propagate-addrspaces.cpp  |  34 ++-
 test/atomics.jl                    |  16 +-
 8 files changed, 510 insertions(+), 190 deletions(-)

diff --git a/src/builtins.c b/src/builtins.c
index b5b4bb4069773..f40d694d23529 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -967,7 +967,9 @@ JL_CALLABLE(jl_f_replacefield)
         JL_TYPECHK(replacefield!, symbol, args[5]);
         failure_order = jl_get_atomic_order_checked((jl_sym_t*)args[5], 1, 0);
     }
-    // TODO: filter more invalid ordering combinations
+    if (failure_order > success_order)
+        jl_atomic_error("invalid atomic ordering");
+    // TODO: filter more invalid ordering combinations?
     jl_value_t *v = args[0];
     jl_datatype_t *st = (jl_datatype_t*)jl_typeof(v);
     size_t idx = get_checked_fieldindex("replacefield!", st, v, args[1], 1);
@@ -978,8 +980,6 @@ JL_CALLABLE(jl_f_replacefield)
     if (isatomic == (failure_order == jl_memory_order_notatomic))
         jl_atomic_error(isatomic ? "replacefield!: atomic field cannot be accessed non-atomically"
                                  : "replacefield!: non-atomic field cannot be accessed atomically");
-    if (failure_order > success_order)
-        jl_atomic_error("invalid atomic ordering");
     v = replace_nth_field(st, v, idx, args[2], args[3], isatomic); // always seq_cst, if isatomic needed at all
     return v;
 }
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 5f4ef560c83ce..f715abb3b490b 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -1064,6 +1064,7 @@ static Value *null_pointer_cmp(jl_codectx_t &ctx, Value *v)
     return ctx.builder.CreateICmpNE(v, Constant::getNullValue(v->getType()));
 }
 
+
 // If `nullcheck` is not NULL and a pointer NULL check is necessary
 // store the pointer to be checked in `*nullcheck` instead of checking it
 static void null_pointer_check(jl_codectx_t &ctx, Value *v, Value **nullcheck = nullptr)
@@ -1076,6 +1077,62 @@ static void null_pointer_check(jl_codectx_t &ctx, Value *v, Value **nullcheck =
             literal_pointer_val(ctx, jl_undefref_exception));
 }
 
+template<typename Func>
+static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, Value *defval, Func &&func)
+{
+    if (auto Cond = dyn_cast<ConstantInt>(ifnot)) {
+        if (Cond->isZero())
+            return defval;
+        return func();
+    }
+    BasicBlock *currBB = ctx.builder.GetInsertBlock();
+    BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext, "guard_pass", ctx.f);
+    BasicBlock *exitBB = BasicBlock::Create(jl_LLVMContext, "guard_exit", ctx.f);
+    ctx.builder.CreateCondBr(ifnot, passBB, exitBB);
+    ctx.builder.SetInsertPoint(passBB);
+    auto res = func();
+    passBB = ctx.builder.GetInsertBlock();
+    ctx.builder.CreateBr(exitBB);
+    ctx.builder.SetInsertPoint(exitBB);
+    if (defval == nullptr)
+        return nullptr;
+    PHINode *phi = ctx.builder.CreatePHI(defval->getType(), 2);
+    phi->addIncoming(defval, currBB);
+    phi->addIncoming(res, passBB);
+    return phi;
+}
+
+template<typename Func>
+static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, bool defval, Func &&func)
+{
+    return emit_guarded_test(ctx, ifnot, ConstantInt::get(T_int1, defval), func);
+}
+
+template<typename Func>
+static Value *emit_nullcheck_guard(jl_codectx_t &ctx, Value *nullcheck, Func &&func)
+{
+    if (!nullcheck)
+        return func();
+    return emit_guarded_test(ctx, null_pointer_cmp(ctx, nullcheck), false, func);
+}
+
+template<typename Func>
+static Value *emit_nullcheck_guard2(jl_codectx_t &ctx, Value *nullcheck1,
+                                    Value *nullcheck2, Func &&func)
+{
+    if (!nullcheck1)
+        return emit_nullcheck_guard(ctx, nullcheck2, func);
+    if (!nullcheck2)
+        return emit_nullcheck_guard(ctx, nullcheck1, func);
+    nullcheck1 = null_pointer_cmp(ctx, nullcheck1);
+    nullcheck2 = null_pointer_cmp(ctx, nullcheck2);
+    // If both are NULL, return true.
+    return emit_guarded_test(ctx, ctx.builder.CreateOr(nullcheck1, nullcheck2), true, [&] {
+        return emit_guarded_test(ctx, ctx.builder.CreateAnd(nullcheck1, nullcheck2),
+                                 false, func);
+    });
+}
+
 static void emit_type_error(jl_codectx_t &ctx, const jl_cgval_t &x, Value *type, const std::string &msg)
 {
     Value *msg_val = stringConstPtr(ctx.emission_context, ctx.builder, msg);
@@ -1398,6 +1455,19 @@ Value *extract_first_ptr(jl_codectx_t &ctx, Value *V)
     return ctx.builder.CreateExtractValue(V, path);
 }
 
+
+static void emit_lockstate_value(jl_codectx_t &ctx, Value *strct, bool newstate)
+{
+    Value *v = mark_callee_rooted(ctx, strct);
+    ctx.builder.CreateCall(prepare_call(newstate ? jllockvalue_func : jlunlockvalue_func), v);
+}
+static void emit_lockstate_value(jl_codectx_t &ctx, const jl_cgval_t &strct, bool newstate)
+{
+    assert(strct.isboxed);
+    emit_lockstate_value(ctx, boxed(ctx, strct), newstate);
+}
+
+
 // If `nullcheck` is not NULL and a pointer NULL check is necessary
 // store the pointer to be checked in `*nullcheck` instead of checking it
 static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, jl_value_t *jltype,
@@ -1461,18 +1531,24 @@ static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, j
     return mark_julia_type(ctx, load, isboxed, jltype);
 }
 
-static void typed_store(jl_codectx_t &ctx,
-        Value *ptr, Value *idx_0based, const jl_cgval_t &rhs,
+static jl_cgval_t typed_store(jl_codectx_t &ctx,
+        Value *ptr, Value *idx_0based, const jl_cgval_t &rhs, const jl_cgval_t &cmp,
         jl_value_t *jltype, MDNode *tbaa, MDNode *aliasscope,
         Value *parent,  // for the write barrier, NULL if no barrier needed
-        bool isboxed, AtomicOrdering Order, unsigned alignment = 0)
+        bool isboxed, AtomicOrdering Order, AtomicOrdering FailOrder, unsigned alignment,
+        bool needlock, bool issetfield, bool isreplacefield, bool maybe_null_if_boxed)
 {
+    assert(!needlock || parent != nullptr);
+    jl_cgval_t oldval = rhs;
     Type *elty = isboxed ? T_prjlvalue : julia_type_to_llvm(ctx, jltype);
     if (type_is_ghost(elty))
-        return;
+        return oldval;
+    Value *intcast = nullptr;
     if (!isboxed && Order != AtomicOrdering::NotAtomic && !elty->isIntOrPtrTy() && !elty->isFloatingPointTy()) {
         const DataLayout &DL = jl_data_layout;
         unsigned nb = DL.getTypeSizeInBits(elty);
+        if (!issetfield)
+            intcast = ctx.builder.CreateAlloca(elty);
         elty = Type::getIntNTy(jl_LLVMContext, nb);
     }
     Value *r;
@@ -1489,18 +1565,206 @@ static void typed_store(jl_codectx_t &ctx,
         alignment = sizeof(void*);
     else if (!alignment)
         alignment = julia_alignment(jltype);
-    StoreInst *store = ctx.builder.CreateAlignedStore(r, ptr, Align(alignment));
-    store->setOrdering(Order);
-    if (aliasscope)
-        store->setMetadata("noalias", aliasscope);
-    if (tbaa)
-        tbaa_decorate(tbaa, store);
+    Instruction *instr = nullptr;
+    Value *Compare = nullptr;
+    Value *Success = nullptr;
+    BasicBlock *DoneBB = issetfield || (!isreplacefield && !isboxed) ? nullptr : BasicBlock::Create(jl_LLVMContext, "done_xchg", ctx.f);
+    if (needlock)
+        emit_lockstate_value(ctx, parent, true);
+    if (issetfield || Order == AtomicOrdering::NotAtomic) {
+        if (!issetfield) {
+            instr = ctx.builder.CreateAlignedLoad(elty, ptr, Align(alignment));
+            if (aliasscope)
+                instr->setMetadata("noalias", aliasscope);
+            if (tbaa)
+                tbaa_decorate(tbaa, instr);
+        }
+        if (isreplacefield) {
+            oldval = mark_julia_type(ctx, instr, isboxed, jltype);
+            Value *first_ptr = nullptr;
+            if (maybe_null_if_boxed)
+                first_ptr = isboxed ? instr : extract_first_ptr(ctx, instr);
+            Success = emit_nullcheck_guard(ctx, first_ptr, [&] {
+                return emit_f_is(ctx, oldval, cmp);
+            });
+            BasicBlock *BB = BasicBlock::Create(jl_LLVMContext, "xchg", ctx.f);
+            ctx.builder.CreateCondBr(Success, BB, DoneBB);
+            ctx.builder.SetInsertPoint(BB);
+        }
+        StoreInst *store = ctx.builder.CreateAlignedStore(r, ptr, Align(alignment));
+        store->setOrdering(Order);
+        if (aliasscope)
+            store->setMetadata("noalias", aliasscope);
+        if (tbaa)
+            tbaa_decorate(tbaa, store);
+        if (DoneBB)
+            ctx.builder.CreateBr(DoneBB);
+    }
+    else if (isboxed || isreplacefield) {
+        // we have to handle isboxed here as a workaround for really bad LLVM design issue: plain Xchg only works with integers
+        bool needloop;
+        PHINode *Succ = nullptr, *Current = nullptr;
+        if (isreplacefield) {
+            if (!isboxed) {
+                needloop = ((jl_datatype_t*)jltype)->layout->haspadding;
+                Value *SameType = emit_isa(ctx, cmp, jltype, nullptr).first;
+                if (SameType != ConstantInt::getTrue(jl_LLVMContext)) {
+                    BasicBlock *SkipBB = BasicBlock::Create(jl_LLVMContext, "skip_xchg", ctx.f);
+                    BasicBlock *BB = BasicBlock::Create(jl_LLVMContext, "xchg", ctx.f);
+                    ctx.builder.CreateCondBr(SameType, BB, SkipBB);
+                    ctx.builder.SetInsertPoint(SkipBB);
+                    LoadInst *load = ctx.builder.CreateAlignedLoad(elty, ptr, Align(alignment));
+                    load->setOrdering(FailOrder);
+                    if (aliasscope)
+                        load->setMetadata("noalias", aliasscope);
+                    if (tbaa)
+                        tbaa_decorate(tbaa, load);
+                    instr = load;
+                    ctx.builder.CreateBr(DoneBB);
+                    ctx.builder.SetInsertPoint(DoneBB);
+                    Succ = ctx.builder.CreatePHI(T_int1, 2);
+                    Succ->addIncoming(ConstantInt::get(T_int1, 0), SkipBB);
+                    Current = ctx.builder.CreatePHI(instr->getType(), 2);
+                    Current->addIncoming(instr, SkipBB);
+                    ctx.builder.SetInsertPoint(BB);
+                }
+                Compare = emit_unbox(ctx, elty, cmp, jltype);
+            }
+            else if (cmp.isboxed) {
+                Compare = boxed(ctx, cmp);
+                needloop = !jl_is_mutable_datatype(jltype);
+            }
+            else {
+                Compare = V_rnull;
+                needloop = true;
+            }
+        }
+        else {
+            LoadInst *Current = ctx.builder.CreateAlignedLoad(elty, ptr, Align(alignment));
+            Current->setOrdering(AtomicOrdering::Monotonic);
+            if (aliasscope)
+                Current->setMetadata("noalias", aliasscope);
+            if (tbaa)
+                tbaa_decorate(tbaa, Current);
+            Compare = Current;
+            needloop = true;
+        }
+        BasicBlock *BB;
+        if (needloop) {
+            BasicBlock *From = ctx.builder.GetInsertBlock();
+            BB = BasicBlock::Create(jl_LLVMContext, "xchg", ctx.f);
+            ctx.builder.CreateBr(BB);
+            ctx.builder.SetInsertPoint(BB);
+            PHINode *Cmp = ctx.builder.CreatePHI(r->getType(), 2);
+            Cmp->addIncoming(Compare, From);
+            Compare = Cmp;
+        }
+        if (Order == AtomicOrdering::Unordered)
+            Order = AtomicOrdering::Monotonic;
+        if (!isreplacefield)
+            FailOrder = AtomicOrdering::Monotonic;
+        else if (FailOrder == AtomicOrdering::Unordered)
+            FailOrder = AtomicOrdering::Monotonic;
+#if JL_LLVM_VERSION >= 130000
+        auto *store = ctx.builder.CreateAtomicCmpXchg(ptr, Compare, r, Align(alignment), Order, FailOrder);
+#else
+        auto *store = ctx.builder.CreateAtomicCmpXchg(ptr, Compare, r, Order, FailOrder);
+        store->setAlignment(Align(alignment));
+#endif
+        if (aliasscope)
+            store->setMetadata("noalias", aliasscope);
+        if (tbaa)
+            tbaa_decorate(tbaa, store);
+        instr = ctx.builder.Insert(ExtractValueInst::Create(store, 0));
+        Success = ctx.builder.CreateExtractValue(store, 1);
+        Value *Done = Success;
+        if (needloop) {
+            if (isreplacefield) {
+                if (intcast) {
+                    ctx.builder.CreateStore(instr, ctx.builder.CreateBitCast(intcast, instr->getType()->getPointerTo()));
+                    oldval = mark_julia_slot(intcast, jltype, NULL, tbaa_stack);
+                }
+                else {
+                    oldval = mark_julia_type(ctx, instr, isboxed, jltype);
+                }
+                Done = emit_guarded_test(ctx, ctx.builder.CreateNot(Success), false, [&] {
+                    Value *first_ptr = nullptr;
+                    if (maybe_null_if_boxed)
+                        first_ptr = isboxed ? instr : extract_first_ptr(ctx, instr);
+                    return emit_nullcheck_guard(ctx, first_ptr, [&] {
+                        return emit_f_is(ctx, oldval, cmp);
+                    });
+                });
+                Done = ctx.builder.CreateNot(Done);
+            }
+            cast<PHINode>(Compare)->addIncoming(instr, ctx.builder.GetInsertBlock());
+        }
+        if (Succ != nullptr) {
+            Current->addIncoming(instr, ctx.builder.GetInsertBlock());
+            instr = Current;
+            Succ->addIncoming(Success, ctx.builder.GetInsertBlock());
+            Success = Succ;
+        }
+        if (needloop)
+            ctx.builder.CreateCondBr(Done, DoneBB, BB);
+        else
+            ctx.builder.CreateBr(DoneBB);
+    }
+    else {
+#if JL_LLVM_VERSION >= 130000
+        instr = ctx.builder.CreateAtomicRMW(AtomicRMWInst::Xchg, ptr, r, Align(alignment), Order);
+#else
+        auto *store = ctx.builder.CreateAtomicRMW(AtomicRMWInst::Xchg, ptr, r, Order);
+        store->setAlignment(Align(alignment));
+        instr = store;
+#endif
+        if (aliasscope)
+            instr->setMetadata("noalias", aliasscope);
+        if (tbaa)
+            tbaa_decorate(tbaa, instr);
+        assert(DoneBB == nullptr);
+    }
+    if (DoneBB)
+        ctx.builder.SetInsertPoint(DoneBB);
+    if (needlock)
+        emit_lockstate_value(ctx, parent, false);
     if (parent != NULL) {
+        BasicBlock *DoneBB;
+        if (isreplacefield) {
+            // TOOD: avoid this branch if we aren't making a write barrier
+            BasicBlock *BB = BasicBlock::Create(jl_LLVMContext, "xchg_wb", ctx.f);
+            DoneBB = BasicBlock::Create(jl_LLVMContext, "done_xchg_wb", ctx.f);
+            ctx.builder.CreateCondBr(Success, BB, DoneBB);
+            ctx.builder.SetInsertPoint(BB);
+        }
         if (!isboxed)
             emit_write_multibarrier(ctx, parent, r, rhs.typ);
         else if (!type_is_permalloc(rhs.typ))
             emit_write_barrier(ctx, parent, r);
+        if (isreplacefield) {
+            ctx.builder.CreateBr(DoneBB);
+            ctx.builder.SetInsertPoint(DoneBB);
+        }
+    }
+    if (!issetfield) {
+        if (intcast) {
+            ctx.builder.CreateStore(instr, ctx.builder.CreateBitCast(intcast, instr->getType()->getPointerTo()));
+            instr = ctx.builder.CreateLoad(intcast);
+        }
+        if (maybe_null_if_boxed) {
+            Value *first_ptr = isboxed ? instr : extract_first_ptr(ctx, instr);
+            if (first_ptr)
+                null_pointer_check(ctx, first_ptr, nullptr);
+        }
+        oldval = mark_julia_type(ctx, instr, isboxed, jltype);
+        if (isreplacefield) {
+            // TODO: do better here
+            jl_cgval_t argv[2] = {oldval, mark_julia_type(ctx, Success, false, jl_bool_type)};
+            instr = emit_jlcall(ctx, jltuple_func, V_rnull, argv, 2, JLCALL_F_CC);
+            oldval = mark_julia_type(ctx, instr, true, jl_any_type);
+        }
     }
+    return oldval;
 }
 
 // --- convert boolean value to julia ---
@@ -1754,11 +2018,22 @@ static bool emit_getfield_unknownidx(jl_codectx_t &ctx,
     return false;
 }
 
-static void emit_lockstate_value(jl_codectx_t &ctx, const jl_cgval_t &strct, bool newstate)
+static jl_cgval_t emit_unionload(jl_codectx_t &ctx, Value *addr, Value *ptindex, jl_value_t *jfty, size_t fsz, size_t al, MDNode *tbaa, bool mutabl)
 {
-    assert(strct.isboxed);
-    Value *v = mark_callee_rooted(ctx, boxed(ctx, strct));
-    ctx.builder.CreateCall(prepare_call(newstate ? jllockvalue_func : jlunlockvalue_func), v);
+    Instruction *tindex0 = tbaa_decorate(tbaa_unionselbyte, ctx.builder.CreateAlignedLoad(T_int8, ptindex, Align(1)));
+    //tindex0->setMetadata(LLVMContext::MD_range, MDNode::get(jl_LLVMContext, {
+    //    ConstantAsMetadata::get(ConstantInt::get(T_int8, 0)),
+    //    ConstantAsMetadata::get(ConstantInt::get(T_int8, union_max)) }));
+    Value *tindex = ctx.builder.CreateNUWAdd(ConstantInt::get(T_int8, 1), tindex0);
+    if (mutabl) {
+        // move value to an immutable stack slot (excluding tindex)
+        Type *ET = IntegerType::get(jl_LLVMContext, 8 * al);
+        AllocaInst *lv = emit_static_alloca(ctx, ET);
+        lv->setOperand(0, ConstantInt::get(T_int32, (fsz + al - 1) / al));
+        emit_memcpy(ctx, lv, tbaa, addr, tbaa, fsz, al);
+        addr = lv;
+    }
+    return mark_julia_slot(addr, jfty, tindex, tbaa);
 }
 
 // If `nullcheck` is not NULL and a pointer NULL check is necessary
@@ -1839,20 +2114,7 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
             else {
                 ptindex = emit_struct_gep(ctx, cast<StructType>(lt), staddr, byte_offset + fsz);
             }
-            Instruction *tindex0 = tbaa_decorate(tbaa_unionselbyte, ctx.builder.CreateAlignedLoad(T_int8, ptindex, Align(1)));
-            //tindex0->setMetadata(LLVMContext::MD_range, MDNode::get(jl_LLVMContext, {
-            //    ConstantAsMetadata::get(ConstantInt::get(T_int8, 0)),
-            //    ConstantAsMetadata::get(ConstantInt::get(T_int8, union_max)) }));
-            Value *tindex = ctx.builder.CreateNUWAdd(ConstantInt::get(T_int8, 1), tindex0);
-            if (jt->name->mutabl) {
-                // move value to an immutable stack slot (excluding tindex)
-                Type *ET = IntegerType::get(jl_LLVMContext, 8 * al);
-                AllocaInst *lv = emit_static_alloca(ctx, ET);
-                lv->setOperand(0, ConstantInt::get(T_int32, (fsz + al - 1) / al));
-                emit_memcpy(ctx, lv, tbaa, addr, tbaa, fsz, al);
-                addr = lv;
-            }
-            return mark_julia_slot(addr, jfty, tindex, tbaa);
+            return emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, jt->name->mutabl);
         }
         assert(jl_is_concrete_type(jfty));
         if (!jt->name->mutabl && !(maybe_null && (jfty == (jl_value_t*)jl_bool_type ||
@@ -2877,49 +3139,76 @@ static void emit_write_multibarrier(jl_codectx_t &ctx, Value *parent, Value *agg
 }
 
 
-static void emit_setfield(jl_codectx_t &ctx,
+static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
         jl_datatype_t *sty, const jl_cgval_t &strct, size_t idx0,
-        const jl_cgval_t &rhs, bool checked, bool wb, AtomicOrdering Order)
-{
-    if (sty->name->mutabl || !checked) {
-        assert(strct.ispointer());
-        size_t byte_offset = jl_field_offset(sty, idx0);
-        Value *addr = data_pointer(ctx, strct);
-        if (byte_offset > 0) {
-            addr = ctx.builder.CreateInBoundsGEP(
-                    T_int8,
-                    emit_bitcast(ctx, maybe_decay_tracked(ctx, addr), T_pint8),
-                    ConstantInt::get(T_size, byte_offset)); // TODO: use emit_struct_gep
-        }
-        jl_value_t *jfty = jl_svecref(sty->types, idx0);
-        if (!jl_field_isptr(sty, idx0) && jl_is_uniontype(jfty)) {
-            int fsz = jl_field_size(sty, idx0) - 1;
-            // compute tindex from rhs
-            jl_cgval_t rhs_union = convert_julia_type(ctx, rhs, jfty);
-            if (rhs_union.typ == jl_bottom_type)
-                return;
-            Value *tindex = compute_tindex_unboxed(ctx, rhs_union, jfty);
-            tindex = ctx.builder.CreateNUWSub(tindex, ConstantInt::get(T_int8, 1));
-            Value *ptindex = ctx.builder.CreateInBoundsGEP(T_int8, emit_bitcast(ctx, maybe_decay_tracked(ctx, addr), T_pint8), ConstantInt::get(T_size, fsz));
-            tbaa_decorate(tbaa_unionselbyte, ctx.builder.CreateAlignedStore(tindex, ptindex, Align(1)));
-            // copy data
-            if (!rhs.isghost) {
-                emit_unionmove(ctx, addr, strct.tbaa, rhs, nullptr);
-            }
-        }
-        else {
-            unsigned align = jl_field_align(sty, idx0);
-            bool isboxed = jl_field_isptr(sty, idx0);
-            typed_store(ctx, addr, NULL, rhs, jfty, strct.tbaa, nullptr,
-                wb ? maybe_bitcast(ctx, data_pointer(ctx, strct), T_pjlvalue) : nullptr,
-                isboxed, Order, align);
-        }
-    }
-    else {
+        const jl_cgval_t &rhs, const jl_cgval_t &cmp,
+        bool checked, bool wb, AtomicOrdering Order, AtomicOrdering FailOrder,
+        bool needlock, bool issetfield, bool isreplacefield)
+{
+    if (!sty->name->mutabl && checked) {
         std::string msg = "setfield!: immutable struct of type "
             + std::string(jl_symbol_name(sty->name->name))
             + " cannot be changed";
         emit_error(ctx, msg);
+        return jl_cgval_t();
+    }
+    assert(strct.ispointer());
+    size_t byte_offset = jl_field_offset(sty, idx0);
+    Value *addr = data_pointer(ctx, strct);
+    if (byte_offset > 0) {
+        addr = ctx.builder.CreateInBoundsGEP(
+                T_int8,
+                emit_bitcast(ctx, maybe_decay_tracked(ctx, addr), T_pint8),
+                ConstantInt::get(T_size, byte_offset)); // TODO: use emit_struct_gep
+    }
+    jl_value_t *jfty = jl_svecref(sty->types, idx0);
+    if (!jl_field_isptr(sty, idx0) && jl_is_uniontype(jfty)) {
+        size_t fsz = 0, al = 0;
+        bool isptr = !jl_islayout_inline(jfty, &fsz, &al);
+        assert(!isptr && fsz == jl_field_size(sty, idx0) - 1); (void)isptr;
+        // compute tindex from rhs
+        jl_cgval_t rhs_union = convert_julia_type(ctx, rhs, jfty);
+        if (rhs_union.typ == jl_bottom_type)
+            return jl_cgval_t();
+        Value *tindex = compute_tindex_unboxed(ctx, rhs_union, jfty);
+        tindex = ctx.builder.CreateNUWSub(tindex, ConstantInt::get(T_int8, 1));
+        Value *ptindex = ctx.builder.CreateInBoundsGEP(T_int8, emit_bitcast(ctx, maybe_decay_tracked(ctx, addr), T_pint8), ConstantInt::get(T_size, fsz));
+        if (needlock)
+            emit_lockstate_value(ctx, strct, true);
+        jl_cgval_t oldval = rhs;
+        if (!issetfield)
+            oldval = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, strct.tbaa, true);
+        Value *Success;
+        BasicBlock *DoneBB;
+        if (isreplacefield) {
+            BasicBlock *BB = BasicBlock::Create(jl_LLVMContext, "xchg", ctx.f);
+            DoneBB = BasicBlock::Create(jl_LLVMContext, "done_xchg", ctx.f);
+            Success = emit_f_is(ctx, oldval, cmp);
+            ctx.builder.CreateCondBr(Success, BB, DoneBB);
+            ctx.builder.SetInsertPoint(BB);
+        }
+        tbaa_decorate(tbaa_unionselbyte, ctx.builder.CreateAlignedStore(tindex, ptindex, Align(1)));
+        // copy data
+        if (!rhs.isghost) {
+            emit_unionmove(ctx, addr, strct.tbaa, rhs, nullptr);
+        }
+        if (isreplacefield) {
+            ctx.builder.CreateBr(DoneBB);
+            ctx.builder.SetInsertPoint(DoneBB);
+        }
+        if (needlock)
+            emit_lockstate_value(ctx, strct, false);
+        return oldval;
+    }
+    else {
+        unsigned align = jl_field_align(sty, idx0);
+        bool isboxed = jl_field_isptr(sty, idx0);
+        size_t nfields = jl_datatype_nfields(sty);
+        bool maybe_null = idx0 >= nfields - (unsigned)sty->name->n_uninitialized;
+        return typed_store(ctx, addr, NULL, rhs, cmp, jfty, strct.tbaa, nullptr,
+            wb ? maybe_bitcast(ctx, data_pointer(ctx, strct), T_pjlvalue) : nullptr,
+            isboxed, Order, FailOrder, align,
+            needlock, issetfield, isreplacefield, maybe_null);
     }
 }
 
@@ -3098,7 +3387,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
             else
                 need_wb = false;
             emit_typecheck(ctx, rhs, jl_svecref(sty->types, i), "new");
-            emit_setfield(ctx, sty, strctinfo, i, rhs, false, need_wb, AtomicOrdering::NotAtomic);
+            emit_setfield(ctx, sty, strctinfo, i, rhs, jl_cgval_t(), false, need_wb, AtomicOrdering::NotAtomic, AtomicOrdering::NotAtomic, false, true, false);
         }
         return strctinfo;
     }
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 5a4bc9fec6b4b..3d8ad33516080 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -879,6 +879,8 @@ static const std::map<jl_fptr_args_t, JuliaFunction*> builtin_func_map = {
     { &jl_f_isdefined,          new JuliaFunction{"jl_f_isdefined", get_func_sig, get_func_attrs} },
     { &jl_f_getfield,           new JuliaFunction{"jl_f_getfield", get_func_sig, get_func_attrs} },
     { &jl_f_setfield,           new JuliaFunction{"jl_f_setfield", get_func_sig, get_func_attrs} },
+    { &jl_f_swapfield,          new JuliaFunction{"jl_f_swapfield", get_func_sig, get_func_attrs} },
+    { &jl_f_modifyfield,        new JuliaFunction{"jl_f_modifyfield", get_func_sig, get_func_attrs} },
     { &jl_f_fieldtype,          new JuliaFunction{"jl_f_fieldtype", get_func_sig, get_func_attrs} },
     { &jl_f_nfields,            new JuliaFunction{"jl_f_nfields", get_func_sig, get_func_attrs} },
     { &jl_f__expr,              new JuliaFunction{"jl_f__expr", get_func_sig, get_func_attrs} },
@@ -1160,6 +1162,8 @@ static CallInst *emit_jlcall(jl_codectx_t &ctx, Function *theFptr, Value *theF,
                              jl_cgval_t *args, size_t nargs, CallingConv::ID cc);
 static CallInst *emit_jlcall(jl_codectx_t &ctx, JuliaFunction *theFptr, Value *theF,
                              jl_cgval_t *args, size_t nargs, CallingConv::ID cc);
+static Value *emit_f_is(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgval_t &arg2,
+                        Value *nullcheck1 = nullptr, Value *nullcheck2 = nullptr);
 
 static Value *literal_pointer_val(jl_codectx_t &ctx, jl_value_t *p);
 static GlobalVariable *prepare_global_in(Module *M, GlobalVariable *G);
@@ -1441,6 +1445,17 @@ static void alloc_def_flag(jl_codectx_t &ctx, jl_varinfo_t& vi)
 
 // --- utilities ---
 
+static Constant *undef_value_for_type(Type *T) {
+    auto tracked = CountTrackedPointers(T);
+    Constant *undef;
+    if (tracked.count)
+        // make sure gc pointers (including ptr_phi of union-split) are initialized to NULL
+        undef = Constant::getNullValue(T);
+    else
+        undef = UndefValue::get(T);
+    return undef;
+}
+
 static void CreateTrap(IRBuilder<> &irbuilder)
 {
     Function *f = irbuilder.GetInsertBlock()->getParent();
@@ -1472,6 +1487,7 @@ static void CreateConditionalAbort(IRBuilder<> &irbuilder, Value *test)
 #endif
 #endif
 
+
 #include "cgutils.cpp"
 
 static jl_cgval_t convert_julia_type_union(jl_codectx_t &ctx, const jl_cgval_t &v, jl_value_t *typ, Value **skip)
@@ -2351,62 +2367,6 @@ static jl_cgval_t emit_globalref(jl_codectx_t &ctx, jl_module_t *mod, jl_sym_t *
     return emit_checked_var(ctx, bp, name, false, tbaa_binding);
 }
 
-template<typename Func>
-static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, Constant *defval, Func &&func)
-{
-    if (auto Cond = dyn_cast<ConstantInt>(ifnot)) {
-        if (Cond->isZero())
-            return defval;
-        return func();
-    }
-    BasicBlock *currBB = ctx.builder.GetInsertBlock();
-    BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext, "guard_pass", ctx.f);
-    BasicBlock *exitBB = BasicBlock::Create(jl_LLVMContext, "guard_exit", ctx.f);
-    ctx.builder.CreateCondBr(ifnot, passBB, exitBB);
-    ctx.builder.SetInsertPoint(passBB);
-    auto res = func();
-    passBB = ctx.builder.GetInsertBlock();
-    ctx.builder.CreateBr(exitBB);
-    ctx.builder.SetInsertPoint(exitBB);
-    if (defval == nullptr)
-        return nullptr;
-    PHINode *phi = ctx.builder.CreatePHI(defval->getType(), 2);
-    phi->addIncoming(defval, currBB);
-    phi->addIncoming(res, passBB);
-    return phi;
-}
-
-template<typename Func>
-static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, bool defval, Func &&func)
-{
-    return emit_guarded_test(ctx, ifnot, ConstantInt::get(T_int1, defval), func);
-}
-
-template<typename Func>
-static Value *emit_nullcheck_guard(jl_codectx_t &ctx, Value *nullcheck, Func &&func)
-{
-    if (!nullcheck)
-        return func();
-    return emit_guarded_test(ctx, null_pointer_cmp(ctx, nullcheck), false, func);
-}
-
-template<typename Func>
-static Value *emit_nullcheck_guard2(jl_codectx_t &ctx, Value *nullcheck1,
-                                    Value *nullcheck2, Func &&func)
-{
-    if (!nullcheck1)
-        return emit_nullcheck_guard(ctx, nullcheck2, func);
-    if (!nullcheck2)
-        return emit_nullcheck_guard(ctx, nullcheck1, func);
-    nullcheck1 = null_pointer_cmp(ctx, nullcheck1);
-    nullcheck2 = null_pointer_cmp(ctx, nullcheck2);
-    // If both are NULL, return true.
-    return emit_guarded_test(ctx, ctx.builder.CreateOr(nullcheck1, nullcheck2), true, [&] {
-        return emit_guarded_test(ctx, ctx.builder.CreateAnd(nullcheck1, nullcheck2),
-                                 false, func);
-    });
-}
-
 static Value *emit_box_compare(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgval_t &arg2,
                                Value *nullcheck1, Value *nullcheck2)
 {
@@ -2443,8 +2403,6 @@ static Value *emit_box_compare(jl_codectx_t &ctx, const jl_cgval_t &arg1, const
 }
 
 static Value *emit_bits_compare(jl_codectx_t &ctx, jl_cgval_t arg1, jl_cgval_t arg2);
-static Value *emit_f_is(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgval_t &arg2,
-                        Value *nullcheck1 = nullptr, Value *nullcheck2 = nullptr);
 
 static Value *emit_bitsunion_compare(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgval_t &arg2)
 {
@@ -3011,13 +2969,18 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                         else {
                             typed_store(ctx,
                                         emit_arrayptr(ctx, ary, ary_ex, isboxed),
-                                        idx, val, ety,
+                                        idx, val, jl_cgval_t(), ety,
                                         isboxed ? tbaa_ptrarraybuf : tbaa_arraybuf,
                                         ctx.aliasscope,
                                         data_owner,
                                         isboxed,
                                         isboxed ? AtomicOrdering::Unordered : AtomicOrdering::NotAtomic, // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
-                                        0);
+                                        isboxed ? AtomicOrdering::Unordered : AtomicOrdering::NotAtomic, // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
+                                        0,
+                                        false,
+                                        true,
+                                        false,
+                                        false);
                         }
                     }
                     *ret = ary;
@@ -3158,19 +3121,34 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
         return false;
     }
 
-    else if (f == jl_builtin_setfield && (nargs == 3 || nargs == 4)) {
+    else if ((f == jl_builtin_setfield && (nargs == 3 || nargs == 4)) ||
+             (f == jl_builtin_swapfield && (nargs == 3 || nargs == 4)) ||
+             (f == jl_builtin_replacefield && (nargs == 4 || nargs == 5 || nargs == 6))) {
+        bool issetfield = f == jl_builtin_setfield;
+        bool isreplacefield = f == jl_builtin_replacefield;
+        const jl_cgval_t undefval;
         const jl_cgval_t &obj = argv[1];
         const jl_cgval_t &fld = argv[2];
-        const jl_cgval_t &val = argv[3];
+        const jl_cgval_t &val = argv[isreplacefield ? 4 : 3];
+        const jl_cgval_t &cmp = isreplacefield ? argv[3] : undefval;
         enum jl_memory_order order = jl_memory_order_notatomic;
-        if (nargs == 4) {
-            const jl_cgval_t &ord = argv[4];
-            emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, "setfield!");
+        if (nargs >= (isreplacefield ? 5 : 4)) {
+            const jl_cgval_t &ord = argv[isreplacefield ? 5 : 4];
+            emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type,
+                    issetfield ? "setfield!" : isreplacefield ? "replacefield!" : "swapfield!");
             if (!ord.constant)
                 return false;
-            order = jl_get_atomic_order((jl_sym_t*)ord.constant, false, true);
+            order = jl_get_atomic_order((jl_sym_t*)ord.constant, !issetfield, true);
         }
-        if (order == jl_memory_order_invalid) {
+        enum jl_memory_order fail_order = order;
+        if (isreplacefield && nargs == 6) {
+            const jl_cgval_t &ord = argv[6];
+            emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, "replacefield!");
+            if (!ord.constant)
+                return false;
+            fail_order = jl_get_atomic_order((jl_sym_t*)ord.constant, true, false);
+        }
+        if (order == jl_memory_order_invalid || fail_order == jl_memory_order_invalid || fail_order > order) {
             emit_atomic_error(ctx, "invalid atomic ordering");
             *ret = jl_cgval_t(); // unreachable
             return true;
@@ -3189,27 +3167,39 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
             }
             if (idx != -1) {
                 jl_value_t *ft = jl_svecref(uty->types, idx);
-                if (jl_subtype(val.typ, ft)) {
+                if (!jl_has_free_typevars(ft) && jl_subtype(val.typ, ft)) {
                     // TODO: attempt better codegen for approximate types
                     bool isboxed = jl_field_isptr(uty, idx);
                     bool isatomic = jl_field_isatomic(uty, idx);
                     bool needlock = isatomic && !isboxed && jl_datatype_size(jl_field_type(uty, idx)) > MAX_ATOMIC_SIZE;
                     if (isatomic == (order == jl_memory_order_notatomic)) {
                         emit_atomic_error(ctx,
-                                isatomic ? "setfield!: atomic field cannot be written non-atomically"
-                                         : "setfield!: non-atomic field cannot be written atomically");
+                                issetfield ?
+                                (isatomic ? "setfield!: atomic field cannot be written non-atomically"
+                                          : "setfield!: non-atomic field cannot be written atomically") :
+                                isreplacefield ?
+                                (isatomic ? "replacefield!: atomic field cannot be written non-atomically"
+                                          : "replacefield!: non-atomic field cannot be written atomically") :
+                                (isatomic ? "swapfield!: atomic field cannot be written non-atomically"
+                                          : "swapfield!: non-atomic field cannot be written atomically"));
+                        *ret = jl_cgval_t();
+                        return true;
+                    }
+                    if (isatomic == (fail_order == jl_memory_order_notatomic)) {
+                        emit_atomic_error(ctx,
+                                (isatomic ? "replacefield!: atomic field cannot be accessed non-atomically"
+                                          : "replacefield!: non-atomic field cannot be accessed atomically"));
                         *ret = jl_cgval_t();
                         return true;
                     }
-                    if (needlock)
-                        emit_lockstate_value(ctx, obj, true);
-                    emit_setfield(ctx, uty, obj, idx, val, true, true,
+                    *ret = emit_setfield(ctx, uty, obj, idx, val, cmp, true, true,
                             (needlock || order <= jl_memory_order_notatomic)
                             ? (isboxed ? AtomicOrdering::Unordered : AtomicOrdering::NotAtomic) // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
-                            : get_llvm_atomic_order(order));
-                    if (needlock)
-                        emit_lockstate_value(ctx, obj, false);
-                    *ret = val;
+                            : get_llvm_atomic_order(order),
+                            (needlock || fail_order <= jl_memory_order_notatomic)
+                            ? (isboxed ? AtomicOrdering::Unordered : AtomicOrdering::NotAtomic) // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
+                            : get_llvm_atomic_order(fail_order),
+                            needlock, issetfield, isreplacefield);
                     return true;
                 }
             }
@@ -7233,17 +7223,6 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
     ctx.builder.SetCurrentDebugLocation(noDbg);
     ctx.builder.ClearInsertionPoint();
 
-    auto undef_value_for_type = [&](Type *T) {
-        auto tracked = CountTrackedPointers(T);
-        Constant *undef;
-        if (tracked.count)
-            // make sure gc pointers (including ptr_phi of union-split) are initialized to NULL
-            undef = Constant::getNullValue(T);
-        else
-            undef = UndefValue::get(T);
-        return undef;
-    };
-
     // Codegen Phi nodes
     std::map<std::pair<BasicBlock*, BasicBlock*>, BasicBlock*> BB_rewrite_map;
     std::vector<llvm::PHINode*> ToDelete;
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index 904623e4ec43c..7d0e94fd30783 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -690,7 +690,8 @@ static jl_cgval_t emit_pointerset(jl_codectx_t &ctx, jl_cgval_t *argv)
         assert(!isboxed);
         if (!type_is_ghost(ptrty)) {
             thePtr = emit_unbox(ctx, ptrty->getPointerTo(), e, e.typ);
-            typed_store(ctx, thePtr, im1, x, ety, tbaa_data, nullptr, nullptr, isboxed, AtomicOrdering::NotAtomic, align_nb);
+            typed_store(ctx, thePtr, im1, x, jl_cgval_t(), ety, tbaa_data, nullptr, nullptr, isboxed,
+                        AtomicOrdering::NotAtomic, AtomicOrdering::NotAtomic, align_nb, false, true, false, false);
         }
     }
     return e;
diff --git a/src/llvm-gc-invariant-verifier.cpp b/src/llvm-gc-invariant-verifier.cpp
index 1c584f3852e9e..29b8c9ac4e60c 100644
--- a/src/llvm-gc-invariant-verifier.cpp
+++ b/src/llvm-gc-invariant-verifier.cpp
@@ -55,13 +55,17 @@ struct GCInvariantVerifier : public FunctionPass, public InstVisitor<GCInvariant
 
     bool runOnFunction(Function &F) override;
     void visitAddrSpaceCastInst(AddrSpaceCastInst &I);
-    void visitStoreInst(StoreInst &SI);
     void visitLoadInst(LoadInst &LI);
+    void visitStoreInst(StoreInst &SI);
+    void visitAtomicCmpXchgInst(AtomicCmpXchgInst &SI);
+    void visitAtomicRMWInst(AtomicRMWInst &SI);
     void visitReturnInst(ReturnInst &RI);
     void visitGetElementPtrInst(GetElementPtrInst &GEP);
     void visitIntToPtrInst(IntToPtrInst &IPI);
     void visitPtrToIntInst(PtrToIntInst &PII);
     void visitCallInst(CallInst &CI);
+
+    void checkStoreInst(Type *VTy, unsigned AS, Value &SI);
 };
 
 void GCInvariantVerifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
@@ -80,8 +84,7 @@ void GCInvariantVerifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
           "Illegal address space cast from decayed ptr", &I);
 }
 
-void GCInvariantVerifier::visitStoreInst(StoreInst &SI) {
-    Type *VTy = SI.getValueOperand()->getType();
+void GCInvariantVerifier::checkStoreInst(Type *VTy, unsigned AS, Value &SI) {
     if (VTy->isPointerTy()) {
         /* We currently don't obey this for arguments. That's ok - they're
            externally rooted. */
@@ -90,12 +93,23 @@ void GCInvariantVerifier::visitStoreInst(StoreInst &SI) {
               AS != AddressSpace::Derived,
               "Illegal store of decayed value", &SI);
     }
-    VTy = SI.getPointerOperand()->getType();
-    if (VTy->isPointerTy()) {
-        unsigned AS = cast<PointerType>(VTy)->getAddressSpace();
-        Check(AS != AddressSpace::CalleeRooted,
-              "Illegal store to callee rooted value", &SI);
-    }
+    Check(AS != AddressSpace::CalleeRooted,
+          "Illegal store to callee rooted value", &SI);
+}
+
+void GCInvariantVerifier::visitStoreInst(StoreInst &SI) {
+    Type *VTy = SI.getValueOperand()->getType();
+    checkStoreInst(VTy, SI.getPointerAddressSpace(), SI);
+}
+
+void GCInvariantVerifier::visitAtomicRMWInst(AtomicRMWInst &SI) {
+    Type *VTy = SI.getValOperand()->getType();
+    checkStoreInst(VTy, SI.getPointerAddressSpace(), SI);
+}
+
+void GCInvariantVerifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &SI) {
+    Type *VTy = SI.getNewValOperand()->getType();
+    checkStoreInst(VTy, SI.getPointerAddressSpace(), SI);
 }
 
 void GCInvariantVerifier::visitLoadInst(LoadInst &LI) {
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index ca066319d9c33..d47f6e3d0b114 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -496,6 +496,16 @@ static std::pair<Value*,int> FindBaseValue(const State &S, Value *V, bool UseCac
             // In general a load terminates a walk
             break;
         }
+        else if (auto LI = dyn_cast<AtomicCmpXchgInst>(CurrentV)) {
+            // In general a load terminates a walk
+            (void)LI;
+            break;
+        }
+        else if (auto LI = dyn_cast<AtomicRMWInst>(CurrentV)) {
+            // In general a load terminates a walk
+            (void)LI;
+            break;
+        }
         else if (auto II = dyn_cast<IntrinsicInst>(CurrentV)) {
             // Some intrinsics behave like LoadInst followed by a SelectInst
             // This should never happen in a derived addrspace (since those cannot be stored to memory)
@@ -538,6 +548,7 @@ static std::pair<Value*,int> FindBaseValue(const State &S, Value *V, bool UseCac
         }
     }
     assert(isa<LoadInst>(CurrentV) || isa<CallInst>(CurrentV) ||
+           isa<AtomicCmpXchgInst>(CurrentV) || isa<AtomicRMWInst>(CurrentV) ||
            isa<Argument>(CurrentV) || isa<SelectInst>(CurrentV) ||
            isa<PHINode>(CurrentV) || isa<AddrSpaceCastInst>(CurrentV) ||
            isa<Constant>(CurrentV) || isa<AllocaInst>(CurrentV) ||
@@ -883,7 +894,8 @@ std::vector<int> LateLowerGCFrame::NumberAllBase(State &S, Value *CurrentV) {
             Numbers = S.AllCompositeNumbering.at(CurrentV);
         }
     } else {
-        assert((isa<LoadInst>(CurrentV) || isa<CallInst>(CurrentV) || isa<PHINode>(CurrentV) || isa<SelectInst>(CurrentV))
+        assert((isa<LoadInst>(CurrentV) || isa<CallInst>(CurrentV) || isa<PHINode>(CurrentV) || isa<SelectInst>(CurrentV) ||
+                isa<AtomicCmpXchgInst>(CurrentV) || isa<AtomicRMWInst>(CurrentV))
                 && "unexpected def expression");
         // This is simple, we can just number them sequentially
         for (unsigned i = 0; i < tracked.count; ++i) {
@@ -1042,7 +1054,8 @@ void RecursivelyVisit(callback f, Value *V) {
             f(VU);
         if (isa<CallInst>(TheUser) || isa<LoadInst>(TheUser) ||
             isa<SelectInst>(TheUser) || isa<PHINode>(TheUser) ||
-            isa<StoreInst>(TheUser) || isa<PtrToIntInst>(TheUser))
+            isa<StoreInst>(TheUser) || isa<PtrToIntInst>(TheUser) ||
+            isa<AtomicCmpXchgInst>(TheUser) || isa<AtomicRMWInst>(TheUser))
             continue;
         if (isa<GetElementPtrInst>(TheUser) || isa<BitCastInst>(TheUser) || isa<AddrSpaceCastInst>(TheUser)) {
             RecursivelyVisit<VisitInst, callback>(f, TheUser);
@@ -1583,6 +1596,20 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                     MaybeNoteDef(S, BBS, LI, BBS.Safepoints, std::move(RefinedPtr));
                 }
                 NoteOperandUses(S, BBS, I);
+            } else if (auto *LI = dyn_cast<AtomicCmpXchgInst>(&I)) {
+                Type *Ty = LI->getNewValOperand()->getType()->getScalarType();
+                if (!Ty->isPointerTy() || Ty->getPointerAddressSpace() != AddressSpace::Loaded) {
+                    MaybeNoteDef(S, BBS, LI, BBS.Safepoints);
+                }
+                NoteOperandUses(S, BBS, I);
+                // TODO: do we need MaybeTrackStore(S, LI);
+            } else if (auto *LI = dyn_cast<AtomicRMWInst>(&I)) {
+                Type *Ty = LI->getType()->getScalarType();
+                if (!Ty->isPointerTy() || Ty->getPointerAddressSpace() != AddressSpace::Loaded) {
+                    MaybeNoteDef(S, BBS, LI, BBS.Safepoints);
+                }
+                NoteOperandUses(S, BBS, I);
+                // TODO: do we need MaybeTrackStore(S, LI);
             } else if (SelectInst *SI = dyn_cast<SelectInst>(&I)) {
                 auto tracked = CountTrackedPointers(SI->getType());
                 if (tracked.count && !tracked.derived) {
diff --git a/src/llvm-propagate-addrspaces.cpp b/src/llvm-propagate-addrspaces.cpp
index 6cfa66ddca6ff..a6afcda870911 100644
--- a/src/llvm-propagate-addrspaces.cpp
+++ b/src/llvm-propagate-addrspaces.cpp
@@ -51,8 +51,11 @@ struct PropagateJuliaAddrspaces : public FunctionPass, public InstVisitor<Propag
 public:
     bool runOnFunction(Function &F) override;
     Value *LiftPointer(Value *V, Type *LocTy = nullptr, Instruction *InsertPt=nullptr);
-    void visitStoreInst(StoreInst &SI);
+    void visitMemop(Instruction &I, Type *T, unsigned OpIndex);
     void visitLoadInst(LoadInst &LI);
+    void visitStoreInst(StoreInst &SI);
+    void visitAtomicCmpXchgInst(AtomicCmpXchgInst &SI);
+    void visitAtomicRMWInst(AtomicRMWInst &SI);
     void visitMemSetInst(MemSetInst &MI);
     void visitMemTransferInst(MemTransferInst &MTI);
 
@@ -229,24 +232,31 @@ Value *PropagateJuliaAddrspaces::LiftPointer(Value *V, Type *LocTy, Instruction
     return CollapseCastsAndLift(V, InsertPt);
 }
 
-void PropagateJuliaAddrspaces::visitLoadInst(LoadInst &LI) {
-    unsigned AS = LI.getPointerAddressSpace();
+void PropagateJuliaAddrspaces::visitMemop(Instruction &I, Type *T, unsigned OpIndex) {
+    Value *Original = I.getOperand(OpIndex);
+    unsigned AS = Original->getType()->getPointerAddressSpace();
     if (!isSpecialAS(AS))
         return;
-    Value *Replacement = LiftPointer(LI.getPointerOperand(), LI.getType(), &LI);
+    Value *Replacement = LiftPointer(Original, T, &I);
     if (!Replacement)
         return;
-    LI.setOperand(LoadInst::getPointerOperandIndex(), Replacement);
+    I.setOperand(OpIndex, Replacement);
+}
+
+void PropagateJuliaAddrspaces::visitLoadInst(LoadInst &LI) {
+    visitMemop(LI, LI.getType(), LoadInst::getPointerOperandIndex());
 }
 
 void PropagateJuliaAddrspaces::visitStoreInst(StoreInst &SI) {
-    unsigned AS = SI.getPointerAddressSpace();
-    if (!isSpecialAS(AS))
-        return;
-    Value *Replacement = LiftPointer(SI.getPointerOperand(), SI.getValueOperand()->getType(), &SI);
-    if (!Replacement)
-        return;
-    SI.setOperand(StoreInst::getPointerOperandIndex(), Replacement);
+    visitMemop(SI, SI.getValueOperand()->getType(), StoreInst::getPointerOperandIndex());
+}
+
+void PropagateJuliaAddrspaces::visitAtomicCmpXchgInst(AtomicCmpXchgInst &SI) {
+    visitMemop(SI, SI.getNewValOperand()->getType(), AtomicCmpXchgInst::getPointerOperandIndex());
+}
+
+void PropagateJuliaAddrspaces::visitAtomicRMWInst(AtomicRMWInst &SI) {
+    visitMemop(SI, SI.getType(), AtomicRMWInst::getPointerOperandIndex());
 }
 
 void PropagateJuliaAddrspaces::visitMemSetInst(MemSetInst &MI) {
diff --git a/test/atomics.jl b/test/atomics.jl
index 59c45299db221..2a0cbd7357c6e 100644
--- a/test/atomics.jl
+++ b/test/atomics.jl
@@ -184,12 +184,12 @@ test_field_operators(ARefxy{Complex{Int128}}(12345_10, 12345_20))
     @test_throws ConcurrencyViolationError("replacefield!: non-atomic field cannot be written atomically") replacefield!(r, :y, y, y, :acquire_release, :not_atomic)
     @test_throws ConcurrencyViolationError("replacefield!: non-atomic field cannot be written atomically") replacefield!(r, :y, y, y, :sequentially_consistent, :not_atomic)
     @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :y, y, y, :not_atomic, :u)
-    @test_throws ConcurrencyViolationError("replacefield!: non-atomic field cannot be accessed atomically") replacefield!(r, :y, y, y, :not_atomic, :unordered)
-    @test_throws ConcurrencyViolationError("replacefield!: non-atomic field cannot be accessed atomically") replacefield!(r, :y, y, y, :not_atomic, :monotonic)
-    @test_throws ConcurrencyViolationError("replacefield!: non-atomic field cannot be accessed atomically") replacefield!(r, :y, y, y, :not_atomic, :acquire)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :y, y, y, :not_atomic, :unordered)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :y, y, y, :not_atomic, :monotonic)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :y, y, y, :not_atomic, :acquire)
     @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :y, y, y, :not_atomic, :release)
     @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :y, y, y, :not_atomic, :acquire_release)
-    @test_throws ConcurrencyViolationError("replacefield!: non-atomic field cannot be accessed atomically") replacefield!(r, :y, y, y, :not_atomic, :sequentially_consistent)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :y, y, y, :not_atomic, :sequentially_consistent)
     @test replacefield!(r, :y, x, y, :not_atomic, :not_atomic) === (x, true)
     @test replacefield!(r, :y, x, y, :not_atomic, :not_atomic) === (y, x === y)
     @test replacefield!(r, :y, y, y, :not_atomic) === (y, true)
@@ -225,12 +225,12 @@ test_field_operators(ARefxy{Complex{Int128}}(12345_10, 12345_20))
     @test_throws ConcurrencyViolationError("replacefield!: atomic field cannot be accessed non-atomically") replacefield!(r, :x, x, x, :acquire_release, :not_atomic)
     @test_throws ConcurrencyViolationError("replacefield!: atomic field cannot be accessed non-atomically") replacefield!(r, :x, x, x, :sequentially_consistent, :not_atomic)
     @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :x, x, x, :not_atomic, :u)
-    @test_throws ConcurrencyViolationError("replacefield!: atomic field cannot be written non-atomically") replacefield!(r, :x, x, x, :not_atomic, :unordered)
-    @test_throws ConcurrencyViolationError("replacefield!: atomic field cannot be written non-atomically") replacefield!(r, :x, x, x, :not_atomic, :monotonic)
-    @test_throws ConcurrencyViolationError("replacefield!: atomic field cannot be written non-atomically") replacefield!(r, :x, x, x, :not_atomic, :acquire)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :x, x, x, :not_atomic, :unordered)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :x, x, x, :not_atomic, :monotonic)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :x, x, x, :not_atomic, :acquire)
     @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :x, x, x, :not_atomic, :release)
     @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :x, x, x, :not_atomic, :acquire_release)
-    @test_throws ConcurrencyViolationError("replacefield!: atomic field cannot be written non-atomically") replacefield!(r, :x, x, x, :not_atomic, :sequentially_consistent)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") replacefield!(r, :x, x, x, :not_atomic, :sequentially_consistent)
     @test replacefield!(r, :x, x, y, :sequentially_consistent, :sequentially_consistent) === (x, true)
     @test replacefield!(r, :x, x, y, :sequentially_consistent, :sequentially_consistent) === (y, x === y)
     @test replacefield!(r, :x, y, x, :sequentially_consistent) === (y, true)

From d61ce5a652d6125a3468e45ed7f8404e3386d4c8 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 5 Jul 2021 19:37:56 -0400
Subject: [PATCH 44/44] non-power-of-two atomic handling (#41369)

(cherry picked from commit 252ae698f96a05439b78934d123130c2addd5470)
---
 src/cgutils.cpp   |  94 +++++++++++++-------
 src/datatype.c    | 219 +++++++++++++++++++++++++++-------------------
 src/processor.cpp |   2 +
 test/atomics.jl   |  67 +++++++++-----
 4 files changed, 241 insertions(+), 141 deletions(-)

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index f715abb3b490b..8c7bdad2a5903 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -1479,12 +1479,19 @@ static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, j
     if (type_is_ghost(elty))
         return ghostValue(jltype);
     AllocaInst *intcast = NULL;
-    if (!isboxed && Order != AtomicOrdering::NotAtomic && !elty->isIntOrPtrTy() && !elty->isFloatingPointTy()) {
+    if (!isboxed && Order != AtomicOrdering::NotAtomic && !elty->isIntOrPtrTy()) {
         const DataLayout &DL = jl_data_layout;
         unsigned nb = DL.getTypeSizeInBits(elty);
         intcast = ctx.builder.CreateAlloca(elty);
         elty = Type::getIntNTy(jl_LLVMContext, nb);
     }
+    Type *realelty = elty;
+    if (Order != AtomicOrdering::NotAtomic && isa<IntegerType>(elty)) {
+        unsigned nb = cast<IntegerType>(elty)->getBitWidth();
+        unsigned nb2 = PowerOf2Ceil(nb);
+        if (nb != nb2)
+            elty = Type::getIntNTy(jl_LLVMContext, nb2);
+    }
     Type *ptrty = PointerType::get(elty, ptr->getType()->getPointerAddressSpace());
     Value *data;
     if (ptr->getType() != ptrty)
@@ -1493,7 +1500,7 @@ static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, j
         data = ptr;
     if (idx_0based)
         data = ctx.builder.CreateInBoundsGEP(elty, data, idx_0based);
-    Instruction *load;
+    Value *instr;
     // TODO: can only lazy load if we can create a gc root for ptr for the lifetime of elt
     //if (elty->isAggregateType() && tbaa == tbaa_immut && !alignment) { // can lazy load on demand, no copy needed
     //    elt = data;
@@ -1503,20 +1510,23 @@ static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, j
             alignment = sizeof(void*);
         else if (!alignment)
             alignment = julia_alignment(jltype);
-        load = ctx.builder.CreateAlignedLoad(data, Align(alignment), false);
-        cast<LoadInst>(load)->setOrdering(Order);
+        LoadInst *load = ctx.builder.CreateAlignedLoad(data, Align(alignment), false);
+        load->setOrdering(Order);
         if (aliasscope)
             load->setMetadata("alias.scope", aliasscope);
         if (isboxed)
-            load = maybe_mark_load_dereferenceable(load, true, jltype);
+            maybe_mark_load_dereferenceable(load, true, jltype);
         if (tbaa)
-            load = tbaa_decorate(tbaa, load);
+            tbaa_decorate(tbaa, load);
+        instr = load;
+        if (elty != realelty)
+            instr = ctx.builder.CreateTrunc(instr, realelty);
         if (intcast) {
-            ctx.builder.CreateStore(load, ctx.builder.CreateBitCast(intcast, load->getType()->getPointerTo()));
-            load = ctx.builder.CreateLoad(intcast);
+            ctx.builder.CreateStore(instr, ctx.builder.CreateBitCast(intcast, instr->getType()->getPointerTo()));
+            instr = ctx.builder.CreateLoad(intcast);
         }
         if (maybe_null_if_boxed) {
-            Value *first_ptr = isboxed ? load : extract_first_ptr(ctx, load);
+            Value *first_ptr = isboxed ? instr : extract_first_ptr(ctx, instr);
             if (first_ptr)
                 null_pointer_check(ctx, first_ptr, nullcheck);
         }
@@ -1526,9 +1536,9 @@ static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, j
         //load->setMetadata(LLVMContext::MD_range, MDNode::get(jl_LLVMContext, {
         //    ConstantAsMetadata::get(ConstantInt::get(T_int8, 0)),
         //    ConstantAsMetadata::get(ConstantInt::get(T_int8, 2)) }));
-        load = ctx.builder.Insert(CastInst::Create(Instruction::Trunc, load, T_int1));
+        instr = ctx.builder.CreateTrunc(instr, T_int1);
     }
-    return mark_julia_type(ctx, load, isboxed, jltype);
+    return mark_julia_type(ctx, instr, isboxed, jltype);
 }
 
 static jl_cgval_t typed_store(jl_codectx_t &ctx,
@@ -1544,18 +1554,27 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
     if (type_is_ghost(elty))
         return oldval;
     Value *intcast = nullptr;
-    if (!isboxed && Order != AtomicOrdering::NotAtomic && !elty->isIntOrPtrTy() && !elty->isFloatingPointTy()) {
+    if (!isboxed && Order != AtomicOrdering::NotAtomic && !elty->isIntOrPtrTy()) {
         const DataLayout &DL = jl_data_layout;
         unsigned nb = DL.getTypeSizeInBits(elty);
         if (!issetfield)
             intcast = ctx.builder.CreateAlloca(elty);
         elty = Type::getIntNTy(jl_LLVMContext, nb);
     }
+    Type *realelty = elty;
+    if (Order != AtomicOrdering::NotAtomic && isa<IntegerType>(elty)) {
+        unsigned nb = cast<IntegerType>(elty)->getBitWidth();
+        unsigned nb2 = PowerOf2Ceil(nb);
+        if (nb != nb2)
+            elty = Type::getIntNTy(jl_LLVMContext, nb2);
+    }
     Value *r;
     if (!isboxed)
-        r = emit_unbox(ctx, elty, rhs, jltype);
+        r = emit_unbox(ctx, realelty, rhs, jltype);
     else
         r = boxed(ctx, rhs);
+    if (realelty != elty)
+        r = ctx.builder.CreateZExt(r, elty);
     Type *ptrty = PointerType::get(elty, ptr->getType()->getPointerAddressSpace());
     if (ptr->getType() != ptrty)
         ptr = ctx.builder.CreateBitCast(ptr, ptrty);
@@ -1578,18 +1597,19 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
                 instr->setMetadata("noalias", aliasscope);
             if (tbaa)
                 tbaa_decorate(tbaa, instr);
-        }
-        if (isreplacefield) {
-            oldval = mark_julia_type(ctx, instr, isboxed, jltype);
-            Value *first_ptr = nullptr;
-            if (maybe_null_if_boxed)
-                first_ptr = isboxed ? instr : extract_first_ptr(ctx, instr);
-            Success = emit_nullcheck_guard(ctx, first_ptr, [&] {
-                return emit_f_is(ctx, oldval, cmp);
-            });
-            BasicBlock *BB = BasicBlock::Create(jl_LLVMContext, "xchg", ctx.f);
-            ctx.builder.CreateCondBr(Success, BB, DoneBB);
-            ctx.builder.SetInsertPoint(BB);
+            assert(realelty == elty);
+            if (isreplacefield) {
+                oldval = mark_julia_type(ctx, instr, isboxed, jltype);
+                Value *first_ptr = nullptr;
+                if (maybe_null_if_boxed)
+                    first_ptr = isboxed ? instr : extract_first_ptr(ctx, instr);
+                Success = emit_nullcheck_guard(ctx, first_ptr, [&] {
+                    return emit_f_is(ctx, oldval, cmp);
+                });
+                BasicBlock *BB = BasicBlock::Create(jl_LLVMContext, "xchg", ctx.f);
+                ctx.builder.CreateCondBr(Success, BB, DoneBB);
+                ctx.builder.SetInsertPoint(BB);
+            }
         }
         StoreInst *store = ctx.builder.CreateAlignedStore(r, ptr, Align(alignment));
         store->setOrdering(Order);
@@ -1628,7 +1648,9 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
                     Current->addIncoming(instr, SkipBB);
                     ctx.builder.SetInsertPoint(BB);
                 }
-                Compare = emit_unbox(ctx, elty, cmp, jltype);
+                Compare = emit_unbox(ctx, realelty, cmp, jltype);
+                if (realelty != elty)
+                    Compare = ctx.builder.CreateZExt(Compare, elty);
             }
             else if (cmp.isboxed) {
                 Compare = boxed(ctx, cmp);
@@ -1676,21 +1698,26 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
         if (tbaa)
             tbaa_decorate(tbaa, store);
         instr = ctx.builder.Insert(ExtractValueInst::Create(store, 0));
-        Success = ctx.builder.CreateExtractValue(store, 1);
+        Success = ctx.builder.Insert(ExtractValueInst::Create(store, 1));
         Value *Done = Success;
         if (needloop) {
             if (isreplacefield) {
+                Value *realinstr = instr;
+                if (realelty != elty)
+                    realinstr = ctx.builder.CreateTrunc(instr, realelty);
                 if (intcast) {
-                    ctx.builder.CreateStore(instr, ctx.builder.CreateBitCast(intcast, instr->getType()->getPointerTo()));
+                    ctx.builder.CreateStore(realinstr, ctx.builder.CreateBitCast(intcast, realinstr->getType()->getPointerTo()));
                     oldval = mark_julia_slot(intcast, jltype, NULL, tbaa_stack);
+                    if (maybe_null_if_boxed)
+                        realinstr = ctx.builder.CreateLoad(intcast);
                 }
                 else {
-                    oldval = mark_julia_type(ctx, instr, isboxed, jltype);
+                    oldval = mark_julia_type(ctx, realinstr, isboxed, jltype);
                 }
                 Done = emit_guarded_test(ctx, ctx.builder.CreateNot(Success), false, [&] {
                     Value *first_ptr = nullptr;
                     if (maybe_null_if_boxed)
-                        first_ptr = isboxed ? instr : extract_first_ptr(ctx, instr);
+                        first_ptr = isboxed ? realinstr : extract_first_ptr(ctx, realinstr);
                     return emit_nullcheck_guard(ctx, first_ptr, [&] {
                         return emit_f_is(ctx, oldval, cmp);
                     });
@@ -1747,6 +1774,8 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
         }
     }
     if (!issetfield) {
+        if (realelty != elty)
+            instr = ctx.builder.Insert(CastInst::Create(Instruction::Trunc, instr, realelty));
         if (intcast) {
             ctx.builder.CreateStore(instr, ctx.builder.CreateBitCast(intcast, instr->getType()->getPointerTo()));
             instr = ctx.builder.CreateLoad(intcast);
@@ -2053,6 +2082,9 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
         emit_atomic_error(ctx, "getfield: atomic field cannot be accessed non-atomically");
         return jl_cgval_t(); // unreachable
     }
+    if (order == jl_memory_order_unspecified) {
+        order = isatomic ? jl_memory_order_unordered : jl_memory_order_notatomic;
+    }
     if (jfty == jl_bottom_type) {
         raise_exception(ctx, literal_pointer_val(ctx, jl_undefref_exception));
         return jl_cgval_t(); // unreachable
@@ -2126,7 +2158,7 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
         if (needlock)
             emit_lockstate_value(ctx, strct, true);
         jl_cgval_t ret = typed_load(ctx, addr, NULL, jfty, tbaa, nullptr, false,
-                needlock || order <= jl_memory_order_notatomic ? AtomicOrdering::NotAtomic : get_llvm_atomic_order(order), // TODO: we should use unordered for anything with CountTrackedPointers(elty).count > 0
+                needlock ? AtomicOrdering::NotAtomic : get_llvm_atomic_order(order), // TODO: we should use unordered for anything with CountTrackedPointers(elty).count > 0
                 maybe_null, align, nullcheck);
         if (needlock)
             emit_lockstate_value(ctx, strct, false);
diff --git a/src/datatype.c b/src/datatype.c
index a321b417d91c0..1a3ffa78170ac 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -730,7 +730,53 @@ JL_DLLEXPORT int jl_is_foreign_type(jl_datatype_t *dt)
 #error MAX_POINTERATOMIC_SIZE too large
 #endif
 #if MAX_POINTERATOMIC_SIZE >= 16
+#ifndef _P64
+#error 12 byte GC pool size not implemented for 32-bit
+#endif
 typedef __uint128_t uint128_t;
+typedef uint128_t jl_uatomicmax_t;
+#else
+typedef uint64_t jl_uatomicmax_t;
+#endif
+
+#if BYTE_ORDER != LITTLE_ENDIAN
+#error using masks for atomics (instead of memcpy like nb == 16) assumes little endian
+#endif
+
+static inline uint32_t zext_read32(const jl_value_t *x, size_t nb) JL_NOTSAFEPOINT
+{
+    uint32_t y = *(uint32_t*)x;
+    if (nb == 4)
+        return y;
+    else // if (nb == 3)
+        return 0xffffffu & y;
+}
+
+#if MAX_POINTERATOMIC_SIZE >= 8
+static inline uint64_t zext_read64(const jl_value_t *x, size_t nb) JL_NOTSAFEPOINT
+{
+    uint64_t y = *(uint64_t*)x;
+    if (nb == 8)
+        return y;
+    else if (nb == 7)
+        return 0xffffffffffffffu & y;
+    else if (nb == 6)
+        return 0xffffffffffffu & y;
+    else // if (nb == 5)
+        return 0xffffffffffu & y;
+}
+#endif
+
+#if MAX_POINTERATOMIC_SIZE >= 16
+static inline uint128_t zext_read128(const jl_value_t *x, size_t nb) JL_NOTSAFEPOINT
+{
+    uint128_t y = 0;
+    if (nb == 16)
+        y = *(uint128_t*)x;
+    else
+        memcpy(&y, x, nb);
+    return y;
+}
 #endif
 
 JL_DLLEXPORT jl_value_t *jl_new_bits(jl_value_t *dt, const void *data)
@@ -755,16 +801,7 @@ JL_DLLEXPORT jl_value_t *jl_new_bits(jl_value_t *dt, const void *data)
 
     jl_task_t *ct = jl_current_task;
     jl_value_t *v = jl_gc_alloc(ct->ptls, nb, bt);
-    switch (nb) {
-    case  1: *(uint8_t*) v = *(uint8_t*)data;    break;
-    case  2: *(uint16_t*)v = jl_load_unaligned_i16(data);   break;
-    case  4: *(uint32_t*)v = jl_load_unaligned_i32(data);   break;
-    case  8: *(uint64_t*)v = jl_load_unaligned_i64(data);   break;
-    case 16:
-        memcpy(jl_assume_aligned(v, 16), data, 16);
-        break;
-    default: memcpy(v, data, nb);
-    }
+    memcpy(jl_assume_aligned(v, sizeof(void*)), data, nb);
     return v;
 }
 
@@ -789,19 +826,24 @@ JL_DLLEXPORT jl_value_t *jl_atomic_new_bits(jl_value_t *dt, const char *data)
 
     jl_task_t *ct = jl_current_task;
     jl_value_t *v = jl_gc_alloc(ct->ptls, nb, bt);
-    switch (nb) {
-    case  1: *(uint8_t*) v = jl_atomic_load((uint8_t*)data);    break;
-    case  2: *(uint16_t*)v = jl_atomic_load((uint16_t*)data);   break;
-    case  4: *(uint32_t*)v = jl_atomic_load((uint32_t*)data);   break;
+    // data is aligned to the power of two,
+    // we will write too much of v, but the padding should exist
+    if (nb == 1)
+        *(uint8_t*) v = jl_atomic_load((uint8_t*)data);
+    else if (nb <= 2)
+        *(uint16_t*)v = jl_atomic_load((uint16_t*)data);
+    else if (nb <= 4)
+        *(uint32_t*)v = jl_atomic_load((uint32_t*)data);
 #if MAX_POINTERATOMIC_SIZE >= 8
-    case  8: *(uint64_t*)v = jl_atomic_load((uint64_t*)data);   break;
+    else if (nb <= 8)
+        *(uint64_t*)v = jl_atomic_load((uint64_t*)data);
 #endif
 #if MAX_POINTERATOMIC_SIZE >= 16
-    case 16: *(uint128_t*)v = jl_atomic_load((uint128_t*)data);        break;
+    else if (nb <= 16)
+        *(uint128_t*)v = jl_atomic_load((uint128_t*)data);
 #endif
-    default:
+    else
         abort();
-    }
     return v;
 }
 
@@ -809,20 +851,26 @@ JL_DLLEXPORT void jl_atomic_store_bits(char *dst, const jl_value_t *src, int nb)
 {
     // dst must have the required alignment for an atomic of the given size
     // src must be aligned by the GC
-    switch (nb) {
-    case  0:                                                   break;
-    case  1: jl_atomic_store((uint8_t*)dst, *(uint8_t*)src);   break;
-    case  2: jl_atomic_store((uint16_t*)dst, *(uint16_t*)src); break;
-    case  4: jl_atomic_store((uint32_t*)dst, *(uint32_t*)src); break;
+    // we may therefore read too much from src, but will zero the excess bits
+    // before the store (so that we can get faster cmpswap later)
+    if (nb == 0)
+        ;
+    else if (nb == 1)
+        jl_atomic_store((uint8_t*)dst, *(uint8_t*)src);
+    else if (nb == 2)
+        jl_atomic_store((uint16_t*)dst, *(uint16_t*)src);
+    else if (nb <= 4)
+        jl_atomic_store((uint32_t*)dst, zext_read32(src, nb));
 #if MAX_POINTERATOMIC_SIZE >= 8
-    case  8: jl_atomic_store((uint64_t*)dst, *(uint64_t*)src); break;
+    else if (nb <= 8)
+        jl_atomic_store((uint64_t*)dst, zext_read64(src, nb));
 #endif
 #if MAX_POINTERATOMIC_SIZE >= 16
-    case 16: jl_atomic_store((uint128_t*)dst, *(uint128_t*)src); break;
+    else if (nb <= 16)
+        jl_atomic_store((uint128_t*)dst, zext_read128(src, nb));
 #endif
-    default:
+    else
         abort();
-    }
 }
 
 JL_DLLEXPORT jl_value_t *jl_atomic_swap_bits(jl_value_t *dt, char *dst, const jl_value_t *src, int nb)
@@ -845,19 +893,22 @@ JL_DLLEXPORT jl_value_t *jl_atomic_swap_bits(jl_value_t *dt, char *dst, const jl
 
     jl_task_t *ct = jl_current_task;
     jl_value_t *v = jl_gc_alloc(ct->ptls, jl_datatype_size(bt), bt);
-    switch (nb) {
-    case  1: *(uint8_t*) v = jl_atomic_exchange((uint8_t*)dst, *(uint8_t*)src);    break;
-    case  2: *(uint16_t*)v = jl_atomic_exchange((uint16_t*)dst, *(uint16_t*)src);   break;
-    case  4: *(uint32_t*)v = jl_atomic_exchange((uint32_t*)dst, *(uint32_t*)src);   break;
+    if (nb == 1)
+        *(uint8_t*)v = jl_atomic_exchange((uint8_t*)dst, *(uint8_t*)src);
+    else if (nb == 2)
+        *(uint16_t*)v = jl_atomic_exchange((uint16_t*)dst, *(uint16_t*)src);
+    else if (nb <= 4)
+        *(uint32_t*)v = jl_atomic_exchange((uint32_t*)dst, zext_read32(src, nb));
 #if MAX_POINTERATOMIC_SIZE >= 8
-    case  8: *(uint64_t*)v = jl_atomic_exchange((uint64_t*)dst, *(uint64_t*)src);   break;
+    else if (nb <= 8)
+        *(uint64_t*)v = jl_atomic_exchange((uint64_t*)dst, zext_read64(src, nb));
 #endif
 #if MAX_POINTERATOMIC_SIZE >= 16
-    case 16: *(uint128_t*)v = jl_atomic_exchange((uint128_t*)dst, *(uint128_t*)src);   break;
+    else if (nb <= 16)
+        *(uint128_t*)v = jl_atomic_exchange((uint128_t*)dst, zext_read128(src, nb));
 #endif
-    default:
+    else
         abort();
-    }
     return v;
 }
 
@@ -866,41 +917,37 @@ JL_DLLEXPORT int jl_atomic_bool_cmpswap_bits(char *dst, const jl_value_t *expect
     // dst must have the required alignment for an atomic of the given size
     // n.b.: this can spuriously fail if there are padding bits, the caller should deal with that
     int success;
-    switch (nb) {
-    case  0: {
+    if (nb == 0) {
         success = 1;
-        break;
     }
-    case  1: {
+    else if (nb == 1) {
         uint8_t y = *(uint8_t*)expected;
         success = jl_atomic_cmpswap((uint8_t*)dst, &y, *(uint8_t*)src);
-        break;
     }
-    case  2: {
+    else if (nb == 2) {
         uint16_t y = *(uint16_t*)expected;
         success = jl_atomic_cmpswap((uint16_t*)dst, &y, *(uint16_t*)src);
-        break;
     }
-    case  4: {
-        uint32_t y = *(uint32_t*)expected;
-        success = jl_atomic_cmpswap((uint32_t*)dst, &y, *(uint32_t*)src);
-        break;
+    else if (nb <= 4) {
+        uint32_t y = zext_read32(expected, nb);
+        uint32_t z = zext_read32(src, nb);
+        success = jl_atomic_cmpswap((uint32_t*)dst, &y, z);
     }
 #if MAX_POINTERATOMIC_SIZE >= 8
-    case  8: {
-        uint64_t y = *(uint64_t*)expected;
-        success = jl_atomic_cmpswap((uint64_t*)dst, &y, *(uint64_t*)src);
-        break;
+    else if (nb <= 8) {
+        uint64_t y = zext_read64(expected, nb);
+        uint64_t z = zext_read64(src, nb);
+        success = jl_atomic_cmpswap((uint64_t*)dst, &y, z);
     }
 #endif
 #if MAX_POINTERATOMIC_SIZE >= 16
-    case 16: {
-        uint128_t y = *(uint128_t*)expected;
-        success = jl_atomic_cmpswap((uint128_t*)dst, &y, *(uint128_t*)src);
-        break;
+    else if (nb <= 16) {
+        uint128_t y = zext_read128(expected, nb);
+        uint128_t z = zext_read128(src, nb);
+        success = jl_atomic_cmpswap((uint128_t*)dst, &y, z);
     }
 #endif
-    default:
+    else {
         abort();
     }
     return success;
@@ -920,45 +967,42 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, char *dst, co
     jl_value_t *y = jl_gc_alloc(ct->ptls, isptr ? nb : tuptyp->size, isptr ? dt : tuptyp);
     int success;
     jl_datatype_t *et = (jl_datatype_t*)jl_typeof(expected);
-    switch (nb) {
-    case  0: {
+    if (nb == 0) {
         success = (dt == et);
-        break;
     }
-    case  1: {
+    else if (nb == 1) {
         uint8_t *y8 = (uint8_t*)y;
+        assert(!dt->layout->haspadding);
         if (dt == et) {
             *y8 = *(uint8_t*)expected;
-            success = jl_atomic_cmpswap((uint8_t*)dst, y8, *(uint8_t*)src);
+            uint8_t z8 = *(uint8_t*)src;
+            success = jl_atomic_cmpswap((uint8_t*)dst, y8, z8);
         }
         else {
             *y8 = jl_atomic_load((uint8_t*)dst);
             success = 0;
         }
-        break;
     }
-    case  2: {
+    else if (nb == 2) {
         uint16_t *y16 = (uint16_t*)y;
+        assert(!dt->layout->haspadding);
         if (dt == et) {
             *y16 = *(uint16_t*)expected;
-            while (1) {
-                success = jl_atomic_cmpswap((uint16_t*)dst, y16, *(uint16_t*)src);
-                if (success || !dt->layout->haspadding || !jl_egal__bits(y, expected, dt))
-                    break;
-            }
+            uint16_t z16 = *(uint16_t*)src;
+            success = jl_atomic_cmpswap((uint16_t*)dst, y16, z16);
         }
         else {
             *y16 = jl_atomic_load((uint16_t*)dst);
             success = 0;
         }
-        break;
     }
-    case  4: {
+    else if (nb <= 4) {
         uint32_t *y32 = (uint32_t*)y;
         if (dt == et) {
-            *y32 = *(uint32_t*)expected;
+            *y32 = zext_read32(expected, nb);
+            uint32_t z32 = zext_read32(src, nb);
             while (1) {
-                success = jl_atomic_cmpswap((uint32_t*)dst, y32, *(uint32_t*)src);
+                success = jl_atomic_cmpswap((uint32_t*)dst, y32, z32);
                 if (success || !dt->layout->haspadding || !jl_egal__bits(y, expected, dt))
                     break;
             }
@@ -967,15 +1011,15 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, char *dst, co
             *y32 = jl_atomic_load((uint32_t*)dst);
             success = 0;
         }
-        break;
     }
 #if MAX_POINTERATOMIC_SIZE >= 8
-    case  8: {
+    else if (nb <= 8) {
         uint64_t *y64 = (uint64_t*)y;
         if (dt == et) {
-            *y64 = *(uint64_t*)expected;
+            *y64 = zext_read64(expected, nb);
+            uint64_t z64 = zext_read64(src, nb);
             while (1) {
-                success = jl_atomic_cmpswap((uint64_t*)dst, y64, *(uint64_t*)src);
+                success = jl_atomic_cmpswap((uint64_t*)dst, y64, z64);
                 if (success || !dt->layout->haspadding || !jl_egal__bits(y, expected, dt))
                     break;
             }
@@ -984,16 +1028,16 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, char *dst, co
             *y64 = jl_atomic_load((uint64_t*)dst);
             success = 0;
         }
-        break;
     }
 #endif
 #if MAX_POINTERATOMIC_SIZE >= 16
-    case 16: {
+    else if (nb <= 16) {
         uint128_t *y128 = (uint128_t*)y;
         if (dt == et) {
-            *y128 = *(uint128_t*)expected;
+            *y128 = zext_read128(expected, nb);
+            uint128_t z128 = zext_read128(src, nb);
             while (1) {
-                success = jl_atomic_cmpswap((uint128_t*)dst, y128, *(uint128_t*)src);
+                success = jl_atomic_cmpswap((uint128_t*)dst, y128, z128);
                 if (success || !dt->layout->haspadding || !jl_egal__bits(y, expected, dt))
                     break;
             }
@@ -1002,10 +1046,9 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, char *dst, co
             *y128 = jl_atomic_load((uint128_t*)dst);
             success = 0;
         }
-        break;
     }
 #endif
-    default:
+    else {
         abort();
     }
     if (isptr) {
@@ -1417,16 +1460,12 @@ static inline void memassign_safe(int hasptr, jl_value_t *parent, char *dst, con
     else {
         // src must be a heap box.
         assert(nb == jl_datatype_size(jl_typeof(src)));
+        if (nb >= 16) {
+            memcpy(dst, jl_assume_aligned(src, 16), nb);
+            return;
+        }
     }
-    switch (nb) {
-    case  0:                                               break;
-    case  1: *(uint8_t*)dst            = *(uint8_t*)src;   break;
-    case  2: jl_store_unaligned_i16(dst, *(uint16_t*)src); break;
-    case  4: jl_store_unaligned_i32(dst, *(uint32_t*)src); break;
-    case  8: jl_store_unaligned_i64(dst, *(uint64_t*)src); break;
-    case 16: memcpy(dst, jl_assume_aligned(src, 16), 16);  break;
-    default: memcpy(dst, src, nb);                         break;
-    }
+    memcpy(dst, jl_assume_aligned(src, sizeof(void*)), nb);
 }
 
 void set_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *rhs, int isatomic) JL_NOTSAFEPOINT
diff --git a/src/processor.cpp b/src/processor.cpp
index 9d4ac476ef316..c5e42368412e8 100644
--- a/src/processor.cpp
+++ b/src/processor.cpp
@@ -401,6 +401,8 @@ static inline std::vector<uint8_t> serialize_target_data(llvm::StringRef name,
 {
     std::vector<uint8_t> res;
     auto add_data = [&] (const void *data, size_t sz) {
+        if (sz == 0)
+            return;
         size_t old_sz = res.size();
         res.resize(old_sz + sz);
         memcpy(&res[old_sz], data, sz);
diff --git a/test/atomics.jl b/test/atomics.jl
index 2a0cbd7357c6e..e4202b5ce1aea 100644
--- a/test/atomics.jl
+++ b/test/atomics.jl
@@ -63,22 +63,43 @@ let (x, y) = (Complex{Int128}(10, 30), Complex{Int128}(20, 40))
     @test sizeof(r) == sizeof(ar) - Int(fieldoffset(typeof(ar), 1))
 end
 
+struct PadIntA <: Number # internal padding
+    a::Int8
+    b::Int16
+    PadIntA(x) = new(82, x)
+end
+struct PadIntB <: Number # external padding
+    a::UInt8
+    b::UInt8
+    c::UInt8
+    PadIntB(x) = new(x & 0xff, (x >> 8) & 0xff, (x >> 16) & 0xff)
+end
+primitive type Int24 <: Signed 24 end # integral padding
+Int24(x::Int) = Core.Intrinsics.trunc_int(Int24, x)
+Base.Int(x::PadIntB) = x.a + (Int(x.b) << 8) + (Int(x.c) << 16)
+Base.:(+)(x::PadIntA, b::Int) = PadIntA(x.b + b)
+Base.:(+)(x::PadIntB, b::Int) = PadIntB(Int(x) + b)
+Base.:(+)(x::Int24, b::Int) = Core.Intrinsics.add_int(x, Int24(b))
+Base.show(io::IO, x::PadIntA) = print(io, "PadIntA(", x.b, ")")
+Base.show(io::IO, x::PadIntB) = print(io, "PadIntB(", Int(x), ")")
+Base.show(io::IO, x::Int24) = print(io, "Int24(", Core.Intrinsics.zext_int(Int, x), ")")
+
 @noinline function _test_field_operators(r)
     r = r[]
     T = typeof(getfield(r, :x))
-    @test getfield(r, :x, :sequentially_consistent) === T(12345_10)
-    @test setfield!(r, :x, T(12345_1), :sequentially_consistent) === T(12345_1)
-    @test getfield(r, :x, :sequentially_consistent) === T(12345_1)
-    @test replacefield!(r, :x, 12345_1 % UInt, T(12345_100), :sequentially_consistent, :sequentially_consistent) === (T(12345_1), false)
-    @test replacefield!(r, :x, T(12345_1), T(12345_100), :sequentially_consistent, :sequentially_consistent) === (T(12345_1), true)
-    @test getfield(r, :x, :sequentially_consistent) === T(12345_100)
-    @test replacefield!(r, :x, T(12345_1), T(12345_1), :sequentially_consistent, :sequentially_consistent) === (T(12345_100), false)
-    @test getfield(r, :x, :sequentially_consistent) === T(12345_100)
-    @test modifyfield!(r, :x, add, 1, :sequentially_consistent) === (T(12345_100), T(12345_101))
-    @test modifyfield!(r, :x, add, 1, :sequentially_consistent) === (T(12345_101), T(12345_102))
-    @test getfield(r, :x, :sequentially_consistent) === T(12345_102)
-    @test swapfield!(r, :x, T(12345_1), :sequentially_consistent) === T(12345_102)
-    @test getfield(r, :x, :sequentially_consistent) === T(12345_1)
+    @test getfield(r, :x, :sequentially_consistent) === T(123_10)
+    @test setfield!(r, :x, T(123_1), :sequentially_consistent) === T(123_1)
+    @test getfield(r, :x, :sequentially_consistent) === T(123_1)
+    @test replacefield!(r, :x, 123_1 % UInt, T(123_30), :sequentially_consistent, :sequentially_consistent) === (T(123_1), false)
+    @test replacefield!(r, :x, T(123_1), T(123_30), :sequentially_consistent, :sequentially_consistent) === (T(123_1), true)
+    @test getfield(r, :x, :sequentially_consistent) === T(123_30)
+    @test replacefield!(r, :x, T(123_1), T(123_1), :sequentially_consistent, :sequentially_consistent) === (T(123_30), false)
+    @test getfield(r, :x, :sequentially_consistent) === T(123_30)
+    @test modifyfield!(r, :x, add, 1, :sequentially_consistent) === (T(123_30), T(123_31))
+    @test modifyfield!(r, :x, add, 1, :sequentially_consistent) === (T(123_31), T(123_32))
+    @test getfield(r, :x, :sequentially_consistent) === T(123_32)
+    @test swapfield!(r, :x, T(123_1), :sequentially_consistent) === T(123_32)
+    @test getfield(r, :x, :sequentially_consistent) === T(123_1)
     nothing
 end
 @noinline function test_field_operators(r)
@@ -86,11 +107,15 @@ end
     _test_field_operators(Ref{Any}(copy(r)))
     nothing
 end
-test_field_operators(ARefxy{Int}(12345_10, 12345_20))
-test_field_operators(ARefxy{Any}(12345_10, 12345_20))
-test_field_operators(ARefxy{Union{Nothing,Int}}(12345_10, nothing))
-test_field_operators(ARefxy{Complex{Int32}}(12345_10, 12345_20))
-test_field_operators(ARefxy{Complex{Int128}}(12345_10, 12345_20))
+test_field_operators(ARefxy{Int}(123_10, 123_20))
+test_field_operators(ARefxy{Any}(123_10, 123_20))
+test_field_operators(ARefxy{Union{Nothing,Int}}(123_10, nothing))
+test_field_operators(ARefxy{Complex{Int32}}(123_10, 123_20))
+test_field_operators(ARefxy{Complex{Int128}}(123_10, 123_20))
+test_field_operators(ARefxy{PadIntA}(123_10, 123_20))
+test_field_operators(ARefxy{PadIntB}(123_10, 123_20))
+#FIXME: test_field_operators(ARefxy{Int24}(123_10, 123_20))
+test_field_operators(ARefxy{Float64}(123_10, 123_20))
 
 @noinline function _test_field_orderings(r, x, y)
     @nospecialize x y
@@ -247,11 +272,13 @@ test_field_orderings(true, false)
 test_field_orderings("hi", "bye")
 test_field_orderings(:hi, :bye)
 test_field_orderings(nothing, nothing)
-test_field_orderings(ARefxy{Any}(12345_10, 12345_20), 12345_10, 12345_20)
+test_field_orderings(ARefxy{Any}(123_10, 123_20), 123_10, 123_20)
 test_field_orderings(ARefxy{Any}(true, false), true, false)
 test_field_orderings(ARefxy{Union{Nothing,Missing}}(nothing, missing), nothing, missing)
-test_field_orderings(ARefxy{Union{Nothing,Int}}(nothing, 12345_1), nothing, 12345_1)
+test_field_orderings(ARefxy{Union{Nothing,Int}}(nothing, 123_1), nothing, 123_1)
 test_field_orderings(Complex{Int128}(10, 30), Complex{Int128}(20, 40))
+test_field_orderings(10.0, 20.0)
+test_field_orderings(NaN, Inf)
 
 struct UndefComplex{T}
     re::T